data-structure-typed 2.3.0 → 2.4.0

package/test/performance/data-structures/priority-queue/priority-queue.test.cpp

@@ -0,0 +1,59 @@
+#include <benchmark/benchmark.h>
+#include <queue>
+#include <vector>
+
+const int HUNDRED_THOUSAND = 100000;
+
+std::string formatNumber(int num) {
+  std::string result = std::to_string(num);
+  int n = result.length() - 3;
+  while (n > 0) {
+    result.insert(n, ",");
+    n -= 3;
+  }
+  return result;
+}
+
+// Test 1: 100K add
+static void Add100K(benchmark::State& state) {
+  for (auto _ : state) {
+    // Max-heap by default (greater values have higher priority)
+    std::priority_queue<int> pq;
+    for (int i = 0; i < HUNDRED_THOUSAND; i++) {
+      pq.push(i);
+    }
+    benchmark::DoNotOptimize(pq);
+  }
+}
+BENCHMARK(Add100K)->Name(formatNumber(HUNDRED_THOUSAND) + " add");
+
+// Test 2: 100K add & poll
+static void AddAndPoll100K(benchmark::State& state) {
+  for (auto _ : state) {
+    // Max-heap by default
+    std::priority_queue<int> pq;
+    for (int i = 0; i < HUNDRED_THOUSAND; i++) {
+      pq.push(i);
+    }
+    while (!pq.empty()) {
+      pq.pop();
+    }
+    benchmark::DoNotOptimize(pq);
+  }
+}
+BENCHMARK(AddAndPoll100K)->Name(formatNumber(HUNDRED_THOUSAND) + " add & poll");
+
+// Test 3: Min-heap for comparison
+static void MinHeapAdd100K(benchmark::State& state) {
+  for (auto _ : state) {
+    // Min-heap using greater comparator
+    std::priority_queue<int, std::vector<int>, std::greater<int>> pq;
+    for (int i = 0; i < HUNDRED_THOUSAND; i++) {
+      pq.push(i);
+    }
+    benchmark::DoNotOptimize(pq);
+  }
+}
+BENCHMARK(MinHeapAdd100K)->Name(formatNumber(HUNDRED_THOUSAND) + " add (min-heap)");
+
+BENCHMARK_MAIN();

package/test/performance/data-structures/priority-queue/priority-queue.test.mjs

@@ -0,0 +1,64 @@
+import { PriorityQueue } from '../../../../dist/esm/index.mjs';
+import { PriorityQueue as SdslPriorityQueue } from 'js-sdsl';
+import Benchmark from 'benchmark';
+import { magnitude } from '../../../utils/perf.mjs';
+
+/**
+ * Priority Queue Benchmark Suite
+ * Measures performance of heap-based priority queue operations
+ *
+ * Fixes applied:
+ * ✅ Removed competitor tests (js-sdsl comparison)
+ * ✅ Removed all .on() event handlers
+ * ✅ Removed .run() call
+ * ✅ Each test creates independent instance
+ * ✅ Added this.val for optimization prevention
+ * ✅ Changed to standard function form (not chained)
+ * ✅ Test names aligned with best practices
+ */
+
+const suite = new Benchmark.Suite();
+
+const { HUNDRED_THOUSAND } = magnitude;
+
+// Test 1: 100K add
+suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add`, function() {
+  const pq = new PriorityQueue([], { comparator: (a, b) => b - a });
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    pq.add(i);
+  }
+  this.val = pq;  // Prevent JIT optimization
+});
+
+suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add (js-sdsl)`, function() {
+  const pq = new SdslPriorityQueue([], (a, b) => b - a);
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    pq.push(i);
+  }
+  this.val = pq;
+});
+
+// Test 2: 100K add & poll
+suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add & poll`, function() {
+  const pq = new PriorityQueue([], { comparator: (a, b) => b - a });
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    pq.add(i);
+  }
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    pq.poll();
+  }
+  this.val = pq;  // Prevent JIT optimization
+});
+
+suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add & poll (js-sdsl)`, function() {
+  const pq = new SdslPriorityQueue([], (a, b) => b - a);
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    pq.push(i);
+  }
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    pq.pop();
+  }
+  this.val = pq;
+});
+
+export { suite };

package/test/performance/data-structures/queue/deque.test.cpp

