fastds 0.0.5 → 0.0.6

package/src/binary-search.ts

@@ -0,0 +1,129 @@
+import { RingBuffer } from './ring-buffer.js';
+
+export interface Comparator<T> {
+  (a: T, b: T): number;
+}
+
+export class BinarySearchArray<T> implements Iterable<T, void, unknown> {
+  #buffer: RingBuffer<T>;
+  #comparator: Comparator<T>;
+
+  constructor(comparator: Comparator<T>) {
+    this.#buffer = new RingBuffer();
+    this.#comparator = comparator;
+  }
+
+  readonly [Symbol.toStringTag] = 'BinarySearchArray';
+
+  get length(): number {
+    return this.#buffer.length;
+  }
+
+  at(index: number) {
+    return this.#buffer.peekAt(index);
+  }
+
+  lowerBound(value: T): number {
+    const length = this.#buffer.length;
+    if (length === 0) return 0;
+
+    const buffer = this.#buffer;
+    const comparator = this.#comparator;
+    let left = 0;
+    let right = length;
+
+    while (left < right) {
+      const mid = (left + right) >>> 1;
+      const midValue = buffer.peekAt(mid)!;
+      if (comparator(midValue, value) < 0) {
+        left = mid + 1;
+      } else {
+        right = mid;
+      }
+    }
+
+    return left;
+  }
+
+  upperBound(value: T): number {
+    const length = this.#buffer.length;
+    if (length === 0) return 0;
+
+    const buffer = this.#buffer;
+    const comparator = this.#comparator;
+    let left = 0;
+    let right = length;
+
+    while (left < right) {
+      const mid = (left + right) >>> 1;
+      const midValue = buffer.peekAt(mid)!;
+      if (comparator(midValue, value) <= 0) {
+        left = mid + 1;
+      } else {
+        right = mid;
+      }
+    }
+
+    return left;
+  }
+
+  indexOf(value: T, index = 0) {
+    const length = this.#buffer.length;
+    if (length === 0 || index >= length) return -1;
+
+    const buffer = this.#buffer;
+    const comparator = this.#comparator;
+    let left = index;
+    let right = length - 1;
+
+    while (left <= right) {
+      const mid = (left + right) >>> 1;
+      const midValue = buffer.peekAt(mid)!;
+      const cmp = comparator(midValue, value);
+
+      if (cmp === 0) {
+        return mid;
+      } else if (cmp < 0) {
+        left = mid + 1;
+      } else {
+        right = mid - 1;
+      }
+    }
+
+    return -1;
+  }
+
+  has(value: T): boolean {
+    return this.indexOf(value) !== -1;
+  }
+
+  insert(value: T) {
+    const index = this.lowerBound(value);
+    this.#buffer.setOne(index, value, true);
+
+    return index;
+  }
+
+  removeOne(index: number) {
+    return this.#buffer.removeOne(index);
+  }
+
+  removeFirst(value: T) {
+    const index = this.indexOf(value);
+    return this.#buffer.removeOne(index);
+  }
+
+  remove(index: number, count: number): this {
+    this.#buffer.deallocate(index, count);
+
+    return this;
+  }
+
+  iter() {
+    return this.#buffer.iter();
+  }
+
+  [Symbol.iterator](): Iterator<T> {
+    return this.#buffer[Symbol.iterator]();
+  }
+}

package/src/ring-buffer.ts

@@ -117,7 +117,6 @@ export class RingBuffer<T> {
       return false;
     }
 
-    // Clamp index to valid range, like Array.splice()
     index = Math.min(index, prevLength);
 
     const buffer = this.#buffer;
@@ -258,12 +257,12 @@ export class RingBuffer<T> {
       }
       return -1;
     }
+    
     const capacity = buffer.length;
     const firstSegmentLength = capacity - head;
 
     if (index < firstSegmentLength) {
-      const startOffset = head + index;
-      const result = buffer.indexOf(value, startOffset);
+      const result = buffer.indexOf(value, head + index);
       if (result !== -1) {
         return result - head;
       }
@@ -271,19 +270,12 @@ export class RingBuffer<T> {
     }
 
     if (index < length) {
-      if (tail > length / 2) {
-        const result = buffer.indexOf(value);
-        if (result !== -1 && result < tail) {
-          return firstSegmentLength + result;
-        }
-      } else {
-        for (let i = 0; i < tail; i++) {
-          if (buffer[i] === value) {
-            return firstSegmentLength + i;
-          }
-        }
+      const result = buffer.indexOf(value, 0);
+      if (result !== -1 && result < tail) {
+        return firstSegmentLength + result;
       }
     }
+    
     return -1;
   }
 
@@ -468,22 +460,27 @@ export class RingBuffer<T> {
   }
 
   push(value: T) {
-    const tail = this.getTailOffset(1);
-    if (tail === this.#head) {
+    const nextTail = (this.#tail + 1) & this.#mask;
+    if (nextTail === this.#head) {
       this.grow(this.#mask + 2);
+      this.#buffer[this.#tail] = value;
+      this.#tail = (this.#tail + 1) & this.#mask;
+    } else {
+      this.#buffer[this.#tail] = value;
+      this.#tail = nextTail;
     }
-    this.#buffer[this.#tail] = value;
-    this.#tail = this.getTailOffset(1);
     this.#length++;
     return this;
   }
 
   unshift(value: T): this {
-    const head = this.getHeadOffset(-1);
-    if (head === this.#tail) {
+    const newHead = (this.#head - 1) & this.#mask;
+    if (newHead === this.#tail) {
       this.grow(this.#mask + 2);
+      this.#head = (this.#head - 1) & this.#mask;
+    } else {
+      this.#head = newHead;
     }
-    this.#head = this.getHeadOffset(-1);
     this.#buffer[this.#head] = value;
     this.#length++;
     return this;
@@ -495,7 +492,7 @@ export class RingBuffer<T> {
     }
     const value = this.#buffer[this.#head];
     this.#buffer[this.#head] = undefined;
-    this.#head = this.getHeadOffset(1);
+    this.#head = (this.#head + 1) & this.#mask;
     this.#length--;
     return value;
   }
@@ -504,7 +501,7 @@ export class RingBuffer<T> {
     if (this.#head === this.#tail) {
       return undefined;
     }
-    this.#tail = this.getTailOffset(-1);
+    this.#tail = (this.#tail - 1) & this.#mask;
     const value = this.#buffer[this.#tail];
     this.#buffer[this.#tail] = undefined;
     this.#length--;
@@ -568,14 +565,18 @@ export class RingBuffer<T> {
 
   [Symbol.iterator](): Iterator<T, void, unknown> {
     const buffer = this.#buffer;
+    const mask = this.#mask;
+    const length = this.#length;
+    let count = 0;
     let idx = this.#head;
     return {
       next: (): IteratorResult<T> => {
-        if (idx >= this.#head + this.#length) {
+        if (count >= length) {
           return { done: true, value: undefined };
         }
-        const offset = idx++ & this.#mask;
-        const value = buffer[offset]!;
+        const value = buffer[idx]!;
+        idx = (idx + 1) & mask;
+        count++;
         return { done: false, value };
       },
     };