replace all bitarr_ptr usages with bitany_ptr

This commit is contained in:
dzaima 2024-08-15 17:07:04 +03:00
parent 88de336516
commit 5098781ffc
21 changed files with 61 additions and 61 deletions

View File

@ -325,7 +325,7 @@ B c = IGet(x,n); // skip the initialize/call separation; not suggested in loops
B c = IGetU(x,n);
// for specific array types:
if (TI(x,elType)==el_i32) i32* xp = i32any_ptr(x); // for either t_i32arr or t_i32slice; for t_i32arr only, there's i32arr_ptr(x); same for all other primitive element types (except bitarr which only has bitarr_ptr)
if (TI(x,elType)==el_i32) i32* xp = i32any_ptr(x); // for either t_i32arr or t_i32slice; for t_i32arr only, there's i32arr_ptr(x); same for all other primitive element types (bitarr has bitany_ptr but no slice type yet)
if (TI(x,elType)!=el_B) void* xp = tyany_ptr(x); // alternative equivalent check: IS_ANY_ARR(TY(x)); tyarr_ptr if the input is also known to not be a slice
if (TY(x)==t_harr) B* xp = harr_ptr(x);
if (TY(x)==t_harr || TY(x)==t_hslice) B* xp = hany_ptr(x); // note that elType==el_B doesn't imply hany_ptr is safe!

View File