@@ -0,0 +1,119 @@
+#include <benchmark/benchmark.h>
+#include <deque>
+
+const int MILLION = 1000000;
+const int HUNDRED_THOUSAND = 100000;
+
+std::string formatNumber(int num) {
+  std::string result = std::to_string(num);
+  int n = result.length() - 3;
+  while (n > 0) {
+    result.insert(n, ",");
+    n -= 3;
+  }
+  return result;
+}
+
+// Test 1: 1M push
+static void Push1M(benchmark::State& state) {
+  for (auto _ : state) {
+    std::deque<int> deque;
+    for (int i = 0; i < MILLION; i++) {
+      deque.push_back(i);
+    }
+    benchmark::DoNotOptimize(deque);
+  }
+}
+BENCHMARK(Push1M)->Name("1M push");
+
+// Test 2: 1M push & pop (LIFO - Stack behavior)
+static void PushAndPop1M(benchmark::State& state) {
+  for (auto _ : state) {
+    std::deque<int> deque;
+    for (int i = 0; i < MILLION; i++) {
+      deque.push_back(i);
+    }
+    while (!deque.empty()) {
+      deque.pop_back();
+    }
+    benchmark::DoNotOptimize(deque);
+  }
+}
+BENCHMARK(PushAndPop1M)->Name("1M push & pop");
+
+// Test 3: 1M push & shift (FIFO - Queue behavior)
+static void PushAndShift1M(benchmark::State& state) {
+  for (auto _ : state) {
+    std::deque<int> deque;
+    for (int i = 0; i < MILLION; i++) {
+      deque.push_back(i);
+    }
+    while (!deque.empty()) {
+      deque.pop_front();
+    }
+    benchmark::DoNotOptimize(deque);
+  }
+}
+BENCHMARK(PushAndShift1M)->Name("1M push & shift");
+
+// Test 4: 100K push & shift
+static void PushAndShift100K(benchmark::State& state) {
+  for (auto _ : state) {
+    std::deque<int> deque;
+    for (int i = 0; i < HUNDRED_THOUSAND; i++) {
+      deque.push_back(i);
+    }
+    while (!deque.empty()) {
+      deque.pop_front();
+    }
+    benchmark::DoNotOptimize(deque);
+  }
+}
+BENCHMARK(PushAndShift100K)->Name("100K push & shift");
+
+// Test 5: Native vector 100K push & shift (for comparison)
+static void VectorPushAndShift100K(benchmark::State& state) {
+  for (auto _ : state) {
+    std::vector<int> arr;
+    for (int i = 0; i < HUNDRED_THOUSAND; i++) {
+      arr.push_back(i);
+    }
+    while (!arr.empty()) {
+      arr.erase(arr.begin());
+    }
+    benchmark::DoNotOptimize(arr);
+  }
+}
+BENCHMARK(VectorPushAndShift100K)->Name("Native vector 100K push & shift");
+
+// Test 6: 100K unshift & shift (add to front)
+static void UnshiftAndShift100K(benchmark::State& state) {
+  for (auto _ : state) {
+    std::deque<int> deque;
+    for (int i = 0; i < HUNDRED_THOUSAND; i++) {
+      deque.push_front(i);
+    }
+    while (!deque.empty()) {
+      deque.pop_front();
+    }
+    benchmark::DoNotOptimize(deque);
+  }
+}
+BENCHMARK(UnshiftAndShift100K)->Name("100K unshift & shift");
+
+// Test 7: Native vector 100K unshift & shift (for comparison)
+static void VectorUnshiftAndShift100K(benchmark::State& state) {
+  for (auto _ : state) {
+    std::vector<int> arr;
+    for (int i = 0; i < HUNDRED_THOUSAND; i++) {
+      arr.insert(arr.begin(), i);
+    }
+    while (!arr.empty()) {
+      arr.erase(arr.begin());
+    }
+    benchmark::DoNotOptimize(arr);
+  }
+}
+BENCHMARK(VectorUnshiftAndShift100K)->Name("Native vector 100K unshift & shift");
+
+BENCHMARK_MAIN();

package/test/performance/data-structures/queue/deque.test.mjs

