@woosh/meep-engine 2.33.26 → 2.33.27

package/core/binary/BitSet.js

@@ -3,55 +3,42 @@ import { max3 } from "../math/max3.js";
 import { min2 } from "../math/min2.js";
 
 /**
- * @readonly
- * @type {number[]}
+ * de Bruijn sequence
+ * @see https://graphics.stanford.edu/~seander/bithacks.html
+ * @type {Uint16Array}
  */
-const MaskSet = [
-    0x01,
-    0x02,
-    0x04,
-    0x08,
-    0x10,
-    0x20,
-    0x40,
-    0x80,
-];
+const msb_lut = new Uint16Array([
+    0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8,
+    31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9
+]);
 
 /**
- *
- * @type {number[]}
+ * get most significant set bit
+ * @see https://graphics.stanford.edu/~seander/bithacks.html
+ * @param {number} v 32 bit integer
+ * @returns {number} integer position of most significant bit
  */
-const MaskClear = [];
-for (let i = 0; i < 8; i++) {
-    MaskClear[i] = ~MaskSet[i];
+function msb_32(v) {
+    v |= v >>> 1;
+    v |= v >>> 2;
+    v |= v >>> 4;
+    v |= v >>> 8;
+    v |= v >>> 16;
+    v = (v >>> 1) + 1;
+    return msb_lut[(v * 0x077CB531) >>> 27];
 }
 
 /**
- * Lookup table where each byte index is mapped to position of the first set bit
- * TODO consider bithacks: https://stackoverflow.com/questions/21623614/finding-the-first-set-bit-in-a-binary-number
- * http://graphics.stanford.edu/~seander/bithacks.html
- * @type {number[]}
+ * get least significant set bit
+ * @see https://graphics.stanford.edu/~seander/bithacks.html
+ * @param {number} v
+ * @returns {number}
  */
-const FirstSetBitLookup = [8];
-const FirstClearBitLookup = [0];
-FirstClearBitLookup[255] = 8;
-
-for (let i = 1; i < 256; i++) {
-    for (let j = 0; j < 8; j++) {
-        if ((MaskSet[j] & i) !== 0) {
-            FirstSetBitLookup[i] = j;
-            break;
-        }
-    }
-
-    for (let j = 0; j < 8; j++) {
-        if ((MaskSet[j] & i) === 0) {
-            FirstClearBitLookup[i] = j;
-            break;
-        }
-    }
+function lsb_32(v) {
+    return msb_lut[((v & -v) * 0x077CB531) >>> 27];
 }
 
+
 /**
  * Used for overallocating space when bit set needs to grow
  * @constant
@@ -93,29 +80,34 @@ function BitSet() {
     this.__capacity = 64;
 
     /**
+     * Uint32-backed storage
+     * @type {Uint32Array}
      * @private
-     * @type {Uint8Array}
      */
-    this.__data = new Uint8Array(this.__capacity >> 3);
+    this.__data_uint32 = new Uint32Array(this.__capacity >> 5);
 
     /**
      *
      * @type {number}
      */
     this.__shrinkFactor = SHRINK_FACTOR;
-
-    /**
-     * Acceleration parameter. Used to speed up search for next clear bit.
-     * @type {number}
-     * @private
-     */
-    this.__firstClearBitIndex = 0;
 }
 
 BitSet.prototype.preventShrink = function () {
     this.__shrinkFactor = 0;
 }
 
+/**
+ *
+ * @param {number} x
+ */
+BitSet.prototype.setShrinkFactor = function (x) {
+    assert.greaterThanOrEqual(x, 0, 'x >= 0');
+    assert.lessThan(x, 1, 'x < 1');
+
+    this.__shrinkFactor = x;
+}
+
 /**
  *
  * @param {number} numBits
@@ -151,54 +143,56 @@ BitSet.prototype.capacity = function () {
 BitSet.prototype.__resize = function (bitCapacity) {
     assert.isNonNegativeInteger(bitCapacity, 'bitCapacity');
 
-    const byteCapacity = Math.ceil(bitCapacity / 8);
+    const uint32_capacity = Math.ceil(bitCapacity / 32);
 
-    const oldData = this.__data;
-    const newData = new Uint8Array(byteCapacity);
+    const oldData = this.__data_uint32;
+    const newData = new Uint32Array(uint32_capacity);
 
     //copy data from old container
 
     const oldDataSize = oldData.length;
 
-    if (oldDataSize < byteCapacity) {
+    if (oldDataSize < uint32_capacity) {
         newData.set(oldData);
     } else {
         //creating a sub-array is using heap memory, so we prefer to avoid it
-        newData.set(oldData.subarray(0, byteCapacity));
+        newData.set(oldData.subarray(0, uint32_capacity));
     }
 
-    this.__data = newData;
+    this.__data_uint32 = newData;
 
-    this.__capacity = byteCapacity * 8;
+    this.__capacity = uint32_capacity * 32;
 };
 
 /**
  *
- * @param {int} newLength
+ * @param {int} new_length
  * @private
  */
-BitSet.prototype.__setLength = function (newLength) {
-    this.__length = newLength;
+BitSet.prototype.__setLength = function (new_length) {
+    this.__length = new_length;
 
     const capacity = this.__capacity;
 
-    if (newLength > capacity) {
+    if (new_length > capacity) {
 
-        const growSize = Math.ceil(max3(newLength, capacity + RESIZE_COUNT_THRESHOLD, capacity * GROW_FACTOR));
+        const growSize = Math.ceil(max3(
+            new_length,
+            capacity + RESIZE_COUNT_THRESHOLD,
+            capacity * GROW_FACTOR
+        ));
 
         this.__resize(growSize);
 
     } else {
-        if (newLength < capacity - RESIZE_COUNT_THRESHOLD && newLength < capacity * this.__shrinkFactor) {
+        if (
+            new_length < capacity - RESIZE_COUNT_THRESHOLD
+            && new_length < capacity * this.__shrinkFactor
+        ) {
 
-            this.__resize(newLength);
+            this.__resize(new_length);
 
         }
-
-        if (this.__firstClearBitIndex > newLength) {
-            //update first clear bit index when shrinking
-            this.__firstClearBitIndex = newLength;
-        }
     }
 };
 
@@ -212,32 +206,32 @@ BitSet.prototype.previousSetBit = function (fromIndex) {
 
     const index = min2(fromIndex, this.__length - 1);
 
-    let byteIndex = index >> 3;
-    let bitIndex = index & 7; // modulo operation is slow, bitwise and is fast, this is the same as %8
+    let word_index = index >> 5;
+    let bit_index = index & 31; // modulo operation is slow, bitwise and is fast, this is the same as %8
 
-    const data = this.__data;
+    const data = this.__data_uint32;
 
-    let byte = data[byteIndex];
+    let word = data[word_index];
 
     //handle first byte separately due to potential partial traversal
-    for (; bitIndex >= 0; bitIndex--) {
-        if ((byte & MaskSet[bitIndex]) !== 0) {
-            return byteIndex * 8 + bitIndex;
+    for (; bit_index >= 0; bit_index--) {
+        if ((word & (1 << bit_index)) !== 0) {
+            return word_index * 32 + bit_index;
         }
     }
 
     //unwind first byte
-    byteIndex--;
+    word_index--;
 
     //scan the rest
-    for (; byteIndex >= 0; byteIndex--) {
+    for (; word_index >= 0; word_index--) {
 
-        byte = data[byteIndex];
+        word = data[word_index];
 
-        for (bitIndex = 7; bitIndex >= 0; bitIndex--) {
+        for (bit_index = 31; bit_index >= 0; bit_index--) {
 
-            if ((byte & MaskSet[bitIndex]) !== 0) {
-                return byteIndex * 8 + bitIndex;
+            if ((word & (1 << bit_index)) !== 0) {
+                return word_index * 32 + bit_index;
             }
 
         }
@@ -255,45 +249,50 @@ BitSet.prototype.nextSetBit = function (fromIndex) {
     // assert.ok(fromIndex >= 0, `fromIndex must be greater or equal to 0, instead was ${fromIndex}`);
     // assert.ok(Number.isInteger(fromIndex), `fromIndex must be an integer, instead was ${fromIndex}`);
 
-    const bitLength = this.__length;
-    if (fromIndex >= bitLength) {
+    const bit_length = this.__length;
+    if (fromIndex >= bit_length) {
         //index is out of bounds, return -1
         return -1;
     }
 
-    let byteIndex = fromIndex >> 3;
-    let bitIndex = fromIndex & 7; //replacement for %8
+    const data = this.__data_uint32;
 
-    const data = this.__data;
+    let word_index = fromIndex >> 5;
+    let word;
+    let bit_address;
 
-    let byte = data[byteIndex];
-    let bitAddress;
+    let bit_index = fromIndex & 31;
 
+    if (bit_index !== 0) {
+        // bit offset boundary in inside the word, we need to mask part of the word
 
-    //handle first byte separately due to potential partial traversal
-    for (; bitIndex < 8; bitIndex++) {
-        if ((byte & MaskSet[bitIndex]) !== 0) {
-            bitAddress = byteIndex * 8 + bitIndex;
+        const fill_mask = ~((1 << bit_index) - 1);
+
+        const masked_word = data[word_index] & fill_mask;
 
-            return bitAddress;
+        if (masked_word !== 0) {
+            bit_index = lsb_32(masked_word);
+            return (word_index << 5) + bit_index;
         }
+
+        word_index++;
     }
 
-    //unwind first byte
-    byteIndex++;
 
     //scan the rest
-    const byteLength = bitLength / 8;
-    for (; byteIndex < byteLength; byteIndex++) {
-        byte = data[byteIndex];
+    const word_count = bit_length / 32;
+    for (; word_index < word_count; word_index++) {
+        word = data[word_index];
+
+        if (word === 0) {
+            continue;
+        }
 
-        const bitIndex = FirstSetBitLookup[byte];
+        bit_index = lsb_32(word);
 
-        if (bitIndex < 8) {
-            bitAddress = byteIndex * 8 + bitIndex;
+        bit_address = (word_index << 5) + bit_index;
 
-            return bitAddress;
-        }
+        return bit_address;
     }
 
 
@@ -309,55 +308,50 @@ BitSet.prototype.nextClearBit = function (fromIndex) {
     //assert.ok(fromIndex >= 0, `fromIndex must be greater or equal to 0, instead was ${fromIndex}`);
     //assert.ok(Number.isInteger(fromIndex), `fromIndex must be an integer, instead was ${fromIndex}`);
 
-    if (fromIndex <= this.__firstClearBitIndex) {
-        return this.__firstClearBitIndex;
-    }
+    let word_index = fromIndex >> 5;
 
-    let byteIndex = fromIndex >> 3;
-    let bitIndex = fromIndex & 7;
+    let word;
 
-    let byte = this.__data[byteIndex];
-    let bitAddress;
+    // treat first word specially, as we may need to mask out portion of a word to skip certain number of bits
+    let bit_index = fromIndex & 31;
 
+    const set_length = this.__length;
+    const word_count = set_length / 32;
+    const data = this.__data_uint32;
 
-    //handle first byte separately due to potential partial traversal
-    for (; bitIndex < 8; bitIndex++) {
-        if ((byte & MaskSet[bitIndex]) === 0) {
-            bitAddress = byteIndex * 8 + bitIndex;
+    if (bit_index !== 0) {
+        // bit offset boundary in inside the word, we need to mask part of the word
 
-            if (this.__firstClearBitIndex === -1) {
-                this.__firstClearBitIndex = bitAddress;
-            }
+        word = data[word_index];
 
-            return bitAddress;
-        }
-    }
+        const fill_mask = (1 << bit_index) - 1;
 
-    //unwind first byte
-    byteIndex++;
-
-    //scan the rest
-    for (; byteIndex < this.__length; byteIndex++) {
-        byte = this.__data[byteIndex];
+        // apply mask and convert to uint32 via shift
+        const masked_word = (word | fill_mask) >>> 0;
 
-        const firstClearBit = FirstClearBitLookup[byte];
-        if (firstClearBit < 8) {
+        if (masked_word !== 4294967295) {
+            bit_index = lsb_32(~masked_word);
+            return bit_index + word_index * 32;
+        }
 
-            bitAddress = byteIndex * 8 + firstClearBit;
+        word_index++;
+    }
 
-            if (this.__firstClearBitIndex === -1) {
-                this.__firstClearBitIndex = bitAddress;
-            }
+    //scan the rest
+    for (; word_index < word_count; word_index++) {
+        word = data[word_index];
 
-            return bitAddress;
+        if (word === 4294967295) {
+            // no 0s
+            continue;
         }
-    }
 
-    if (this.__firstClearBitIndex === -1) {
-        this.__firstClearBitIndex = this.__length;
+        bit_index = lsb_32(~word);
+        return bit_index + word_index * 32;
+
     }
 
-    return this.__length;
+    return set_length;
 };
 
 /**
@@ -384,11 +378,13 @@ BitSet.prototype.set = function (bitIndex, value) {
     //assert.ok(typeof bitIndex, 'number', `bitIndex must be a number, instead was '${typeof bitIndex}'`);
     //assert.ok(typeof value, 'boolean', `value must be a boolean, instead was '${typeof bitIndex}'`);
 
-    const byteOffset = bitIndex >> 3;
-    const bitOffset = bitIndex & 7;
+    const word_offset = bitIndex >> 5;
+    const bit_offset = bitIndex & 31;
 
     //const oldLength = this.__length;
 
+    const word_mask = 1 << bit_offset;
+
     if (value) {
         const bitIndexInc = bitIndex + 1;
 
@@ -397,31 +393,17 @@ BitSet.prototype.set = function (bitIndex, value) {
         }
 
         //set
-        this.__data[byteOffset] |= MaskSet[bitOffset];
-
-
-        if (bitIndex === this.__firstClearBitIndex) {
-            if (bitIndexInc === this.__length) {
-                //this was the end bit, move clear bit forward
-                this.__firstClearBitIndex = this.__length;
-            } else {
-                //reset first clear bit index
-                this.__firstClearBitIndex = -1;
-            }
-        }
+        this.__data_uint32[word_offset] |= word_mask;
 
 
     } else if (bitIndex < this.__length) {
         //clear
-        this.__data[byteOffset] &= MaskClear[bitOffset];
+        this.__data_uint32[word_offset] &= ~word_mask;
 
         if (bitIndex === this.__length - 1) {
             const newLastSetBit = this.previousSetBit(bitIndex);
 
             this.__setLength(newLastSetBit + 1);
-        } else if (bitIndex < this.__firstClearBitIndex) {
-            //update first clear bit index
-            this.__firstClearBitIndex = bitIndex;
         }
     }
 
@@ -487,12 +469,12 @@ BitSet.prototype.get = function (bitIndex) {
         return false;
     }
 
-    const byteOffset = bitIndex >> 3;
-    const bitOffset = bitIndex & 7;
+    const byteOffset = bitIndex >> 5;
+    const bitOffset = bitIndex & 31;
 
-    const byte = this.__data[byteOffset];
+    const byte = this.__data_uint32[byteOffset];
 
-    const maskedValue = byte & MaskSet[bitOffset];
+    const maskedValue = byte & (1 << bitOffset);
 
     return maskedValue !== 0;
 };
@@ -531,8 +513,7 @@ BitSet.prototype.getAndClear = function (index) {
  * Sets all of the bits in this BitSet to false.
  */
 BitSet.prototype.reset = function () {
-    this.__data.fill(0, 0, Math.ceil(this.__length / 8));
-    this.__firstClearBitIndex = 0;
+    this.__data_uint32.fill(0, 0, Math.ceil(this.__length / 32));
     this.__length = 0;
 };
 
@@ -543,7 +524,7 @@ BitSet.prototype.reset = function () {
 BitSet.prototype.copy = function (other) {
     const length = other.__length;
 
-    const byte_size = length >> 3;
+    const uint32_size = length >> 5;
 
     const old_length = this.__length;
 
@@ -554,18 +535,18 @@ BitSet.prototype.copy = function (other) {
             this.__resize(length);
         } else {
             // clear everything past the target region
-            this.__data.fill(0, byte_size);
+            this.__data_uint32.fill(0, uint32_size);
         }
 
         this.__length = length;
     }
 
 
-    for (let i = 0; i < byte_size; i++) {
-        this.__data[i] = other.__data[i];
+    for (let i = 0; i < uint32_size; i++) {
+        this.__data_uint32[i] = other.__data_uint32[i];
     }
 
-    const byte_aligned_bit_size = byte_size << 3;
+    const byte_aligned_bit_size = uint32_size << 5;
 
     const overflow_bits = length - byte_aligned_bit_size;
 
@@ -574,10 +555,13 @@ BitSet.prototype.copy = function (other) {
 
         this.set(bitIndex, other.get(bitIndex));
     }
-
-    this.__firstClearBitIndex = other.__firstClearBitIndex;
 };
 
+/**
+ *
+ * @param {number} x
+ * @returns {BitSet}
+ */
 BitSet.fixedSize = function (x) {
     const r = new BitSet();
 

package/core/binary/BitSet.spec.js

@@ -61,6 +61,20 @@ test("resizing down should throw when requested capacity is smaller than actual
     }).toThrow();
 });
 
+test('previousSetBit with set bit 31', () => {
+    const bits = new BitSet();
+
+    bits.set(31, true);
+
+    expect(bits.previousSetBit(8)).toBe(-1);
+    expect(bits.previousSetBit(16)).toBe(-1);
+    expect(bits.previousSetBit(30)).toBe(-1);
+
+    expect(bits.previousSetBit(31)).toBe(31);
+    expect(bits.previousSetBit(32)).toBe(31);
+    expect(bits.previousSetBit(33)).toBe(31);
+});
+
 test("previousSetBit method works correctly", () => {
     const bits = new BitSet();
 
@@ -139,6 +153,16 @@ test("nextClearBit stability", () => {
     expect(bits.nextClearBit(0)).toBe(0);
 });
 
+test('nextClearBit from index 8, with 32 continuous set bits', () => {
+    const bits = new BitSet();
+
+    for (let i = 0; i < 32; i++) {
+        bits.set(i, true);
+    }
+
+    expect(bits.nextClearBit(8)).toBe(32);
+});
+
 test("combination of set and clear", () => {
 
     const bits = new BitSet();
@@ -213,6 +237,33 @@ test("combination of set and clear", () => {
     expect(bits.size()).toBe(4);
 });
 
+test("nextSetBit with only bit 31 set", () => {
+
+    const bits = new BitSet();
+
+    bits.set(31, true);
+
+    expect(bits.nextSetBit(0)).toBe(31);
+    expect(bits.nextSetBit(1)).toBe(31);
+    expect(bits.nextSetBit(31)).toBe(31);
+
+    expect(bits.nextSetBit(32)).toBe(-1);
+});
+
+test("nextSetBit with only bit 33 set", () => {
+
+    const bits = new BitSet();
+
+    bits.set(33, true);
+
+    expect(bits.nextSetBit(0)).toBe(33);
+    expect(bits.nextSetBit(1)).toBe(33);
+
+    expect(bits.nextSetBit(33)).toBe(33);
+
+    expect(bits.nextSetBit(34)).toBe(-1);
+});
+
 test("nextSetBit method works correctly", () => {
     const bits = new BitSet();
 
@@ -353,4 +404,51 @@ test("setRange 0 to 35", () => {
 
     expect(set.nextSetBit(0)).toBe(0)
     expect(set.nextClearBit(0)).toBe(36)
-});
+});
+
+test('copy empty', () => {
+    const a = new BitSet();
+
+    const b = new BitSet();
+
+    b.copy(a);
+
+    expect(b.size()).toBe(0);
+});
+
+test('copy with only bit 33 set', () => {
+    const a = new BitSet();
+
+    a.set(33, true);
+
+    const b = new BitSet();
+
+    b.copy(a);
+
+    expect(b.get(32)).toBe(false);
+    expect(b.get(33)).toBe(true);
+    expect(b.get(34)).toBe(false);
+
+    expect(b.size()).toBe(34);
+});
+
+test('performance, next set from 0', () => {
+    const s = new BitSet();
+
+    s.set(1024, true);
+
+    for (let i = 0; i < 1000000; i++) {
+        const v = s.nextSetBit(0);
+    }
+});
+test('performance, next clear from 0', () => {
+    const s = new BitSet();
+
+    for (let i = 0; i < 1024; i++) {
+        s.set(i, true);
+    }
+
+    for (let i = 0; i < 1000000; i++) {
+        const v = s.nextClearBit(0);
+    }
+});