@ -239,7 +239,7 @@ static B modint_AS(B w, B xv) { return modint_AA(w, C2(shape, C1(fne, incG(w))
#else
static NOINLINE B bit_sel1Fn(FC2 f, B w, B x, bool bitX) { // consumes both
B b = bitX? x : w;
u64* bp = bitarr_ptr(b);
u64* bp = bitany_ptr(b);
usz ia = IA(b);
bool b0 = ia? bp[0]&1 : 0;
@ -270,13 +270,13 @@ static B modint_AS(B w, B xv) { return modint_AA(w, C2(shape, C1(fne, incG(w))
static B bitAA0(B w, B x, usz ia) { UD; }
static NOINLINE B bitAA1(B w, B x, usz ia) {
u64* rp; B r = m_bitarrc(&rp, x);
u64* wp=bitarr_ptr(w); u64* xp=bitarr_ptr(x);
u64* wp=bitany_ptr(w); u64* xp=bitany_ptr(x);
vfor (usz i=0; i<BIT_N(ia); i++) rp[i] = wp[i]|xp[i];
decG(w); decG(x); return r;
}
static NOINLINE B bitAA2(B w, B x, usz ia) {
u64* rp; B r = m_bitarrc(&rp, x);
u64* wp=bitarr_ptr(w); u64* xp=bitarr_ptr(x);
u64* wp=bitany_ptr(w); u64* xp=bitany_ptr(x);
vfor (usz i=0; i<BIT_N(ia); i++) rp[i] = wp[i]&xp[i];
decG(w); decG(x); return r;
}

View File

@ -14,7 +14,7 @@ void bit_negatePtr(u64* rp, u64* xp, usz count) {
vfor (usz i = 0; i < count; i++) rp[i] = ~xp[i];
}
B bit_negate(B x) { // consumes
u64* xp = bitarr_ptr(x);
u64* xp = bitany_ptr(x);
u64* rp; B r = m_bitarrc(&rp, x);
bit_negatePtr(rp, xp, BIT_N(IA(x)));
decG(x);

View File

@ -293,10 +293,10 @@ static void set_column_typed(void* rp, B v, u8 e, ux p, ux stride, ux n) { // ma
bit_special:;
bool b = o2bG(v);
B m1 = taga(arr_shVec(b? allZeroes(stride) : allOnes(stride)));
bitp_set(bitarr_ptr(m1), p, b);
bitp_set(bitany_ptr(m1), p, b);
B m = C2(shape, m_f64(stride*n+8), m1); // +8 to make the following loops reading past-the-end read acceptable values
assert(TI(m,elType)==el_bit);
u8* mp = (u8*)bitarr_ptr(m);
u8* mp = (u8*)bitany_ptr(m);
if (b) for (ux i = 0; i < (stride*n+7)/8; i++) ((u8*)rp)[i]|= mp[i]; // TODO call some general fns for this
else for (ux i = 0; i < (stride*n+7)/8; i++) ((u8*)rp)[i]&= mp[i];
decG(m);

View File

@ -210,7 +210,7 @@ B fold_c1(Md1D* d, B x) { B f = d->f;
if (rtid==n_rtack) { B r = IGet(x, ia-1); decG(x); return r; }
if (xe>el_f64) goto base;
if (xe==el_bit) {
u64* xp = bitarr_ptr(x);
u64* xp = bitany_ptr(x);
f64 r;
switch (rtid) { default: goto base;
case n_mul:
@ -287,7 +287,7 @@ B fold_c2(Md1D* d, B w, B x) { B f = d->f;
f64 wf = o2fG(w);
if (xe==el_bit) {
i32 wi = wf; if (wi!=wf) goto base;
u64* xp = bitarr_ptr(x);
u64* xp = bitany_ptr(x);
if (rtid==n_add) { B r = m_f64(wi + bit_sum (xp, ia)); decG(x); return r; }
if (rtid==n_sub) { B r = m_f64((ia&1?-wi:wi) + bit_diff(xp, ia)); decG(x); return r; }
if (wi!=(wi&1)) goto base;
@ -351,7 +351,7 @@ u64 usum(B x) { // doesn't consume; will error on non-integers, or elements <0,
u64 r = 0;
usz xia = IA(x);
u8 xe = TI(x,elType);
if (xe==el_bit) return bit_sum(bitarr_ptr(x), xia);
if (xe==el_bit) return bit_sum(bitany_ptr(x), xia);
else if (xe==el_i8 ) { i8* p = i8any_ptr (x); i8 m=0; for (usz i = 0; i < xia; ) { usz b=1<< 8; i16 s=0; for (usz e = xia-i<b?xia:i+b; i < e; i++) { m|=p[i]; s+=p[i]; } if (m<0) goto neg; if (addOn(r,(u16)s)) goto overflow; } }
else if (xe==el_i16) { i16* p = i16any_ptr(x); i16 m=0; for (usz i = 0; i < xia; ) { usz b=1<<16; i32 s=0; for (usz e = xia-i<b?xia:i+b; i < e; i++) { m|=p[i]; s+=p[i]; } if (m<0) goto neg; if (addOn(r,(u32)s)) goto overflow; } }
else if (xe==el_i32) { i32* p = i32any_ptr(x); i32 m=0; for (usz i = 0; i < xia; i++) { m|=p[i]; if (addOn(r,p[i])) { if (m<0) goto neg; else goto overflow; } } if (m<0) goto neg; }
@ -551,7 +551,7 @@ B fold_rows(Md1D* fd, B x, usz n, usz m) {
}
B sum_rows_bit(B x, usz n, usz m) {
u64* xp = bitarr_ptr(x);
u64* xp = bitany_ptr(x);
if (m < 128) {
if (m == 2) return bi_N; // Transpose is faster
i8* rp; B r = m_i8arrv(&rp, n);
@ -635,11 +635,11 @@ B fold_rows_bit(Md1D* fd, B x, usz n, usz m) {
u64* yp; B y = m_bitarrv(&yp, c);
u8 e = el_i8 + f-3;
CmpASFn cmp = is_or ? CMP_AS_FN(ne, e) : CMP_AS_FN(eq, e);
CMP_AS_CALL(cmp, yp, bitarr_ptr(x), m_f64(is_or-1), c);
CMP_AS_CALL(cmp, yp, bitany_ptr(x), m_f64(is_or-1), c);
decG(x); if (m==1) return y;
x = y;
}
u64* xp = bitarr_ptr(x);
u64* xp = bitany_ptr(x);
u64* rp; B r = m_bitarrv(&rp, n);
if (andor) si_or_rows_bit(xp, rp, n, m, !is_or);
else si_xor_rows_bit(xp, rp, n, m, rtid==n_eq);

View File

@ -193,7 +193,7 @@ B SORT_C1(B t, B x) {
u8 xe = TI(x,elType);
B r;
if (xe==el_bit) {
u64* xp = bitarr_ptr(x);
u64* xp = bitany_ptr(x);
u64* rp; r = m_bitarrv(&rp, n);
usz sum = bit_sum(xp, n);
u64 n0 = GRADE_UD(n-sum, sum);
@ -357,7 +357,7 @@ bool CAT(isSorted,GRADE_UD(Up,Down))(B x) {
CASE(c8) CASE(c16) CASE(c32)
case el_bit: {
#define HI GRADE_UD(1,0)
u64* xp = bitarr_ptr(x);
u64* xp = bitany_ptr(x);
u64 i = bit_find(xp, xia, HI);
usz iw = i/64;
u64 m = ~(u64)0;
@ -455,7 +455,7 @@ B GRADE_CAT(c2)(B t, B w, B x) {
if (elNum(xe)) {
if (RARE(we==el_bit | xe==el_bit)) {
if (we==el_bit) {
usz c1 = CAT(bit_boundary,GRADE_UD(up,dn))(bitarr_ptr(w), wia);
usz c1 = CAT(bit_boundary,GRADE_UD(up,dn))(bitany_ptr(w), wia);
decG(w); // c1 and wia contain all information in w
if (xe==el_bit) {
r = bit_sel(x, m_f64(GRADE_UD(c1,wia)), m_f64(GRADE_UD(wia,c1)));

View File

@ -214,11 +214,11 @@ static B group_simple(B w, B x, ur xr, usz wia, usz xn, usz* xsh, u8 we) {
case 3: for (usz i = 0; i < xn; i++) { i32 n = wp[i]; if (n>=0) ((u64*)tyarr_ptr(rp[n]))[pos[n]++] = ((u64*)xp)[i]; } break;
}
} else if (xl == 0) { // 1-bit cells
u64* xp = bitarr_ptr(x);
u64* xp = bitany_ptr(x);
allocBitGroups(rp, ria, z, xr, xsh, len, width);
for (usz i = 0; i < xn; i++) {
bool b = bitp_get(xp,i); i32 n = wp[i];
if (n>=0) bitp_set(bitarr_ptr(rp[n]), pos[n]++, b);
if (n>=0) bitp_set(bitany_ptr(rp[n]), pos[n]++, b);
}
} else { // Generic case
for (usz i = 0; i < ria; i++) {

View File

@ -308,7 +308,7 @@ B internalTemp_c1(B t, B x) {
#endif
#ifdef TEST_BITCPY
SGetU(x)
bit_cpyN(bitarr_ptr(GetU(x,0)), o2s(GetU(x,1)), bitarr_ptr(GetU(x,2)), o2s(GetU(x,3)), o2s(GetU(x,4)));
bit_cpyN(bitany_ptr(GetU(x,0)), o2s(GetU(x,1)), bitany_ptr(GetU(x,2)), o2s(GetU(x,3)), o2s(GetU(x,4)));
#endif
return x;
}

View File

@ -64,7 +64,7 @@ B mul_c2(B, B, B);
B scan_ne(B x, u64 p, u64 ia) { // consumes x
u64* xp = bitarr_ptr(x);
u64* xp = bitany_ptr(x);
u64* rp; B r=m_bitarrv(&rp,ia);
#if SINGELI
si_scan_ne(p, xp, rp, BIT_N(ia));
@ -85,20 +85,20 @@ B scan_ne(B x, u64 p, u64 ia) { // consumes x
}
B scan_eq(B x, u64 ia) { // consumes x
B r = scan_ne(x, 0, ia);
u64* rp = bitarr_ptr(r);
u64* rp = bitany_ptr(r);
for (usz i = 0; i < BIT_N(ia); i++) rp[i] ^= 0xAAAAAAAAAAAAAAAA;
return r;
}
static B scan_or(B x, u64 ia) { // consumes x
u64* xp = bitarr_ptr(x);
u64* xp = bitany_ptr(x);
u64* rp; B r=m_bitarrv(&rp,ia);
usz n=BIT_N(ia); u64 xi; usz i=0;
while (i<n) if ((xi= vg_rand(xp[i]))!=0) { rp[i] = -(xi&-xi) ; i++; while(i<n) rp[i++] = ~0LL; break; } else rp[i++]=0;
decG(x); return FL_SET(r, fl_asc|fl_squoze);
}
static B scan_and(B x, u64 ia) { // consumes x
u64* xp = bitarr_ptr(x);
u64* xp = bitany_ptr(x);
u64* rp; B r=m_bitarrv(&rp,ia);
usz n=BIT_N(ia); u64 xi; usz i=0;
while (i<n) if ((xi=~vg_rand(xp[i]))!=0) { rp[i] = (xi&-xi)-1; i++; while(i<n) rp[i++] = 0 ; break; } else rp[i++]=~0LL;
@ -106,7 +106,7 @@ static B scan_and(B x, u64 ia) { // consumes x
}
B scan_add_bool(B x, u64 ia) { // consumes x
u64* xp = bitarr_ptr(x);
u64* xp = bitany_ptr(x);
u64 xs = bit_sum(xp, ia);
if (xs<=1) return xs==0? x : scan_or(x, ia);
B r;
@ -189,7 +189,7 @@ SHOULD_INLINE B scan2_max_num(B w, B x, u8 xe, usz ia) { MINMAX2(max,>,MIN,or ,0
#undef MINMAX_SCAN
static B scan_lt(B x, u64 p, usz ia) {
u64* xp = bitarr_ptr(x);
u64* xp = bitany_ptr(x);
u64* rp; B r=m_bitarrv(&rp,ia); usz n=BIT_N(ia);
u64 m10 = 0x5555555555555555;
for (usz i=0; i<n; i++) {
@ -261,9 +261,9 @@ B scan_c1(Md1D* d, B x) { B f = d->f;
case n_eq: return scan_eq(x, ia); // =
case n_lt: return scan_lt(x, 0, ia); // <
case n_le: return bit_negate(scan_lt(bit_negate(x), 0, ia)); // ≤
case n_gt: x=bit_negate(x); *bitarr_ptr(x)^= 1; return scan_and(x, ia); // >
case n_ge: x=bit_negate(x); *bitarr_ptr(x)^= 1; return scan_or (x, ia); // ≥
case n_sub: return C2(sub, m_f64(2 * (*bitarr_ptr(x) & 1)), scan_add_bool(x, ia)); // -
case n_gt: x=bit_negate(x); *bitany_ptr(x)^= 1; return scan_and(x, ia); // >
case n_ge: x=bit_negate(x); *bitany_ptr(x)^= 1; return scan_or (x, ia); // ≥
case n_sub: return C2(sub, m_f64(2 * (*bitany_ptr(x) & 1)), scan_add_bool(x, ia)); // -
}
if (rtid==n_add) return scan_plus(0, x, xe, ia); // +
if (rtid==n_floor) return scan_min_num(x, xe, ia); // ⌊
@ -341,7 +341,7 @@ B scan_c2(Md1D* d, B w, B x) { B f = d->f;
if (rtid==n_ne) { // ≠
bool wBit = q_bit(w);
if (xe==el_bit) return scan_ne(x, -(u64)(wBit? o2bG(w) : 1&~*bitarr_ptr(x)), ia);
if (xe==el_bit) return scan_ne(x, -(u64)(wBit? o2bG(w) : 1&~*bitany_ptr(x)), ia);
if (!wBit || !elInt(xe)) goto base;
bool c = o2bG(w);
u64* rp; B r = m_bitarrv(&rp, ia);
@ -390,7 +390,7 @@ B scan_rows_bit(u8 rtid, B x, usz m) {
case n_eq: return bit_negate(scan_rows_bit(n_ne, bit_negate(x), m));
CASE_N_AND: CASE_N_OR: case n_ne: case n_ltack: {
usz ia = IA(x);
u64* xp = bitarr_ptr(x);
u64* xp = bitany_ptr(x);
u64* rp; B r = m_bitarrc(&rp, x);
switch (rtid) { default:UD;
CASE_N_AND: si_scan_rows_and (xp, rp, ia, m); break;
@ -405,7 +405,7 @@ B scan_rows_bit(u8 rtid, B x, usz m) {
if (m >= 128) return bi_N;
usz bl = 128; // block size
i8 buf[bl]; i8 c = 0;
u64* xp = bitarr_ptr(x);
u64* xp = bitany_ptr(x);
i8* rp; B r = m_i8arrc(&rp, x);
static const u64 ms[7] = { 0x00ff00ff00ff00ff, 0x00ff0000ff0000ff, 0x000000ff000000ff, 0x0000ff00000000ff, 0x00ff0000000000ff, 0xff000000000000ff, 0 };
u64 mm = ms[m-2>6? 6 : m-2]; usz mk = m*(POPC(mm)/8);

View File

@ -284,7 +284,7 @@ B indexOf_c2(B t, B w, B x) {
}
if (we==el_bit) {
u64* wp = bitarr_ptr(w);
u64* wp = bitany_ptr(w);
u64 w0 = 1 & wp[0];
u64 i = bit_find(wp, wia, !w0); decG(w);
if (i!=wia) incG(x);
@ -404,7 +404,7 @@ B memberOf_c2(B t, B w, B x) {
#define WEQ(V) C2(eq, incG(w), V)
if (xe==el_bit) {
u64* xp = bitarr_ptr(x);
u64* xp = bitany_ptr(x);
u64 x0 = 1 & xp[0];
r = WEQ(m_usz(x0));
if (bit_has(xp, xia, !x0)) r = C2(or, r, WEQ(m_usz(!x0)));

View File

@ -269,7 +269,7 @@ B select_c2(B t, B w, B x) {
#define TYPE(W, NEXT) { W* wp = W##any_ptr(w); \
if (xl==0) { u64* xp=bitarr_ptr(x); \
if (xl==0) { u64* xp=bitany_ptr(x); \
u64* rp; r = m_bitarrp(&rp, ria); \
BOOL_SPECIAL(W) \
u64 b=0; \
@ -311,7 +311,7 @@ B select_c2(B t, B w, B x) {
B x0 = GetU(x, 0);
B x1;
if (xia<2) {
u64* wp=bitarr_ptr(w);
u64* wp=bitany_ptr(w);
usz i; for (i=0; i<wia/64; i++) if (wp[i]) break;
if (i<wia/64 || bitp_l0(wp,wia)!=0) thrF("⊏: Indexing out-of-bounds (1∊𝕨, %s≡≠𝕩)", xn);
x1 = x0;

View File

@ -255,7 +255,7 @@ B count_c1(B t, B x) {
if (csz==0) { decG(x); return C1(ud, m_f64(n)); }
u8 lw = cellWidthLog(x);
if (lw==0) {
u64* xp = bitarr_ptr(x);
u64* xp = bitany_ptr(x);
B r;
#define COUNT_BOOL(T) \
T* rp; r = m_##T##arrv(&rp, n); \
@ -479,7 +479,7 @@ B find_c1(B t, B x) {
if (n<=1) return x;
u8 xe = TI(x,elType);
if (xe==el_bit && RNK(x)==1) {
u64* xp = bitarr_ptr(x);
u64* xp = bitany_ptr(x);
u64 x0 = 1 & *xp;
usz i = bit_find(xp, n, !x0); decG(x);
u64* rp; B r = m_bitarrv(&rp, 1 + (i<n));

View File

@ -237,7 +237,7 @@ B shape_c2(B t, B w, B x) {
u64* rq; r = m_bitarrp(&rq, nia);
rp = (u8*)rq;
usz nw = BIT_N(nia);
u64* xp = bitarr_ptr(x);
u64* xp = bitany_ptr(x);
u64 b = xia;
if (b % 8) {
if (b < 64) {

View File

@ -227,7 +227,7 @@ static B compress_grouped(u64* wp, B x, usz wia, usz wsum, u8 xt) { // expected
static B where(B x, usz xia, u64 s) {
B r;
u64* xp = bitarr_ptr(x);
u64* xp = bitany_ptr(x);
usz q=xia%64; if (q) xp[xia/64] &= ((u64)1<<q) - 1;
if (xia <= 128) {
#if SINGELI
@ -355,14 +355,14 @@ B grade_bool(B x, usz xia, bool up) {
r0+=b; r1++; \
}
B r;
u64* xp = bitarr_ptr(x);
u64* xp = bitany_ptr(x);
u64 sum = bit_sum(xp, xia);
u64 l0 = up? xia-sum : sum; // Length of first set of indices
#if SINGELI
if (xia < 16) { BRANCHLESS_GRADE(i8) }
else if (xia <= 1<<15) {
B notx = bit_negate(incG(x));
u64* xp0 = bitarr_ptr(notx);
u64* xp0 = bitany_ptr(notx);
u64* xp1 = xp;
u64 q=xia%64; if (q) { usz e=xia/64; u64 m=((u64)1<<q)-1; xp0[e]&=m; xp1[e]&=m; }
if (!up) { u64* t=xp1; xp1=xp0; xp0=t; }
@ -418,7 +418,7 @@ void filter_ne_i32(i32* rp, i32* xp, usz len, usz sum, i32 val) {
extern B take_c2(B, B, B);
static B compress(B w, B x, usz wia, u8 xl, u8 xt) {
u64* wp = bitarr_ptr(w);
u64* wp = bitany_ptr(w);
u64 we = 0;
usz ie = wia/64;
usz q=wia%64; if (q) we = wp[ie] &= ((u64)1<<q) - 1;
@ -439,7 +439,7 @@ static B compress(B w, B x, usz wia, u8 xl, u8 xt) {
// fallthrough
default: r = compress_grouped(wp, x, wia, wsum, xt); break;
case 0: {
u64* xp = bitarr_ptr(x);
u64* xp = bitany_ptr(x);
u64* rp; r = m_bitarrv(&rp,wsum);
#if SINGELI
if (wsum>=wia/si_thresh_compress_bool) {
@ -697,7 +697,7 @@ B slash_c2(B t, B w, B x) {
}
if (xl == 0) {
u64* xp = bitarr_ptr(x);
u64* xp = bitany_ptr(x);
u64* rp; r = m_bitarrv(&rp, s); if (rsh) { SPRNK(a(r),xr); a(r)->sh = rsh; }
if (s/1024 <= wia) {
#define SPARSE_REP(T) T* wp=T##any_ptr(w); BOOL_REP_XOR_SCAN(wp[j])
@ -770,7 +770,7 @@ B slash_c2(B t, B w, B x) {
goto decX_ret;
}
if (xl == 0) {
u64* xp = bitarr_ptr(x);
u64* xp = bitany_ptr(x);
u64* rp; r = m_bitarrv(&rp, s);
#if SINGELI
if (wv <= 64) si_constrep_bool(wv, xp, rp, s);
@ -820,7 +820,7 @@ B slash_im(B t, B x) {
B r;
switch(xe) { default: UD;
case el_bit: {
usz sum = bit_sum(bitarr_ptr(x), xia);
usz sum = bit_sum(bitany_ptr(x), xia);
usz ria = 1 + (sum>0);
f64* rp; r = m_f64arrv(&rp, ria);
rp[sum>0] = sum; rp[0] = xia - sum;
@ -952,7 +952,7 @@ B slash_ucw(B t, B o, B w, B x) {
usz repI = 0;
bool wb = TY(w) == t_bitarr;
if (wb && re!=el_B) {
u64* d = bitarr_ptr(w);
u64* d = bitany_ptr(w);
void* rp = r->a;
switch (re) { default: UD;
case el_bit:
@ -985,7 +985,7 @@ B slash_ucw(B t, B o, B w, B x) {
} else {
SGet(x) SGet(rep) MUTG_INIT(r);
if (wb) {
u64* d = bitarr_ptr(w);
u64* d = bitany_ptr(w);
for (usz i = 0; i < ia; i++) mut_setG(r, i, bitp_get(d, i)? Get(rep,repI++) : Get(x,i));
} else {
SGetU(rep)

View File

@ -106,7 +106,7 @@ B try_interleave_cells(B w, B x, ur xr, ur xk, usz* xsh) {
Arr *r;
if (csz==1 && xlw==0) {
u64* rp; r=m_bitarrp(&rp, ia);
interleave_bits(rp, bitarr_ptr(w), bitarr_ptr(x), ia);
interleave_bits(rp, bitany_ptr(w), bitany_ptr(x), ia);
}
#if SINGELI
else if (csz==1 && xe==el_B) {
@ -157,11 +157,11 @@ static Arr* transpose_noshape(B* px, usz ia, usz w, usz h) {
if (h==2) {
u64* rp; r=m_bitarrp(&rp, ia);
Arr* x1o = TI(x,slice)(inc(x),w,w);
interleave_bits(rp, bitarr_ptr(x), bitanyv_ptr(x1o), ia);
interleave_bits(rp, bitany_ptr(x), bitanyv_ptr(x1o), ia);
mm_free((Value*)x1o);
#ifdef __BMI2__
} else if (w==2) {
u64* xp = bitarr_ptr(x);
u64* xp = bitany_ptr(x);
u64* r0; r=m_bitarrp(&r0, ia);
TALLOC(u64, r1, BIT_N(h));
for (usz i=0; i<BIT_N(ia); i++) {

View File

@ -75,7 +75,7 @@ NOINLINE B m_c32vec_0(u32* s) { usz sz=0; while(s[sz]) sz++; return m_c32vec(s,
static Arr* bitarr_slice(B x, usz s, usz ia) {
u64* rp; Arr* r = m_bitarrp(&rp, ia);
bit_cpy(rp, 0, bitarr_ptr(x), s, ia);
bit_cpy(rp, 0, bitany_ptr(x), s, ia);
ptr_dec(v(x));
return r;
}

View File

@ -27,7 +27,7 @@ NOINLINE Arr* allOnes (usz ia) { u64* rp; Arr* r = m_bitarrp(&rp, ia); for (usz
NOINLINE B bit_sel(B b, B e0, B e1) {
u8 t0 = selfElType(e0);
u64* bp = bitarr_ptr(b);
u64* bp = bitany_ptr(b);
usz ia = IA(b);
B r;
{

View File

@ -20,9 +20,9 @@ NOINLINE u64 bqn_hashObj(B x, const u64 secret[4]) { // TODO manual separation o
switch(xe) { default: UD;
case el_bit:
#if TEST_BAD_HASH
if (xia>=64) return *(u64*)bitarr_ptr(x);
if (xia>=64) return *(u64*)bitany_ptr(x);
#endif
bcl(x,xia); bytes = (xia+7)>>3; data = bitarr_ptr(x); break;
bcl(x,xia); bytes = (xia+7)>>3; data = bitany_ptr(x); break;
case el_i8: case el_c8: bytes = xia*1; data = tyany_ptr(x); break;
case el_i16: case el_c16: bytes = xia*2; data = tyany_ptr(x); break;
case el_i32: case el_c32: bytes = xia*4; data = tyany_ptr(x); break;

View File

@ -6,7 +6,7 @@ extern INIT_GLOBAL u64 wy_secret[4];
static void bcl(B x, usz ia) { // clean up bitarr tail bits to zero
if (ia&63) {
u64* xp = bitarr_ptr(x);
u64* xp = bitany_ptr(x);
xp[ia>>6]&= (1ULL<<(ia&63)) - 1;
}
}

View File

@ -234,7 +234,7 @@ NOINLINE void bit_cpyN(u64* r, usz rs, u64* x, usz xs, usz l) {
bit_cpy(r, rs, x, xs, l);
}
DEF_COPY(bit, { bit_cpyN((u64*)a, ms, bitarr_ptr(x), xs, l); return; })
DEF_COPY(bit, { bit_cpyN((u64*)a, ms, bitany_ptr(x), xs, l); return; })
DEF_COPY(i8 , { i8* rp = ms+(i8*)a; void* xp = tyany_ptr(x);
switch (xt) { default: UD;
case t_bitarr: BIT_COPY(i8)
@ -288,7 +288,7 @@ NOINLINE void m_copyG_B_generic(void* a, B* mpo, B x, usz xs, usz l) {
DEF_G(void, copy, B, (void* a, usz ms, B x, usz xs, usz l), ms, x, xs, l) {
B* mpo = ms+(B*)a;
switch(TY(x)) {
case t_bitarr: { u64* xp = bitarr_ptr(x); for (usz i = 0; i < l; i++) mpo[i] = m_i32(bitp_get(xp, xs+i)); return; }
case t_bitarr: { u64* xp = bitany_ptr(x); for (usz i = 0; i < l; i++) mpo[i] = m_i32(bitp_get(xp, xs+i)); return; }
case t_i8arr: case t_i8slice: { i8* xp = i8any_ptr (x); vfor (usz i = 0; i < l; i++) mpo[i] = m_i32(xp[i+xs]); return; }
case t_i16arr: case t_i16slice: { i16* xp = i16any_ptr(x); vfor (usz i = 0; i < l; i++) mpo[i] = m_i32(xp[i+xs]); return; }
case t_i32arr: case t_i32slice: { i32* xp = i32any_ptr(x); vfor (usz i = 0; i < l; i++) mpo[i] = m_i32(xp[i+xs]); return; }
@ -408,7 +408,7 @@ DEF_G(void, copy, B, (void* a, usz ms, B x, usz xs, usz l), ms, x, x
[(el_B+1)*8 + (el_B+1)] = NULL // make the rest of the entries at least segfault
};
static void m_copyG_bit(void* a, usz ms, B x, usz xs, usz l) { bit_cpyN((u64*)a, ms, bitarr_ptr(x), xs, l); }
static void m_copyG_bit(void* a, usz ms, B x, usz xs, usz l) { bit_cpyN((u64*)a, ms, bitany_ptr(x), xs, l); }
FORCE_INLINE void copy0_bit(void* a, usz ms, B x, u8 xe, usz l) { m_copyG_bit(a, ms, x, 0, l); }
FORCE_INLINE void copy0_B (void* a, usz ms, B x, u8 xe, usz l) { m_copyG_B (a, ms, x, 0, l); }
#define COPY0_TO(WHERE, RE, MS, X, XE, LEN) copy0_##RE(WHERE, MS, X, XE, LEN) // assumptions: x fits; LEN≠0
@ -502,7 +502,7 @@ DEF_G(void, copy, B, (void* a, usz ms, B x, usz xs, usz l), ms, x, x
usz ia = IA(x);
HArr_p r = m_harrUc(x);
u8 xe = TI(x,elType);
if (xe==el_bit) { u64* xp = bitarr_ptr(x); for(usz i=0; i<ia; i++) r.a[i]=m_f64(bitp_get(xp, i)); }
if (xe==el_bit) { u64* xp = bitany_ptr(x); for(usz i=0; i<ia; i++) r.a[i]=m_f64(bitp_get(xp, i)); }
else if (xe==el_i8 ) { i8* xp = i8any_ptr (x); vfor(usz i=0; i<ia; i++) r.a[i]=m_f64(xp[i]); }
else if (xe==el_i16) { i16* xp = i16any_ptr(x); vfor(usz i=0; i<ia; i++) r.a[i]=m_f64(xp[i]); }
else if (xe==el_i32) { i32* xp = i32any_ptr(x); vfor(usz i=0; i<ia; i++) r.a[i]=m_f64(xp[i]); }

View File

@ -214,7 +214,7 @@ static inline bool inplace_add(B w, B x) { // consumes x if returns true; fails
u64 wsz = mm_sizeUsable(v(w));
u8 wt = TY(w);
switch (wt) {
case t_bitarr: if (BITARR_SZ( ria)<wsz && q_bit(x)) { bitp_set(bitarr_ptr(w),wia,o2bG(x)); goto ok; } break;
case t_bitarr: if (BITARR_SZ( ria)<wsz && q_bit(x)) { bitp_set(bitany_ptr(w),wia,o2bG(x)); goto ok; } break;
case t_i8arr: if (TYARR_SZ(I8, ria)<wsz && q_i8 (x)) { i8arr_ptr (w)[wia]=o2iG(x); goto ok; } break;
case t_i16arr: if (TYARR_SZ(I16,ria)<wsz && q_i16(x)) { i16arr_ptr(w)[wia]=o2iG(x); goto ok; } break;
case t_i32arr: if (TYARR_SZ(I32,ria)<wsz && q_i32(x)) { i32arr_ptr(w)[wia]=o2iG(x); goto ok; } break;