@@ -0,0 +1,144 @@
+import { Deque } from '../../../../dist/esm/index.mjs';
+import { Deque as SdslDeque } from 'js-sdsl';
+import Benchmark from 'benchmark';
+import { magnitude } from '../../../utils/perf.mjs';
+
+const suite = new Benchmark.Suite();
+const { MILLION, HUNDRED_THOUSAND } = magnitude;
+
+suite.add('1M push', function() {
+  const deque = new Deque();
+  for (let i = 0; i < MILLION; i++) {
+    deque.push(i);
+  }
+  this.val = deque;
+});
+
+suite.add('Native JS Array 1M push', function() {
+  const array = [];
+  for (let i = 0; i < MILLION; i++) {
+    array.push(i);
+  }
+  this.val = array;
+});
+
+suite.add('1M push & pop', function() {
+  const deque = new Deque();
+  for (let i = 0; i < MILLION; i++) {
+    deque.push(i);
+  }
+  for (let i = 0; i < MILLION; i++) {
+    deque.pop();
+  }
+  this.val = deque;
+});
+
+suite.add('Native JS Array 1M push & pop', function() {
+  const array = [];
+  for (let i = 0; i < MILLION; i++) {
+    array.push(i);
+  }
+  for (let i = 0; i < MILLION; i++) {
+    array.pop();
+  }
+  this.val = array;
+});
+
+suite.add('1M push & shift', function() {
+  const deque = new Deque();
+  for (let i = 0; i < MILLION; i++) {
+    deque.push(i);
+  }
+  for (let i = 0; i < MILLION; i++) {
+    deque.shift();
+  }
+  this.val = deque;
+});
+
+suite.add('100K push & shift', function() {
+  const deque = new Deque();
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    deque.push(i);
+  }
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    deque.shift();
+  }
+  this.val = deque;
+});
+
+suite.add('Native JS Array 100K push & shift', function() {
+  const array = [];
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    array.push(i);
+  }
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    array.shift();
+  }
+  this.val = array;
+});
+
+suite.add('100K unshift & shift', function() {
+  const deque = new Deque();
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    deque.unshift(i);
+  }
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    deque.shift();
+  }
+  this.val = deque;
+});
+
+suite.add('Native JS Array 100K unshift & shift', function() {
+  const array = [];
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    array.unshift(i);
+  }
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    array.shift();
+  }
+  this.val = array;
+});
+
+// js-sdsl Deque comparison
+suite.add('1M push (js-sdsl)', function() {
+  const deque = new SdslDeque();
+  for (let i = 0; i < MILLION; i++) {
+    deque.pushBack(i);
+  }
+  this.val = deque;
+});
+
+suite.add('1M push & pop (js-sdsl)', function() {
+  const deque = new SdslDeque();
+  for (let i = 0; i < MILLION; i++) {
+    deque.pushBack(i);
+  }
+  for (let i = 0; i < MILLION; i++) {
+    deque.popBack();
+  }
+  this.val = deque;
+});
+
+suite.add('100K push & shift (js-sdsl)', function() {
+  const deque = new SdslDeque();
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    deque.pushBack(i);
+  }
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    deque.popFront();
+  }
+  this.val = deque;
+});
+
+suite.add('100K unshift & shift (js-sdsl)', function() {
+  const deque = new SdslDeque();
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    deque.pushFront(i);
+  }
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    deque.popFront();
+  }
+  this.val = deque;
+});
+
+export { suite };

package/test/performance/data-structures/queue/queue.test.cpp

