restructure typed array creation
This commit is contained in:
parent
98cb5fc310
commit
096a7c7637
91
src/c32arr.c
91
src/c32arr.c
@ -6,48 +6,26 @@ typedef struct C32Arr {
|
||||
} C32Arr;
|
||||
|
||||
|
||||
B m_c32arrv(usz ia) {
|
||||
B r = m_arr(fsizeof(C32Arr,a,u32,ia), t_c32arr);
|
||||
arr_shVec(r, ia);
|
||||
return r;
|
||||
B m_c32arrv(u32** p, usz ia) {
|
||||
C32Arr* r = mm_allocN(fsizeof(C32Arr,a,u32,ia), t_c32arr); B rb = tag(r, ARR_TAG);
|
||||
*p = r->a;
|
||||
arr_shVec(rb, ia);
|
||||
return rb;
|
||||
}
|
||||
B m_c32arrc(B x) { assert(isArr(x));
|
||||
B r = m_arr(fsizeof(C32Arr,a,u32,a(x)->ia), t_c32arr);
|
||||
arr_shCopy(r, x);
|
||||
return r;
|
||||
B m_c32arrc(u32** p, B x) { assert(isArr(x));
|
||||
C32Arr* r = mm_allocN(fsizeof(C32Arr,a,u32,a(x)->ia), t_c32arr); B rb = tag(r, ARR_TAG);
|
||||
*p = r->a;
|
||||
arr_shCopy(rb, x);
|
||||
return rb;
|
||||
}
|
||||
B m_c32arrp(usz ia) { // doesn't write shape/rank
|
||||
B r = m_arr(fsizeof(C32Arr,a,u32,ia), t_c32arr);
|
||||
a(r)->ia = ia;
|
||||
return r;
|
||||
B m_c32arrp(u32** p, usz ia) { // doesn't write shape/rank
|
||||
C32Arr* r = mm_allocN(fsizeof(C32Arr,a,u32,ia), t_c32arr);
|
||||
*p = r->a;
|
||||
r->ia = ia;
|
||||
return tag(r, ARR_TAG);
|
||||
}
|
||||
|
||||
|
||||
u32* c32arr_ptr(B x) { VT(x, t_c32arr); return c(C32Arr,x)->a; }
|
||||
|
||||
B m_str8(usz sz, char* s) {
|
||||
B r = m_c32arrv(sz); u32* rp = c32arr_ptr(r);
|
||||
for (u64 i = 0; i < sz; i++) rp[i] = (u32)s[i];
|
||||
return r;
|
||||
}
|
||||
NOINLINE B m_str32(u32* s) {
|
||||
usz sz = 0; while(s[sz]) sz++;
|
||||
B r = m_c32arrv(sz); u32* rp = c32arr_ptr(r);
|
||||
for (usz i = 0; i < sz; i++) rp[i] = s[i];
|
||||
return r;
|
||||
}
|
||||
|
||||
C32Arr* toC32Arr(B x) {
|
||||
if (v(x)->type==t_c32arr) return c(C32Arr,x);
|
||||
B r = m_c32arrc(x);
|
||||
u32* rp = c32arr_ptr(r);
|
||||
usz ia = a(r)->ia;
|
||||
BS2B xgetU = TI(x).getU;
|
||||
for (usz i = 0; i < ia; i++) rp[i] = o2c(xgetU(x,i));
|
||||
dec(x);
|
||||
return c(C32Arr,r);
|
||||
}
|
||||
|
||||
typedef struct C32Slice {
|
||||
struct Slice;
|
||||
u32* a;
|
||||
@ -59,16 +37,30 @@ B m_c32slice(B p, u32* ptr) {
|
||||
return tag(r, ARR_TAG);
|
||||
}
|
||||
|
||||
B c32arr_slice (B x, usz s) {return m_c32slice(x , c(C32Arr ,x)->a+s); }
|
||||
B c32slice_slice(B x, usz s) { B r = m_c32slice(inc(c(Slice,x)->p), c(C32Slice,x)->a+s); dec(x); return r; }
|
||||
|
||||
|
||||
B c32arr_get (B x, usz n) { VT(x,t_c32arr ); return m_c32(c(C32Arr ,x)->a[n]); }
|
||||
B c32slice_get(B x, usz n) { VT(x,t_c32slice); return m_c32(c(C32Slice,x)->a[n]); }
|
||||
void c32arr_free(B x) { decSh(x); }
|
||||
bool c32arr_canStore(B x) { return isC32(x); }
|
||||
|
||||
u32* c32arr_ptr(B x) { VT(x, t_c32arr); return c(C32Arr,x)->a; }
|
||||
u32* c32any_ptr(B x) { assert(isArr(x)); u8 t=v(x)->type; if(t==t_c32arr) return c(C32Arr,x)->a; assert(t==t_c32slice); return c(C32Slice,x)->a; }
|
||||
|
||||
B m_str8(usz sz, char* s) {
|
||||
u32* rp; B r = m_c32arrv(&rp, sz);
|
||||
for (u64 i = 0; i < sz; i++) rp[i] = (u32)s[i];
|
||||
return r;
|
||||
}
|
||||
NOINLINE B m_str32(u32* s) {
|
||||
usz sz = 0; while(s[sz]) sz++;
|
||||
u32* rp; B r = m_c32arrv(&rp, sz);
|
||||
for (usz i = 0; i < sz; i++) rp[i] = s[i];
|
||||
return r;
|
||||
}
|
||||
C32Arr* toC32Arr(B x) {
|
||||
if (v(x)->type==t_c32arr) return c(C32Arr,x);
|
||||
u32* rp; B r = m_c32arrc(&rp, x);
|
||||
usz ia = a(r)->ia;
|
||||
BS2B xgetU = TI(x).getU;
|
||||
for (usz i = 0; i < ia; i++) rp[i] = o2c(xgetU(x,i));
|
||||
dec(x);
|
||||
return c(C32Arr,r);
|
||||
}
|
||||
bool eqStr(B w, u32* x) {
|
||||
if (isAtm(w) || rnk(w)!=1) return false;
|
||||
BS2B wgetU = TI(w).getU;
|
||||
@ -82,6 +74,14 @@ bool eqStr(B w, u32* x) {
|
||||
}
|
||||
|
||||
|
||||
B c32arr_slice (B x, usz s) {return m_c32slice(x , c(C32Arr ,x)->a+s); }
|
||||
B c32slice_slice(B x, usz s) { B r = m_c32slice(inc(c(Slice,x)->p), c(C32Slice,x)->a+s); dec(x); return r; }
|
||||
|
||||
B c32arr_get (B x, usz n) { VT(x,t_c32arr ); return m_c32(c(C32Arr ,x)->a[n]); }
|
||||
B c32slice_get(B x, usz n) { VT(x,t_c32slice); return m_c32(c(C32Slice,x)->a[n]); }
|
||||
void c32arr_free(B x) { decSh(x); }
|
||||
bool c32arr_canStore(B x) { return isC32(x); }
|
||||
|
||||
static inline void c32arr_init() {
|
||||
ti[t_c32arr].get = c32arr_get; ti[t_c32slice].get = c32slice_get;
|
||||
ti[t_c32arr].getU = c32arr_get; ti[t_c32slice].getU = c32slice_get;
|
||||
@ -91,5 +91,6 @@ static inline void c32arr_init() {
|
||||
ti[t_c32arr].print = arr_print; ti[t_c32slice].print = arr_print;
|
||||
ti[t_c32arr].isArr = true; ti[t_c32slice].isArr = true;
|
||||
ti[t_i32arr].arrD1 = true; ti[t_i32slice].arrD1 = true;
|
||||
ti[t_c32arr].elType = el_c32; ti[t_c32slice].elType = el_c32;
|
||||
ti[t_c32arr].canStore = c32arr_canStore;
|
||||
}
|
||||
|
||||
32
src/f64arr.c
32
src/f64arr.c
@ -6,20 +6,23 @@ typedef struct F64Arr {
|
||||
} F64Arr;
|
||||
|
||||
|
||||
B m_f64arrv(usz ia) {
|
||||
B r = m_arr(fsizeof(F64Arr,a,f64,ia), t_f64arr);
|
||||
arr_shVec(r, ia);
|
||||
return r;
|
||||
B m_f64arrv(f64** p, usz ia) {
|
||||
F64Arr* r = mm_allocN(fsizeof(F64Arr,a,f64,ia), t_f64arr); B rb = tag(r, ARR_TAG);
|
||||
*p = r->a;
|
||||
arr_shVec(rb, ia);
|
||||
return rb;
|
||||
}
|
||||
B m_f64arrc(B x) { assert(isArr(x));
|
||||
B r = m_arr(fsizeof(F64Arr,a,f64,a(x)->ia), t_f64arr);
|
||||
arr_shCopy(r, x);
|
||||
return r;
|
||||
B m_f64arrc(f64** p, B x) { assert(isArr(x));
|
||||
F64Arr* r = mm_allocN(fsizeof(F64Arr,a,f64,a(x)->ia), t_f64arr); B rb = tag(r, ARR_TAG);
|
||||
*p = r->a;
|
||||
arr_shCopy(rb, x);
|
||||
return rb;
|
||||
}
|
||||
B m_f64arrp(usz ia) { // doesn't write shape/rank
|
||||
B r = m_arr(fsizeof(F64Arr,a,f64,ia), t_f64arr);
|
||||
a(r)->ia = ia;
|
||||
return r;
|
||||
B m_f64arrp(f64** p, usz ia) { // doesn't write shape/rank
|
||||
F64Arr* r = mm_allocN(fsizeof(F64Arr,a,f64,ia), t_f64arr);
|
||||
*p = r->a;
|
||||
r->ia = ia;
|
||||
return tag(r, ARR_TAG);
|
||||
}
|
||||
|
||||
|
||||
@ -39,15 +42,14 @@ f64* f64arr_ptr(B x) { VT(x, t_f64arr); return c(F64Arr,x)->a; }
|
||||
f64* f64any_ptr(B x) { assert(isArr(x)); u8 t=v(x)->type; if(t==t_f64arr) return c(F64Arr,x)->a; assert(t==t_f64slice); return c(F64Slice,x)->a; }
|
||||
|
||||
NOINLINE B m_caf64(usz sz, f64* a) {
|
||||
B r = m_f64arrv(sz); f64* rp = f64arr_ptr(r);
|
||||
f64* rp; B r = m_f64arrv(&rp, sz);
|
||||
for (usz i = 0; i < sz; i++) rp[i] = a[i];
|
||||
return r;
|
||||
}
|
||||
|
||||
F64Arr* toF64Arr(B x) {
|
||||
if (v(x)->type==t_f64arr) return c(F64Arr,x);
|
||||
B r = m_f64arrc(x);
|
||||
f64* rp = f64arr_ptr(r);
|
||||
f64* rp; B r = m_f64arrc(&rp, x);
|
||||
usz ia = a(r)->ia;
|
||||
BS2B xgetU = TI(x).getU;
|
||||
for (usz i = 0; i < ia; i++) rp[i] = o2f(xgetU(x,i));
|
||||
|
||||
@ -113,14 +113,14 @@ B m_unit(B x) {
|
||||
B m_atomUnit(B x) {
|
||||
if (isNum(x)) {
|
||||
B r;
|
||||
if (q_i32(x)) { r=m_i32arrp(1); i32arr_ptr(r)[0] = o2iu(x); }
|
||||
else { r=m_f64arrp(1); f64arr_ptr(r)[0] = o2fu(x); }
|
||||
if (q_i32(x)) { i32* rp; r=m_i32arrp(&rp, 1); rp[0] = o2iu(x); }
|
||||
else { f64* rp; r=m_f64arrp(&rp, 1); rp[0] = o2fu(x); }
|
||||
arr_shAllocR(r,0);
|
||||
return r;
|
||||
}
|
||||
if (isC32(x)) {
|
||||
B r = m_c32arrp(1);
|
||||
c32arr_ptr(r)[0] = o2cu(x);
|
||||
u32* rp; B r = m_c32arrp(&rp, 1);
|
||||
rp[0] = o2cu(x);
|
||||
arr_shAllocR(r,0);
|
||||
return r;
|
||||
}
|
||||
@ -204,7 +204,7 @@ B withFill(B x, B fill) { // consumes both
|
||||
if (v(x)->type==t_harr) {
|
||||
B* xp = harr_ptr(x);
|
||||
{
|
||||
B r = m_i32arrc(x); i32* rp = i32arr_ptr(r);
|
||||
i32* rp; B r = m_i32arrc(&rp, x);
|
||||
for (usz i = 0; i < ia; i++) {
|
||||
B c = xp[i];
|
||||
if (!q_i32(c)) { dec(r); goto h_f64; }
|
||||
@ -214,7 +214,7 @@ B withFill(B x, B fill) { // consumes both
|
||||
return r;
|
||||
}
|
||||
h_f64: {
|
||||
B r = m_f64arrc(x); f64* rp = f64arr_ptr(r);
|
||||
f64* rp; B r = m_f64arrc(&rp, x);
|
||||
for (usz i = 0; i < ia; i++) {
|
||||
B c = xp[i];
|
||||
if (!q_f64(c)) { dec(r); goto base; }
|
||||
@ -226,7 +226,7 @@ B withFill(B x, B fill) { // consumes both
|
||||
} else {
|
||||
BS2B xgetU = TI(x).getU;
|
||||
{
|
||||
B r = m_i32arrc(x); i32* rp = i32arr_ptr(r);
|
||||
i32* rp; B r = m_i32arrc(&rp, x);
|
||||
for (usz i = 0; i < ia; i++) {
|
||||
B c = xgetU(x, i);
|
||||
if (!q_i32(c)) { dec(r); goto g_f64; }
|
||||
@ -236,7 +236,7 @@ B withFill(B x, B fill) { // consumes both
|
||||
return r;
|
||||
}
|
||||
g_f64: {
|
||||
B r = m_f64arrc(x); f64* rp = f64arr_ptr(r);
|
||||
f64* rp; B r = m_f64arrc(&rp, x);
|
||||
for (usz i = 0; i < ia; i++) {
|
||||
B c = xgetU(x, i);
|
||||
if (!q_f64(c)) { dec(r); goto base; }
|
||||
@ -265,7 +265,7 @@ B withFill(B x, B fill) { // consumes both
|
||||
// }
|
||||
}
|
||||
} else if (isC32(fill)) {
|
||||
B r = m_c32arrc(x); u32* rp = c32arr_ptr(r);
|
||||
u32* rp; B r = m_c32arrc(&rp, x);
|
||||
BS2B xgetU = TI(x).getU;
|
||||
for (usz i = 0; i < ia; i++) {
|
||||
B c = xgetU(x, i);
|
||||
|
||||
13
src/fns.c
13
src/fns.c
@ -13,11 +13,11 @@ B funBI_identity(B x) { return inc(c(BFn,x)->ident); }
|
||||
B ud_c1(B t, B x) {
|
||||
usz xu = o2s(x);
|
||||
if (xu<I32_MAX) {
|
||||
B r = m_i32arrv(xu); i32* rp = i32arr_ptr(r);
|
||||
i32* rp; B r = m_i32arrv(&rp, xu);
|
||||
for (usz i = 0; i < xu; i++) rp[i] = i;
|
||||
return r;
|
||||
}
|
||||
B r = m_f64arrv(xu); f64* rp = f64arr_ptr(r);
|
||||
f64* rp; B r = m_f64arrv(&rp, xu);
|
||||
for (usz i = 0; i < xu; i++) rp[i] = i;
|
||||
return r;
|
||||
}
|
||||
@ -64,18 +64,19 @@ B fne_c1(B t, B x) {
|
||||
ur xr = rnk(x);
|
||||
usz* sh = a(x)->sh;
|
||||
for (i32 i = 0; i < xr; i++) if (sh[i]>I32_MAX) {
|
||||
B r = m_f64arrv(xr); f64* rp = f64arr_ptr(r);
|
||||
f64* rp; B r = m_f64arrv(&rp, xr);
|
||||
for (i32 j = 0; j < xr; j++) rp[j] = sh[j];
|
||||
dec(x);
|
||||
return r;
|
||||
}
|
||||
B r = m_i32arrv(xr); i32* rp = i32arr_ptr(r);
|
||||
i32* rp;
|
||||
B r = m_i32arrv(&rp, xr);
|
||||
for (i32 i = 0; i < xr; i++) rp[i] = sh[i];
|
||||
dec(x);
|
||||
return r;
|
||||
} else {
|
||||
dec(x);
|
||||
return m_i32arrv(0);
|
||||
dec(x); i32* tmp;
|
||||
return m_i32arrv(&tmp, 0);
|
||||
}
|
||||
}
|
||||
u64 depth(B x) { // doesn't consume
|
||||
|
||||
14
src/grade.c
14
src/grade.c
@ -28,11 +28,10 @@ B gradeUp_c1(B t, B x) {
|
||||
// if (c>max) max=c;
|
||||
// }
|
||||
|
||||
B r = m_i32arrv(ia);
|
||||
i32* ri = i32arr_ptr(r);
|
||||
i32* rp; B r = m_i32arrv(&rp, ia);
|
||||
i32 tmp[ia];
|
||||
for (usz i = 0; i < ia; i++) tmp[i] = ri[i] = i;
|
||||
gradeUp_rec(xp, tmp, ri, 0, ia);
|
||||
for (usz i = 0; i < ia; i++) tmp[i] = rp[i] = i;
|
||||
gradeUp_rec(xp, tmp, rp, 0, ia);
|
||||
dec(x);
|
||||
return r;
|
||||
}
|
||||
@ -55,8 +54,7 @@ B gradeUp_c2(B t, B w, B x) {
|
||||
u8 xe = TI(x).elType; usz xia = a(x)->ia;
|
||||
|
||||
if (wia>I32_MAX-10) thrM("⍋: 𝕨 too big");
|
||||
B r = m_i32arrc(x);
|
||||
i32* ri = i32arr_ptr(r);
|
||||
i32* rp; B r = m_i32arrc(&rp, x);
|
||||
|
||||
if (we==el_i32 & xe==el_i32) {
|
||||
i32* wi = i32any_ptr(w);
|
||||
@ -71,7 +69,7 @@ B gradeUp_c2(B t, B w, B x) {
|
||||
if (c < wi[m-1]) e = m;
|
||||
else s = m;
|
||||
}
|
||||
ri[i] = s;
|
||||
rp[i] = s;
|
||||
}
|
||||
} else {
|
||||
BS2B wgetU = TI(w).getU;
|
||||
@ -86,7 +84,7 @@ B gradeUp_c2(B t, B w, B x) {
|
||||
if (compare(c, wgetU(w,m-1)) < 0) e = m;
|
||||
else s = m;
|
||||
}
|
||||
ri[i] = s;
|
||||
rp[i] = s;
|
||||
}
|
||||
}
|
||||
dec(w);dec(x);
|
||||
|
||||
32
src/i32arr.c
32
src/i32arr.c
@ -6,20 +6,23 @@ typedef struct I32Arr {
|
||||
} I32Arr;
|
||||
|
||||
|
||||
B m_i32arrv(usz ia) {
|
||||
B r = m_arr(fsizeof(I32Arr,a,i32,ia), t_i32arr);
|
||||
arr_shVec(r, ia);
|
||||
return r;
|
||||
B m_i32arrv(i32** p, usz ia) {
|
||||
I32Arr* r = mm_allocN(fsizeof(I32Arr,a,i32,ia), t_i32arr); B rb = tag(r, ARR_TAG);
|
||||
*p = r->a;
|
||||
arr_shVec(rb, ia);
|
||||
return rb;
|
||||
}
|
||||
B m_i32arrc(B x) { assert(isArr(x));
|
||||
B r = m_arr(fsizeof(I32Arr,a,i32,a(x)->ia), t_i32arr);
|
||||
arr_shCopy(r, x);
|
||||
return r;
|
||||
B m_i32arrc(i32** p, B x) { assert(isArr(x));
|
||||
I32Arr* r = mm_allocN(fsizeof(I32Arr,a,i32,a(x)->ia), t_i32arr); B rb = tag(r, ARR_TAG);
|
||||
*p = r->a;
|
||||
arr_shCopy(rb, x);
|
||||
return rb;
|
||||
}
|
||||
B m_i32arrp(usz ia) { // doesn't write shape/rank
|
||||
B r = m_arr(fsizeof(I32Arr,a,i32,ia), t_i32arr);
|
||||
a(r)->ia = ia;
|
||||
return r;
|
||||
B m_i32arrp(i32** p, usz ia) { // doesn't write shape/rank
|
||||
I32Arr* r = mm_allocN(fsizeof(I32Arr,a,i32,ia), t_i32arr);
|
||||
*p = r->a;
|
||||
r->ia = ia;
|
||||
return tag(r, ARR_TAG);
|
||||
}
|
||||
|
||||
|
||||
@ -39,15 +42,14 @@ i32* i32arr_ptr(B x) { VT(x, t_i32arr); return c(I32Arr,x)->a; }
|
||||
i32* i32any_ptr(B x) { assert(isArr(x)); u8 t=v(x)->type; if(t==t_i32arr) return c(I32Arr,x)->a; assert(t==t_i32slice); return c(I32Slice,x)->a; }
|
||||
|
||||
NOINLINE B m_cai32(usz ia, i32* a) {
|
||||
B r = m_i32arrv(ia); i32* rp = i32arr_ptr(r);
|
||||
i32* rp; B r = m_i32arrv(&rp, ia);
|
||||
for (usz i = 0; i < ia; i++) rp[i] = a[i];
|
||||
return r;
|
||||
}
|
||||
|
||||
I32Arr* toI32Arr(B x) {
|
||||
if (v(x)->type==t_i32arr) return c(I32Arr,x);
|
||||
B r = m_i32arrc(x);
|
||||
i32* rp = i32arr_ptr(r);
|
||||
i32* rp; B r = m_i32arrc(&rp, x);
|
||||
usz ia = a(r)->ia;
|
||||
BS2B xgetU = TI(x).getU;
|
||||
for (usz i = 0; i < ia; i++) rp[i] = o2i(xgetU(x,i));
|
||||
|
||||
15
src/mut.c
15
src/mut.c
@ -10,11 +10,12 @@ void mut_to(Mut* m, u8 n) {
|
||||
assert(o!=el_B);
|
||||
m->type = n;
|
||||
if (o==el_MAX) {
|
||||
void* t;
|
||||
switch(n) { default: UD;
|
||||
case el_i32: m->val = a(m_i32arrp(m->ia)) ; return;
|
||||
case el_f64: m->val = a(m_f64arrp(m->ia)) ; return;
|
||||
case el_c32: m->val = a(m_c32arrp(m->ia)) ; return;
|
||||
case el_B : m->val = (Arr*)m_harrUp(m->ia).c; return;
|
||||
case el_i32: m->val = a(m_i32arrp((i32**)&t, m->ia)) ; return;
|
||||
case el_f64: m->val = a(m_f64arrp((f64**)&t, m->ia)) ; return;
|
||||
case el_c32: m->val = a(m_c32arrp((u32**)&t, m->ia)) ; return;
|
||||
case el_B : m->val = (Arr*)m_harrUp( m->ia).c; return;
|
||||
}
|
||||
} else {
|
||||
sprnk(m->val, 1);
|
||||
@ -135,10 +136,8 @@ void mut_copy(Mut* m, usz ms, B x, usz xs, usz l) {
|
||||
return;
|
||||
}
|
||||
case el_c32: {
|
||||
u32* xp;
|
||||
if (xt==t_c32arr) xp = c32arr_ptr(x);
|
||||
else if (xt==t_c32slice) xp = c(C32Slice,x)->a;
|
||||
else AGAIN;
|
||||
if (xt!=t_c32arr & xt!=t_c32slice) AGAIN;
|
||||
u32* xp = c32any_ptr(x);
|
||||
memcpy(((C32Arr*)m->val)->a+ms, xp+xs, l*4);
|
||||
return;
|
||||
}
|
||||
|
||||
28
src/sfns.c
28
src/sfns.c
@ -72,8 +72,9 @@ B eachm_fn(BB2B f, B fo, B x) { // consumes x; x must be array
|
||||
}
|
||||
} else if (v(x)->type==t_i32arr) {
|
||||
i32* xp = i32arr_ptr(x);
|
||||
B r = reuse? x : m_i32arrc(x);
|
||||
i32* rp = i32arr_ptr(r);
|
||||
B r; i32* rp;
|
||||
if (reuse) { r=x; rp = xp; }
|
||||
else r = m_i32arrc(&rp, x);
|
||||
rp[i++] = o2iu(cr);
|
||||
for (; i < ia; i++) {
|
||||
cr = f(fo, m_i32(xp[i]));
|
||||
@ -89,8 +90,9 @@ B eachm_fn(BB2B f, B fo, B x) { // consumes x; x must be array
|
||||
return r;
|
||||
} else if (v(x)->type==t_f64arr) {
|
||||
f64* xp = f64arr_ptr(x);
|
||||
B r = reuse? x : m_f64arrc(x);
|
||||
f64* rp = f64arr_ptr(r);
|
||||
B r; f64* rp;
|
||||
if (reuse) { r=x; rp = xp; }
|
||||
else r = m_f64arrc(&rp, x);
|
||||
rp[i++] = o2fu(cr);
|
||||
for (; i < ia; i++) {
|
||||
cr = f(fo, m_f64(xp[i]));
|
||||
@ -234,7 +236,7 @@ B select_c2(B t, B w, B x) {
|
||||
if (v(w)->type==t_i32arr | v(w)->type==t_i32slice) {
|
||||
i32* wp = v(w)->type==t_i32slice? c(I32Slice,w)->a : i32arr_ptr(w);
|
||||
if (v(x)->type==t_i32arr) {
|
||||
B r = m_i32arrc(w); i32* rp = i32arr_ptr(r);
|
||||
i32* rp; B r = m_i32arrc(&rp, w);
|
||||
i32* xp = i32arr_ptr(x);
|
||||
for (usz i = 0; i < wia; i++) {
|
||||
i64 c = wp[i];
|
||||
@ -311,7 +313,7 @@ B slash_c1(B t, B x) {
|
||||
BS2B xgetU = TI(x).getU;
|
||||
usz ri = 0;
|
||||
if (xia<I32_MAX) {
|
||||
B r = m_i32arrv(s); i32* rp = i32arr_ptr(r);
|
||||
i32* rp; B r = m_i32arrv(&rp, s);
|
||||
for (i32 i = 0; i < xia; i++) {
|
||||
usz c = o2s(xgetU(x, i));
|
||||
for (usz j = 0; j < c; j++) rp[ri++] = i;
|
||||
@ -319,7 +321,7 @@ B slash_c1(B t, B x) {
|
||||
dec(x);
|
||||
return r;
|
||||
}
|
||||
B r = m_f64arrv(s); f64* rp = f64arr_ptr(r);
|
||||
f64* rp; B r = m_f64arrv(&rp, s);
|
||||
for (usz i = 0; i < xia; i++) {
|
||||
usz c = o2s(xgetU(x, i));
|
||||
for (usz j = 0; j < c; j++) rp[ri++] = i;
|
||||
@ -476,18 +478,18 @@ B couple_c1(B t, B x) {
|
||||
dec(x);
|
||||
return r;
|
||||
}
|
||||
if (q_i32(x)) { B r = m_i32arrv(1); i32arr_ptr(r)[0] = o2iu(x); return r; }
|
||||
if (isF64(x)) { B r = m_f64arrv(1); f64arr_ptr(r)[0] = o2fu(x); return r; }
|
||||
if (isC32(x)) { B r = m_c32arrv(1); c32arr_ptr(r)[0] = o2cu(x); return r; }
|
||||
if (q_i32(x)) { i32* rp; B r = m_i32arrv(&rp, 1); rp[0] = o2iu(x); return r; }
|
||||
if (isF64(x)) { f64* rp; B r = m_f64arrv(&rp, 1); rp[0] = o2fu(x); return r; }
|
||||
if (isC32(x)) { u32* rp; B r = m_c32arrv(&rp, 1); rp[0] = o2cu(x); return r; }
|
||||
HArr_p r = m_harrUv(1);
|
||||
r.a[0] = x;
|
||||
return r.b;
|
||||
}
|
||||
B couple_c2(B t, B w, B x) {
|
||||
if (isAtm(w)&isAtm(x)) {
|
||||
if (q_i32(x)&q_i32(w)) { B r = m_i32arrv(2); i32* rp=i32arr_ptr(r); rp[0]=o2iu(w); rp[1]=o2iu(x); return r; }
|
||||
if (isF64(x)&isF64(w)) { B r = m_f64arrv(2); f64* rp=f64arr_ptr(r); rp[0]=o2fu(w); rp[1]=o2fu(x); return r; }
|
||||
if (isC32(x)&isC32(w)) { B r = m_c32arrv(2); u32* rp=c32arr_ptr(r); rp[0]=o2cu(w); rp[1]=o2cu(x); return r; }
|
||||
if (q_i32(x)&q_i32(w)) { i32* rp; B r = m_i32arrv(&rp, 2); rp[0]=o2iu(w); rp[1]=o2iu(x); return r; }
|
||||
if (isF64(x)&isF64(w)) { f64* rp; B r = m_f64arrv(&rp, 2); rp[0]=o2fu(w); rp[1]=o2fu(x); return r; }
|
||||
if (isC32(x)&isC32(w)) { u32* rp; B r = m_c32arrv(&rp, 2); rp[0]=o2cu(w); rp[1]=o2cu(x); return r; }
|
||||
}
|
||||
if (isAtm(w)) w = m_atomUnit(w);
|
||||
if (isAtm(x)) x = m_atomUnit(x);
|
||||
|
||||
@ -56,7 +56,7 @@ B grLen_c1(B t, B x) { // assumes valid arguments
|
||||
if (c>ria) ria = c;
|
||||
}
|
||||
ria++;
|
||||
B r = m_i32arrv(ria); i32* rp = i32arr_ptr(r);
|
||||
i32* rp; B r = m_i32arrv(&rp, ria);
|
||||
for (usz i = 0; i < ria; i++) rp[i] = 0;
|
||||
for (usz i = 0; i < ia; i++) {
|
||||
i64 n = o2i64u(xgetU(x, i));
|
||||
@ -75,7 +75,7 @@ B grLen_c2(B t, B w, B x) { // assumes valid arguments
|
||||
if (c>ria) ria = c;
|
||||
}
|
||||
ria++;
|
||||
B r = m_i32arrv(ria); i32* rp = i32arr_ptr(r);
|
||||
i32* rp; B r = m_i32arrv(&rp, ria);
|
||||
for (usz i = 0; i < ria; i++) rp[i] = 0;
|
||||
for (usz i = 0; i < ia; i++) {
|
||||
i64 n = o2i64u(xgetU(x, i));
|
||||
@ -97,7 +97,7 @@ B grOrd_c2(B t, B w, B x) { // assumes valid arguments
|
||||
tmp[0] = 0;
|
||||
for (usz i = 1; i < wia; i++) tmp[i] = tmp[i-1]+o2su(wgetU(w,i-1));
|
||||
usz ria = tmp[wia-1]+o2su(wgetU(w,wia-1));
|
||||
B r = m_i32arrv(ria); i32* rp = i32arr_ptr(r);
|
||||
i32* rp; B r = m_i32arrv(&rp, ria);
|
||||
if (xia>=I32_MAX) thrM("grOrd: Too large");
|
||||
for (usz i = 0; i < xia; i++) {
|
||||
i64 c = o2i64(xgetU(x,i));
|
||||
|
||||
Loading…
Reference in New Issue
Block a user