128 lines
4.1 KiB
TypeScript
128 lines
4.1 KiB
TypeScript
/**
|
|
* Fixed-size bitset backed by `Uint32Array` storage for fast component-mask
|
|
* arithmetic. Used by archetypes and queries for O(words) subset/superset
|
|
* checks.
|
|
*/
|
|
export class BitSet {
|
|
private readonly data: Uint32Array;
|
|
public readonly size: number;
|
|
|
|
public constructor(size: number) {
|
|
if (!Number.isInteger(size) || size <= 0) {
|
|
throw new RangeError(
|
|
`BitSet size must be a positive integer, got ${size}`
|
|
);
|
|
}
|
|
this.size = size;
|
|
this.data = new Uint32Array(Math.ceil(size / 32));
|
|
}
|
|
|
|
/** Set the bit at `bit` to 1. */
|
|
public set(bit: number): void {
|
|
this.checkBit(bit);
|
|
const index = bit >>> 5;
|
|
const offset = bit & 31;
|
|
this.data[index] = (this.data[index] as number) | (1 << offset);
|
|
}
|
|
|
|
/** Clear the bit at `bit`. */
|
|
public unset(bit: number): void {
|
|
this.checkBit(bit);
|
|
const index = bit >>> 5;
|
|
const offset = bit & 31;
|
|
this.data[index] = (this.data[index] as number) & ~(1 << offset);
|
|
}
|
|
|
|
/** Test whether `bit` is set. */
|
|
public has(bit: number): boolean {
|
|
if (bit < 0 || bit >= this.size) return false;
|
|
const index = bit >>> 5;
|
|
const offset = bit & 31;
|
|
return ((this.data[index] as number) & (1 << offset)) !== 0;
|
|
}
|
|
|
|
/** True when this bitset has every bit set in `other`. */
|
|
public containsAll(other: BitSet): boolean {
|
|
const shared = Math.min(this.data.length, other.data.length);
|
|
for (let i = 0; i < shared; i++) {
|
|
const a = this.data[i] as number;
|
|
const b = other.data[i] as number;
|
|
if ((a & b) >>> 0 !== b) return false;
|
|
}
|
|
for (let i = shared; i < other.data.length; i++) {
|
|
if ((other.data[i] as number) !== 0) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/** True when this bitset shares at least one set bit with `other`. */
|
|
public intersects(other: BitSet): boolean {
|
|
const shared = Math.min(this.data.length, other.data.length);
|
|
for (let i = 0; i < shared; i++) {
|
|
if (((this.data[i] as number) & (other.data[i] as number)) !== 0) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/** Comma-separated string of set bit indices, ascending. Stable across runs. */
|
|
public toKey(): string {
|
|
const bits: number[] = [];
|
|
for (let i = 0; i < this.size; i++) {
|
|
if (this.has(i)) bits.push(i);
|
|
}
|
|
return bits.join(",");
|
|
}
|
|
|
|
/** Return a new BitSet with the same size and bits. */
|
|
public clone(): BitSet {
|
|
const copy = new BitSet(this.size);
|
|
copy.data.set(this.data);
|
|
return copy;
|
|
}
|
|
|
|
/** Structural equality — true when every word matches. */
|
|
public equals(other: BitSet): boolean {
|
|
const len = Math.max(this.data.length, other.data.length);
|
|
for (let i = 0; i < len; i++) {
|
|
const a = i < this.data.length ? (this.data[i] as number) : 0;
|
|
const b = i < other.data.length ? (other.data[i] as number) : 0;
|
|
if (a !== b) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/** Population count — total number of set bits. */
|
|
public count(): number {
|
|
let total = 0;
|
|
for (let i = 0; i < this.data.length; i++) {
|
|
let v = this.data[i] as number;
|
|
v = v - ((v >>> 1) & 0x55555555);
|
|
v = (v & 0x33333333) + ((v >>> 2) & 0x33333333);
|
|
total += (((v + (v >>> 4)) & 0x0f0f0f0f) * 0x01010101) >>> 24;
|
|
}
|
|
return total;
|
|
}
|
|
|
|
/** Clear every bit. */
|
|
public clear(): void {
|
|
this.data.fill(0);
|
|
}
|
|
|
|
/** Iterate set bit indices in ascending order. */
|
|
public *[Symbol.iterator](): Generator<number> {
|
|
for (let i = 0; i < this.size; i++) {
|
|
if (this.has(i)) yield i;
|
|
}
|
|
}
|
|
|
|
private checkBit(bit: number): void {
|
|
if (!Number.isInteger(bit) || bit < 0 || bit >= this.size) {
|
|
throw new RangeError(
|
|
`bit index ${bit} out of range [0, ${this.size})`
|
|
);
|
|
}
|
|
}
|
|
}
|