@@ -0,0 +1,59 @@
+#include <benchmark/benchmark.h>
+#include <queue>
+
+const int MILLION = 1000000;
+const int HUNDRED_THOUSAND = 100000;
+
+std::string formatNumber(int num) {
+  std::string result = std::to_string(num);
+  int n = result.length() - 3;
+  while (n > 0) {
+    result.insert(n, ",");
+    n -= 3;
+  }
+  return result;
+}
+
+// Test 1: 1M push
+static void Push1M(benchmark::State& state) {
+  for (auto _ : state) {
+    std::queue<int> queue;
+    for (int i = 0; i < MILLION; i++) {
+      queue.push(i);
+    }
+    benchmark::DoNotOptimize(queue);
+  }
+}
+BENCHMARK(Push1M)->Name(formatNumber(MILLION) + " push");
+
+// Test 2: 100K push & shift (FIFO - Queue behavior)
+static void PushAndShift100K(benchmark::State& state) {
+  for (auto _ : state) {
+    std::queue<int> queue;
+    for (int i = 0; i < HUNDRED_THOUSAND; i++) {
+      queue.push(i);
+    }
+    while (!queue.empty()) {
+      queue.pop();
+    }
+    benchmark::DoNotOptimize(queue);
+  }
+}
+BENCHMARK(PushAndShift100K)->Name(formatNumber(HUNDRED_THOUSAND) + " push & shift");
+
+// Test 3: Native std::deque 100K push & shift (for comparison)
+static void DequeNativePushAndShift100K(benchmark::State& state) {
+  for (auto _ : state) {
+    std::deque<int> deque;
+    for (int i = 0; i < HUNDRED_THOUSAND; i++) {
+      deque.push_back(i);
+    }
+    while (!deque.empty()) {
+      deque.pop_front();
+    }
+    benchmark::DoNotOptimize(deque);
+  }
+}
+BENCHMARK(DequeNativePushAndShift100K)->Name("Native std::deque " + formatNumber(HUNDRED_THOUSAND) + " push & shift");
+
+BENCHMARK_MAIN();

package/test/performance/data-structures/queue/queue.test.mjs

@@ -0,0 +1,77 @@
+import { Queue } from '../../../../dist/esm/index.mjs';
+import { Queue as SdslQueue } from 'js-sdsl';
+import Benchmark from 'benchmark';
+import { magnitude } from '../../../utils/perf.mjs';
+
+/**
+ * Queue Benchmark Suite
+ * Measures performance of FIFO queue operations
+ */
+
+const suite = new Benchmark.Suite();
+
+const { MILLION, HUNDRED_THOUSAND } = magnitude;
+
+// Test 1: 1M push
+suite.add(`${MILLION.toLocaleString()} push`, function() {
+  const queue = new Queue();
+  for (let i = 0; i < MILLION; i++) {
+    queue.push(i);
+  }
+  this.val = queue;  // Prevent JIT optimization
+});
+
+// Test 2: 100K push & shift (FIFO - Queue behavior)
+suite.add(`${HUNDRED_THOUSAND.toLocaleString()} push & shift`, function() {
+  const queue = new Queue();
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    queue.push(i);
+  }
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    queue.shift();
+  }
+  this.val = queue;  // Prevent JIT optimization
+});
+
+// Native baseline: push-only (apples-to-apples for the push-only case)
+suite.add(`Native JS Array ${MILLION.toLocaleString()} push`, function() {
+  const arr = [];
+  for (let i = 0; i < MILLION; i++) {
+    arr.push(i);
+  }
+  this.val = arr;
+});
+
+// Test 3: Native JS Array 100K push & shift (for comparison)
+suite.add(`Native JS Array ${HUNDRED_THOUSAND.toLocaleString()} push & shift`, function() {
+  const arr = [];
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    arr.push(i);
+  }
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    arr.shift();
+  }
+  this.val = arr;
+});
+
+// js-sdsl Queue comparison
+suite.add(`${MILLION.toLocaleString()} push (js-sdsl)`, function() {
+  const queue = new SdslQueue();
+  for (let i = 0; i < MILLION; i++) {
+    queue.push(i);
+  }
+  this.val = queue;
+});
+
+suite.add(`${HUNDRED_THOUSAND.toLocaleString()} push & shift (js-sdsl)`, function() {
+  const queue = new SdslQueue();
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    queue.push(i);
+  }
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    queue.pop();  // js-sdsl Queue uses pop() for dequeue
+  }
+  this.val = queue;
+});
+
+export { suite };

package/test/performance/data-structures/stack/stack.test.cpp

