@isopodlabs/utilities 1.5.7 → 1.5.9

package/dist/bits.d.ts

@@ -1,20 +1,26 @@
 export declare function lowestSet32(x: number): number;
 export declare function highestSet32(x: number): number;
 export declare function countSet32(x: number): number;
+export declare function nthSet32(x: number, i: number): number;
 export declare function highestSet(x: bigint | number): number;
 export declare function lowestSet(x: number | bigint): number;
 export declare function countSet(x: bigint | number): number;
+export declare function nthSet(x: bigint | number, i: number): number;
 export declare function highestClear(x: number | bigint): number;
 export declare function lowestClear(x: number | bigint): number;
 export declare function countClear(x: bigint | number): number;
+export declare function clearLowest(x: bigint): bigint;
+export declare function clearLowest(x: number): number;
+export declare function clearLowest(x: bigint | number): bigint | number;
 export interface immutableBitSet {
+    test(a: number): boolean;
     countSet(): number;
+    nthSet(a: number): number;
     complement(): this;
     intersect(other: this): this;
     union(other: this): this;
     xor(other: this): this;
     contains(other: this): boolean;
-    test(a: number): boolean;
     next(a: number, set: boolean): number;
     where(set: boolean, from?: number): {
         [Symbol.iterator](): Generator<number>;
@@ -22,6 +28,7 @@ export interface immutableBitSet {
     ranges(): {
         [Symbol.iterator](): Generator<number[]>;
     };
+    [Symbol.iterator](): Generator<number>;
 }
 export interface BitSet extends immutableBitSet {
     set(a: number): void;
@@ -44,16 +51,15 @@ export declare class ImmutableSparseBits implements immutableBitSet {
     static fromEntries<T extends ImmutableSparseBits>(this: new (initial?: boolean) => T, entries: Record<number, number> | [number, number][], initial?: boolean): T;
     keys(): number[];
     entries(): [number, number][];
+    test(a: number): boolean;
+    countSet(): number;
+    nthSet(a: number): number;
     complement(): this;
     intersect(other: ImmutableSparseBits): this;
     union(other: ImmutableSparseBits): this;
     xor(other: ImmutableSparseBits): this;
-    clean(): this;
     contains(other: ImmutableSparseBits): boolean;
-    test(a: number): boolean;
-    countSet(): number;
     next(a: number, set?: boolean): number;
-    toDense(): DenseBits;
     where(set: boolean, from?: number): {
         [Symbol.iterator]: () => Generator<number, any, any>;
     };
@@ -61,33 +67,35 @@ export declare class ImmutableSparseBits implements immutableBitSet {
         [Symbol.iterator](): Generator<number[]>;
     };
     [Symbol.iterator](): Generator<number>;
+    clean(): this;
+    toDense(): DenseBits;
 }
 export declare class SparseBits extends ImmutableSparseBits implements BitSet {
     private setMask;
     private clearMask;
-    selfComplement(): this;
-    selfIntersect(other: SparseBits): this;
-    selfUnion(other: SparseBits): this;
-    selfXor(other: SparseBits): this;
     set(a: number): void;
     clear(a: number): void;
-    test(a: number): boolean;
     setRange(a: number, b: number): this;
     clearRange(a: number, b: number): this;
+    selfComplement(): this;
+    selfIntersect(other: SparseBits): this;
+    selfUnion(other: SparseBits): this;
+    selfXor(other: SparseBits): this;
 }
 export declare class ImmutableDenseBits implements immutableBitSet {
     protected bits: bigint;
     constructor(bits?: bigint);
     protected create(bits?: bigint): this;
+    get length(): number;
+    test(a: number): boolean;
+    countSet(): number;
+    nthSet(a: number): number;
     complement(): this;
     intersect(other: ImmutableDenseBits): this;
     union(other: ImmutableDenseBits): this;
     xor(other: ImmutableDenseBits): this;
-    test(a: number): boolean;
     contains(other: this): boolean;
     next(a: number, set?: boolean): number;
-    countSet(): number;
-    get length(): number;
     where(set: boolean, from?: number): {
         [Symbol.iterator](): Generator<number>;
     };
@@ -98,14 +106,14 @@ export declare class ImmutableDenseBits implements immutableBitSet {
     toSparse(): SparseBits;
 }
 export declare class DenseBits extends ImmutableDenseBits implements BitSet {
-    private setMask;
-    private clearMask;
-    selfComplement(): this;
-    selfIntersect(other: DenseBits): this;
-    selfUnion(other: DenseBits): this;
-    selfXor(other: DenseBits): this;
+    protected setMask(m: bigint): void;
+    protected clearMask(m: bigint): void;
     set(a: number): void;
     clear(a: number): void;
     setRange(a: number, b: number): this;
     clearRange(a: number, b: number): this;
+    selfComplement(): this;
+    selfIntersect(other: DenseBits): this;
+    selfUnion(other: DenseBits): this;
+    selfXor(other: DenseBits): this;
 }

package/dist/bits.js

@@ -4,27 +4,63 @@ exports.DenseBits = exports.ImmutableDenseBits = exports.SparseBits = exports.Im
 exports.lowestSet32 = lowestSet32;
 exports.highestSet32 = highestSet32;
 exports.countSet32 = countSet32;
+exports.nthSet32 = nthSet32;
 exports.highestSet = highestSet;
 exports.lowestSet = lowestSet;
 exports.countSet = countSet;
+exports.nthSet = nthSet;
 exports.highestClear = highestClear;
 exports.lowestClear = lowestClear;
 exports.countClear = countClear;
+exports.clearLowest = clearLowest;
 const algorithm_1 = require("./algorithm");
 //-----------------------------------------------------------------------------
 // Bit twiddling functions
 //-----------------------------------------------------------------------------
+// Returns the index (0-31) of the lowest set bit, or 32 if none
 function lowestSet32(x) {
     return x === 0 ? 32 : 31 - Math.clz32(x & -x);
 }
+// Returns the index (1-32) of the highest set bit, or 0 if none
 function highestSet32(x) {
     return x ? 32 - Math.clz32(x) : 0;
 }
+// Returns the number of set bits
 function countSet32(x) {
     x = x - ((x >> 1) & 0x55555555);
     x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
     return ((x + (x >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
 }
+// Returns the index (0-31) of the nth set bit, or 32 if none
+function nthSet32(x, i) {
+    let b2 = x - ((x >> 1) & 0x55555555);
+    let b4 = (b2 & 0x33333333) + ((b2 >> 2) & 0x33333333);
+    let b8 = (b4 + (b4 >> 4) & 0xF0F0F0F);
+    let b16 = (b8 + (b8 >> 8)) & 0xff;
+    let n = 0;
+    if (i >= b16) {
+        i -= b16;
+        n += 16;
+    }
+    b8 = (b8 >> n) & 0xff;
+    if (i >= b8) {
+        i -= b8;
+        n += 8;
+    }
+    b4 = (b4 >> n) & 0x0f;
+    if (i >= b4) {
+        i -= b4;
+        n += 4;
+    }
+    b2 = (b2 >> n) & 0x03;
+    if (i >= b2) {
+        i -= b2;
+        n += 2;
+    }
+    if (i >= ((x >> n) & 1))
+        ++n;
+    return n;
+}
 /*
 const testersShift: bigint[] = [];	//32 << i
 const testers:		bigint[] = [];	//1 << (32 << i)
@@ -85,42 +121,45 @@ export function bitcountCached(x: bigint): number {
     return Number(x & 0xFFFFFFFFn);
 }
 */
-function highestSet(x) {
-    if (x < 0)
-        x = ~x;
-    if (x < 0x100000000)
-        return highestSet32(Number(x));
-    // For numbers within safe float range, use log2
-    if (x <= Number.MAX_VALUE) {
-        const b = Math.floor(Math.log2(Number(x)));
-        return (1n << BigInt(b)) <= x ? b + 1 : b;
-    }
-    // For arbitrarily large bigints, use bit-shifting method
-    let y = BigInt(x);
+function highestSetBig(x) {
     let s = 0;
     let k = 0;
-    for (let t = y >> 32n; t; t >>= BigInt(s)) {
+    for (let t = x >> 32n; t; t >>= BigInt(s)) {
         s = 32 << k++;
-        y = t;
+        x = t;
     }
     if (k) {
         // determine length by bisection
         k--;
         while (k--) {
-            const b = y >> BigInt(32 << k);
+            const b = x >> BigInt(32 << k);
             if (b) {
                 s += 32 << k;
-                y = b;
+                x = b;
             }
         }
     }
-    return (s + 32) - Math.clz32(Number(y));
+    return (s + 32) - Math.clz32(Number(x));
+}
+function highestSet(x) {
+    if (x < 0)
+        x = ~x;
+    if (x < 0x100000000)
+        return highestSet32(Number(x));
+    // For < 1024 bits, use log2
+    if (x <= Number.MAX_VALUE) {
+        const b = Math.floor(Math.log2(Number(x)));
+        return (1n << BigInt(b)) <= x ? b + 1 : b;
+    }
+    return highestSetBig(BigInt(x));
 }
 function lowestSet(x) {
+    if (x < 0)
+        x = ~x;
     if (x < 0x100000000)
         return lowestSet32(Number(x));
-    const xb = BigInt(x < 0 ? ~x : x);
-    return highestSet(xb & -xb) - 1;
+    x = BigInt(x);
+    return highestSetBig(x & -x) - 1;
 }
 function countSet(x) {
     if (x < 0)
@@ -133,9 +172,9 @@ function countSet(x) {
         t >>= BigInt(1 << k++);
     const n = 1 << k;
     const limit = 1n << BigInt(n);
-    let i = 1;
-    for (; i < k; i <<= 1) {
-        const bi = BigInt(i);
+    let s = 1;
+    for (; s < k; s <<= 1) {
+        const bi = BigInt(s);
         const mask = limit / ((1n << bi) + 1n);
         x = (x & mask) + ((x >> bi) & mask);
     }
@@ -143,19 +182,60 @@ function countSet(x) {
     //const mask = limit / ((1n << bi) - 1n);
     //x = (x * mask) >> BigInt(n - i);
     //we can skip the masking when the total can fit
-    for (; i < n; i <<= 1)
-        x += x >> BigInt(i);
-    return Number(x & 0xffffffffn);
+    for (; s < n; s <<= 1)
+        x += x >> BigInt(s);
+    return Number(x & ((1n << BigInt(k)) - 1n));
+}
+function nthSet(x, i) {
+    if (x < 0)
+        x = ~x;
+    if (x < 0x100000000)
+        return nthSet32(Number(x), i);
+    x = BigInt(x);
+    let k = 5;
+    for (let t = x >> 32n; t;)
+        t >>= BigInt(1 << k++);
+    const limit = 1n << BigInt(1 << k);
+    const counts = [];
+    counts.push(x);
+    let s = 1;
+    for (; s < k; s <<= 1) {
+        const bi = BigInt(s);
+        const mask = limit / ((1n << bi) + 1n);
+        x = (x & mask) + ((x >> bi) & mask);
+        counts.push(x);
+    }
+    while (counts.length < k) {
+        x += x >> BigInt(s);
+        counts.push(x);
+        s <<= 1;
+    }
+    let n = 0;
+    for (let j = k; j--;) {
+        const s = 1 << j;
+        const b = Number((counts[j] >> BigInt(n)) & 0xffffffffn) & (s * 2 - 1);
+        if (i >= b) {
+            i -= b;
+            n += s;
+        }
+    }
+    return n;
 }
+// Returns the index of the highest clear bit
 function highestClear(x) {
     return highestSet(~x);
 }
+// Returns the index of the lowest clear bit
 function lowestClear(x) {
     return lowestSet(~x);
 }
+// Returns the number of clear bits
 function countClear(x) {
     return countSet(~x);
 }
+function clearLowest(x) {
+    return typeof x === 'bigint' ? x & (x - 1n) : x & (x - 1);
+}
 //-----------------------------------------------------------------------------
 // SparseBits - a sparse bitset implementation, where each entry in the 'bits' array represents 32 bits
 // The 'undef' member indicates whether undefined entries are treated as 0 or 0xffffffff
@@ -238,6 +318,42 @@ class ImmutableSparseBits {
         //return this.bits;
         return Object.entries(this.bits).map(([k, v]) => [+k, v]);
     }
+    test(a) {
+        return !!((this.bits[a >> 5] ?? this.undef) & (1 << (a & 0x1f)));
+    }
+    countSet() {
+        let count = 0;
+        for (const i in this.bits)
+            count += countSet32(this.bits[i]);
+        return count;
+    }
+    nthSet(a) {
+        if (this.undef === 0) {
+            for (const i in this.bits) {
+                const v = this.bits[i];
+                const n = countSet32(v);
+                if (a < n)
+                    return (+i << 5) + nthSet32(v, a);
+                a -= n;
+            }
+        }
+        else {
+            let prev = 0;
+            for (const i in this.bits) {
+                const m = (+i - prev) << 5;
+                if (a < m)
+                    return (prev << 5) + a;
+                a -= m;
+                const v = this.bits[i];
+                const n = countSet32(v);
+                if (a < n)
+                    return (+i << 5) + nthSet32(v, a);
+                a -= n;
+                prev = +i + 1;
+            }
+        }
+        return -1;
+    }
     complement() {
         const result = this.create(this.undef === 0);
         for (const i in this.bits)
@@ -262,13 +378,6 @@ class ImmutableSparseBits {
             result.bits[i] = this.bits[i] ^ other.bits[i];
         return this.undef ? result.flipUndefined(other) : result.copyUndefined(other);
     }
-    clean() {
-        for (const i in this.bits) {
-            if (this.bits[i] === this.undef)
-                delete this.bits[i];
-        }
-        return this;
-    }
     contains(other) {
         if (other.undef && !this.undef)
             return false;
@@ -278,15 +387,6 @@ class ImmutableSparseBits {
         }
         return true;
     }
-    test(a) {
-        return !!((this.bits[a >> 5] ?? this.undef) & (1 << (a & 0x1f)));
-    }
-    countSet() {
-        let count = 0;
-        for (const i in this.bits)
-            count += countSet32(this.bits[i]);
-        return count;
-    }
     next(a, set = true) {
         ++a;
         const xor = this.undef;
@@ -323,19 +423,6 @@ class ImmutableSparseBits {
             return (i << 5) + lowestSet32(~v);
         }
     }
-    toDense() {
-        let bits = 0n;
-        if (this.undef) {
-            for (const i in this.bits)
-                bits |= BigInt(~this.bits[i]) << BigInt(+i * 32);
-            bits = ~bits;
-        }
-        else {
-            for (const i in this.bits)
-                bits |= BigInt(this.bits[i]) << BigInt(+i * 32);
-        }
-        return new DenseBits(bits);
-    }
     where(set, from = -1) {
         return {
             [Symbol.iterator]: () => ImmutableSparseBits.whereGenerator(this.bits, this.undef, set, from)
@@ -382,6 +469,26 @@ class ImmutableSparseBits {
         //for (let i = this.next(-1); i !== -1; i = this.next(i))
         //	yield i;
     }
+    clean() {
+        for (const i in this.bits) {
+            if (this.bits[i] === this.undef)
+                delete this.bits[i];
+        }
+        return this;
+    }
+    toDense() {
+        let bits = 0n;
+        if (this.undef) {
+            for (const i in this.bits)
+                bits |= BigInt(~this.bits[i]) << BigInt(+i * 32);
+            bits = ~bits;
+        }
+        else {
+            for (const i in this.bits)
+                bits |= BigInt(this.bits[i]) << BigInt(+i * 32);
+        }
+        return new DenseBits(bits);
+    }
 }
 exports.ImmutableSparseBits = ImmutableSparseBits;
 class SparseBits extends ImmutableSparseBits {
@@ -397,48 +504,12 @@ class SparseBits extends ImmutableSparseBits {
         else if (this.undef)
             this.bits[i] = ~m;
     }
-    selfComplement() {
-        this.undef = ~this.undef;
-        for (const i in this.bits)
-            this.bits[i] = ~this.bits[i];
-        return this;
-    }
-    selfIntersect(other) {
-        for (const i in this.bits)
-            this.bits[i] &= other.bits[i];
-        if (this.undef)
-            this.copyUndefined(other);
-        this.undef &= other.undef;
-        return this;
-    }
-    selfUnion(other) {
-        for (const i in other.bits)
-            this.bits[i] |= other.bits[i];
-        if (!this.undef)
-            this.copyUndefined(other);
-        this.undef |= other.undef;
-        return this;
-    }
-    selfXor(other) {
-        for (const i in this.bits)
-            this.bits[i] ^= other.bits[i];
-        if (this.undef)
-            this.flipUndefined(other);
-        else
-            this.copyUndefined(other);
-        this.undef &= other.undef;
-        return this;
-    }
     set(a) {
         this.setMask(a >> 5, 1 << (a & 0x1f));
     }
     clear(a) {
         this.clearMask(a >> 5, 1 << (a & 0x1f));
     }
-    test(a) {
-        const i = a >> 5;
-        return !!((this.bits[i] ?? this.undef) & (1 << (a & 0x1f)));
-    }
     setRange(a, b) {
         let i = a >> 5, j = b >> 5;
         if (i === j) {
@@ -477,6 +548,38 @@ class SparseBits extends ImmutableSparseBits {
         }
         return this;
     }
+    selfComplement() {
+        this.undef = ~this.undef;
+        for (const i in this.bits)
+            this.bits[i] = ~this.bits[i];
+        return this;
+    }
+    selfIntersect(other) {
+        for (const i in this.bits)
+            this.bits[i] &= other.bits[i];
+        if (this.undef)
+            this.copyUndefined(other);
+        this.undef &= other.undef;
+        return this;
+    }
+    selfUnion(other) {
+        for (const i in other.bits)
+            this.bits[i] |= other.bits[i];
+        if (!this.undef)
+            this.copyUndefined(other);
+        this.undef |= other.undef;
+        return this;
+    }
+    selfXor(other) {
+        for (const i in this.bits)
+            this.bits[i] ^= other.bits[i];
+        if (this.undef)
+            this.flipUndefined(other);
+        else
+            this.copyUndefined(other);
+        this.undef &= other.undef;
+        return this;
+    }
 }
 exports.SparseBits = SparseBits;
 ;
@@ -491,6 +594,18 @@ class ImmutableDenseBits {
     create(bits) {
         return new this.constructor(bits);
     }
+    get length() {
+        return highestSet(this.bits);
+    }
+    test(a) {
+        return !!(this.bits & (1n << BigInt(a)));
+    }
+    countSet() {
+        return countSet(this.bits);
+    }
+    nthSet(a) {
+        return nthSet(this.bits, a);
+    }
     complement() {
         return this.create(~this.bits);
     }
@@ -503,9 +618,6 @@ class ImmutableDenseBits {
     xor(other) {
         return this.create(this.bits ^ other.bits);
     }
-    test(a) {
-        return !!(this.bits & (1n << BigInt(a)));
-    }
     contains(other) {
         return (this.bits & other.bits) === other.bits;
     }
@@ -514,12 +626,6 @@ class ImmutableDenseBits {
         s = set ? s & -s : (s + 1n) & ~s;
         return s ? a + highestSet(s) : -1;
     }
-    countSet() {
-        return countSet(this.bits);
-    }
-    get length() {
-        return highestSet(this.bits);
-    }
     where(set, from = -1) {
         let bits = this.bits >> BigInt(from + 1);
         return {
@@ -582,6 +688,20 @@ class DenseBits extends ImmutableDenseBits {
     clearMask(m) {
         this.bits &= ~m;
     }
+    set(a) {
+        this.setMask(1n << BigInt(a));
+    }
+    clear(a) {
+        this.clearMask(1n << BigInt(a));
+    }
+    setRange(a, b) {
+        this.setMask((1n << BigInt(b)) - (1n << BigInt(a)));
+        return this;
+    }
+    clearRange(a, b) {
+        this.clearMask((1n << BigInt(b)) - (1n << BigInt(a)));
+        return this;
+    }
     selfComplement() {
         this.bits = ~this.bits;
         return this;
@@ -598,20 +718,6 @@ class DenseBits extends ImmutableDenseBits {
         this.bits ^= other.bits;
         return this;
     }
-    set(a) {
-        this.setMask(1n << BigInt(a));
-    }
-    clear(a) {
-        this.clearMask(1n << BigInt(a));
-    }
-    setRange(a, b) {
-        this.setMask((1n << BigInt(b)) - (1n << BigInt(a)));
-        return this;
-    }
-    clearRange(a, b) {
-        this.clearMask((1n << BigInt(b)) - (1n << BigInt(a)));
-        return this;
-    }
 }
 exports.DenseBits = DenseBits;
 ;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@isopodlabs/utilities",
-	"version": "1.5.7",
+	"version": "1.5.9",
 	"description": "Various typescript helpers.",
 	"repository": {
 		"type": "git",