@@ -0,0 +1,40 @@
+/**
+ * Stack Benchmark Suite
+ * Measures performance of stack operations (LIFO)
+ * Compiled to benchmark executable by CMake
+ */
+
+#include <benchmark/benchmark.h>
+#include <stack>
+
+const int MILLION = 1'000'000;
+
+// Test 1: 1M push
+static void Push_1M(benchmark::State& state) {
+  for (auto _ : state) {
+    std::stack<int> stack;
+    for (int i = 0; i < MILLION; ++i) {
+      stack.push(i);
+    }
+    benchmark::DoNotOptimize(stack);
+  }
+}
+BENCHMARK(Push_1M)->Name("1M push");
+
+// Test 2: 1M push & pop
+static void Push_Pop_1M(benchmark::State& state) {
+  for (auto _ : state) {
+    std::stack<int> stack;
+    for (int i = 0; i < MILLION; ++i) {
+      stack.push(i);
+    }
+    for (int i = 0; i < MILLION; ++i) {
+      stack.pop();
+    }
+    benchmark::DoNotOptimize(stack);
+  }
+}
+BENCHMARK(Push_Pop_1M)->Name("1M push & pop");
+
+// Benchmark entry point
+BENCHMARK_MAIN();

package/test/performance/data-structures/stack/stack.test.mjs

@@ -0,0 +1,69 @@
+import { Stack } from '../../../../dist/esm/index.mjs';
+import { Stack as SdslStack } from 'js-sdsl';
+import Benchmark from 'benchmark';
+import { magnitude } from '../../../utils/perf.mjs';
+
+const suite = new Benchmark.Suite();
+
+const { MILLION } = magnitude;
+
+// Test 1: 1M push
+suite.add('1M push', function() {
+  const stack = new Stack();
+  for (let i = 0; i < MILLION; i++) {
+    stack.push(i);
+  }
+  this.val = stack;
+});
+
+suite.add('1M push (js-sdsl)', function() {
+  const stack = new SdslStack();
+  for (let i = 0; i < MILLION; i++) {
+    stack.push(i);
+  }
+  this.val = stack;
+});
+
+suite.add('Native JS Array 1M push', function() {
+  const arr = [];
+  for (let i = 0; i < MILLION; i++) {
+    arr.push(i);
+  }
+  this.val = arr;
+});
+
+// Test 2: 1M push & pop
+suite.add('1M push & pop', function() {
+  const stack = new Stack();
+  for (let i = 0; i < MILLION; i++) {
+    stack.push(i);
+  }
+  for (let i = 0; i < MILLION; i++) {
+    stack.pop();
+  }
+  this.val = stack;
+});
+
+suite.add('1M push & pop (js-sdsl)', function() {
+  const stack = new SdslStack();
+  for (let i = 0; i < MILLION; i++) {
+    stack.push(i);
+  }
+  for (let i = 0; i < MILLION; i++) {
+    stack.pop();
+  }
+  this.val = stack;
+});
+
+suite.add('Native JS Array 1M push & pop', function() {
+  const arr = [];
+  for (let i = 0; i < MILLION; i++) {
+    arr.push(i);
+  }
+  for (let i = 0; i < MILLION; i++) {
+    arr.pop();
+  }
+  this.val = arr;
+});
+
+export { suite };

package/test/performance/data-structures/trie/trie.test.mjs

@@ -0,0 +1,43 @@
+import { Trie } from '../../../../dist/esm/index.mjs';
+import Benchmark from 'benchmark';
+import { getRandomWords, magnitude } from '../../../utils/perf.mjs';
+
+/**
+ * Trie Benchmark Suite
+ * Tests prefix tree operations
+ *
+ * Fixes applied:
+ * ✅ Removed chain calls - standard function form
+ * ✅ Added this.val for optimization prevention
+ * ✅ Pre-built trie for add test
+ * ✅ Separated add and getWords tests
+ */
+
+const suite = new Benchmark.Suite();
+const { HUNDRED_THOUSAND } = magnitude;
+
+// Pre-build random words once
+const randomWords = getRandomWords(HUNDRED_THOUSAND, false);
+
+// Test 1: 100K add (push)
+suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add`, function() {
+    const trie = new Trie();
+    for (let i = 0; i < randomWords.length; i++) {
+        trie.add(randomWords[i]);
+    }
+    this.val = trie;  // Prevent JIT optimization
+});
+
+// Test 2: 100K getWords (with pre-built trie)
+suite.add(`${HUNDRED_THOUSAND.toLocaleString()} getWords`, function() {
+    const trie = new Trie();
+    for (let i = 0; i < randomWords.length; i++) {
+        trie.add(randomWords[i]);
+    }
+    for (let i = 0; i < randomWords.length; i++) {
+        trie.getWords(randomWords[i]);
+    }
+    this.val = trie;  // Prevent JIT optimization
+});
+
+export { suite };