data-structure-typed 2.3.0 → 2.4.0

package/test/performance/data-structures/binary-tree/tree-multi-set.test.mjs

@@ -0,0 +1,91 @@
+import { TreeMultiSet } from '../../../../dist/esm/index.mjs';
+import Benchmark from 'benchmark';
+import { getRandomIntArray, magnitude } from '../../../utils/perf.mjs';
+
+const suite = new Benchmark.Suite();
+
+const { HUNDRED_THOUSAND, MILLION } = magnitude;
+
+// MultiSet operations: add/delete/setCount
+const N_ADD = MILLION;
+const N_QUERY = MILLION;
+const N_MUTATE = HUNDRED_THOUSAND;
+
+const randomAdd = getRandomIntArray(N_ADD, 0, N_ADD / 10, false); // Allow duplicates (MultiSet scenario)
+const randomQuery = getRandomIntArray(N_QUERY, 0, N_ADD / 10, false);
+
+// Prebuilt for lookup-only benchmarks
+const tmsPrebuilt = new TreeMultiSet();
+for (let i = 0; i < randomAdd.length; i++) {
+  tmsPrebuilt.add(randomAdd[i]);
+}
+
+suite
+  // Add benchmarks: fresh container inside each run
+  .add(`${N_ADD.toLocaleString()} add (TreeMultiSet, expanded iteration)`, function () {
+    const tms = new TreeMultiSet();
+    for (let i = 0; i < randomAdd.length; i++) tms.add(randomAdd[i]);
+    this.val = tms;
+  })
+
+  // Lookup-only benchmarks (no rebuild)
+  .add(`${N_QUERY.toLocaleString()} has-only (TreeMultiSet)`, function () {
+    for (let i = 0; i < randomQuery.length; i++) tmsPrebuilt.has(randomQuery[i]);
+  })
+  .add(`${N_QUERY.toLocaleString()} count-only (TreeMultiSet)`, function () {
+    for (let i = 0; i < randomQuery.length; i++) tmsPrebuilt.count(randomQuery[i]);
+  })
+
+  // Build + lookup
+  .add(`${N_QUERY.toLocaleString()} build+has (TreeMultiSet)`, function () {
+    const tms = new TreeMultiSet();
+    for (let i = 0; i < randomAdd.length; i++) tms.add(randomAdd[i]);
+    for (let i = 0; i < randomQuery.length; i++) tms.has(randomQuery[i]);
+    this.val = tms;
+  })
+  .add(`${N_QUERY.toLocaleString()} build+count (TreeMultiSet)`, function () {
+    const tms = new TreeMultiSet();
+    for (let i = 0; i < randomAdd.length; i++) tms.add(randomAdd[i]);
+    for (let i = 0; i < randomQuery.length; i++) tms.count(randomQuery[i]);
+    this.val = tms;
+  })
+
+  // Mutation: delete one occurrence
+  .add(`${N_MUTATE.toLocaleString()} delete-one (TreeMultiSet)`, function () {
+    const tms = new TreeMultiSet();
+    for (let i = 0; i < randomAdd.length; i++) tms.add(randomAdd[i]);
+    for (let i = 0; i < N_MUTATE; i++) tms.delete(randomQuery[i]);
+    this.val = tms;
+  })
+
+  // setCount operation
+  .add(`${N_MUTATE.toLocaleString()} setCount (TreeMultiSet)`, function () {
+    const tms = new TreeMultiSet();
+    for (let i = 0; i < randomAdd.length; i++) tms.add(randomAdd[i]);
+    for (let i = 0; i < N_MUTATE; i++) tms.setCount(randomQuery[i], 5);
+    this.val = tms;
+  })
+
+  // Iteration: expanded (default)
+  .add(`${N_ADD.toLocaleString()} expanded iteration (TreeMultiSet)`, function () {
+    let sum = 0;
+    for (const val of tmsPrebuilt) sum += val;
+    this.val = sum;
+  })
+
+  // Iteration: entries view
+  .add(`${N_ADD.toLocaleString()} entries view (TreeMultiSet)`, function () {
+    let sum = 0;
+    for (const [val, count] of tmsPrebuilt.entries()) sum += val * count;
+    this.val = sum;
+  })
+
+  // Size operations
+  .add(`${N_ADD.toLocaleString()} size property (TreeMultiSet)`, function () {
+    this.val = tmsPrebuilt.size;
+  })
+  .add(`${N_ADD.toLocaleString()} distinctSize property (TreeMultiSet)`, function () {
+    this.val = tmsPrebuilt.distinctSize;
+  });
+
+export { suite };

package/test/performance/data-structures/binary-tree/tree-set.test.cpp

@@ -0,0 +1,127 @@
+#include <benchmark/benchmark.h>
+#include <set>
+#include <vector>
+#include <random>
+#include <string>
+
+static const int MILLION = 1000000;
+static const int HUNDRED_THOUSAND = 100000;
+
+// Global RNG
+static std::mt19937 gen(42);
+
+static std::vector<int> generateRandomArray(int size, int max_value) {
+  std::vector<int> arr;
+  arr.reserve(size);
+  std::uniform_int_distribution<> dist(0, max_value - 1);
+  for (int i = 0; i < size; i++) arr.push_back(dist(gen));
+  return arr;
+}
+
+static const auto randomKeys = generateRandomArray(MILLION, MILLION - 1);
+
+// Prebuilt set for lookup-only benchmarks
+static std::set<int> prebuiltSet;
+static bool setInitialized = false;
+
+static void initializeSet() {
+  if (!setInitialized) {
+    for (int i = 0; i < MILLION; i++) {
+      prebuiltSet.insert(randomKeys[i]);
+    }
+    setInitialized = true;
+  }
+}
+
+// -----------------
+// ADD (insert)
+// -----------------
+static void Add1M(benchmark::State& state) {
+  for (auto _ : state) {
+    std::set<int> st;
+    for (int i = 0; i < MILLION; i++) {
+      st.insert(randomKeys[i]);
+    }
+    benchmark::DoNotOptimize(st);
+  }
+}
+BENCHMARK(Add1M)->Name("1M add std::set")->Unit(benchmark::kMillisecond);
+
+// -----------------
+// HAS (find, lookup-only)
+// -----------------
+static void Has1M(benchmark::State& state) {
+  initializeSet();
+  for (auto _ : state) {
+    int count = 0;
+    for (int i = 0; i < MILLION; i++) {
+      if (prebuiltSet.find(randomKeys[i]) != prebuiltSet.end()) count++;
+    }
+    benchmark::DoNotOptimize(count);
+  }
+}
+BENCHMARK(Has1M)->Name("1M has std::set")->Unit(benchmark::kMillisecond);
+
+// -----------------
+// BUILD + HAS
+// -----------------
+static void BuildHas1M(benchmark::State& state) {
+  for (auto _ : state) {
+    std::set<int> st;
+    for (int i = 0; i < MILLION; i++) {
+      st.insert(randomKeys[i]);
+    }
+    int count = 0;
+    for (int i = 0; i < MILLION; i++) {
+      if (st.find(randomKeys[i]) != st.end()) count++;
+    }
+    benchmark::DoNotOptimize(count);
+  }
+}
+BENCHMARK(BuildHas1M)->Name("1M build+has std::set")->Unit(benchmark::kMillisecond);
+
+// -----------------
+// RANGE SEARCH (using lower_bound/upper_bound)
+// -----------------
+static void RangeSearch100K(benchmark::State& state) {
+  initializeSet();
+  for (auto _ : state) {
+    int count = 0;
+    auto lo = prebuiltSet.lower_bound(0);
+    auto hi = prebuiltSet.upper_bound(HUNDRED_THOUSAND - 1);
+    for (auto it = lo; it != hi; ++it) {
+      count++;
+    }
+    benchmark::DoNotOptimize(count);
+  }
+}
+BENCHMARK(RangeSearch100K)->Name("100K rangeSearch std::set")->Unit(benchmark::kMillisecond);
+
+// -----------------
+// NAVIGABLE (ceiling/floor/higher/lower equivalent)
+// -----------------
+static void Navigable100K(benchmark::State& state) {
+  initializeSet();
+  for (auto _ : state) {
+    int sum = 0;
+    for (int i = 0; i < HUNDRED_THOUSAND; i++) {
+      // lower_bound = ceiling
+      auto ceiling = prebuiltSet.lower_bound(i);
+      // floor = --upper_bound (if not begin)
+      auto floor = prebuiltSet.upper_bound(i);
+      if (floor != prebuiltSet.begin()) --floor;
+      // higher = upper_bound
+      auto higher = prebuiltSet.upper_bound(i);
+      // lower = --lower_bound (if not begin)
+      auto lower = prebuiltSet.lower_bound(i);
+      if (lower != prebuiltSet.begin()) --lower;
+      
+      if (ceiling != prebuiltSet.end()) sum += *ceiling;
+      if (higher != prebuiltSet.end()) sum += *higher;
+    }
+    benchmark::DoNotOptimize(sum);
+  }
+}
+BENCHMARK(Navigable100K)->Name("100K navigable std::set")->Unit(benchmark::kMillisecond);
+
+BENCHMARK_MAIN();

package/test/performance/data-structures/binary-tree/tree-set.test.mjs

@@ -0,0 +1,174 @@
+import { RedBlackTree, TreeSet } from '../../../../dist/esm/index.mjs';
+import { OrderedSet } from 'js-sdsl';
+import Benchmark from 'benchmark';
+import { getRandomIntArray, magnitude } from '../../../utils/perf.mjs';
+
+const suite = new Benchmark.Suite();
+
+const { HUNDRED_THOUSAND, MILLION } = magnitude;
+
+// Keep add/get/has large; keep range operations smaller.
+const N_ADD = MILLION;
+const N_QUERY = MILLION;
+const N_RANGE = HUNDRED_THOUSAND;
+
+const randomAdd = getRandomIntArray(N_ADD, 0, N_ADD - 1, true);
+const randomQuery = randomAdd;
+
+// Prebuilt containers for lookup-only benchmarks (read-only during runs)
+const treeSetOn = new TreeSet();
+const treeSetOff = new TreeSet([], { isMapMode: false });
+const rbtSetOn = new RedBlackTree();
+const rbtSetOff = new RedBlackTree([], { isMapMode: false });
+const sdslSet = new OrderedSet();
+
+for (let i = 0; i < randomAdd.length; i++) {
+  const k = randomAdd[i];
+  treeSetOn.add(k);
+  treeSetOff.add(k);
+  rbtSetOn.set(k, undefined);
+  rbtSetOff.set(k, undefined);
+  sdslSet.insert(k);
+}
+const sdslEnd = sdslSet.end();
+
+suite
+  // Insert benchmarks: fresh container inside each run.
+  .add(`${N_ADD.toLocaleString()} add TreeSet`, function () {
+    const st = new TreeSet();
+    for (let i = 0; i < randomAdd.length; i++) st.add(randomAdd[i]);
+    this.val = st;
+  })
+  .add(`${N_ADD.toLocaleString()} add TreeSet (Node)`, function () {
+    const st = new TreeSet([], { isMapMode: false });
+    for (let i = 0; i < randomAdd.length; i++) st.add(randomAdd[i]);
+    this.val = st;
+  })
+  .add(`${N_ADD.toLocaleString()} add RBT`, function () {
+    const st = new RedBlackTree();
+    for (let i = 0; i < randomAdd.length; i++) st.set(randomAdd[i], undefined);
+    this.val = st;
+  })
+  .add(`${N_ADD.toLocaleString()} add RBT (Node)`, function () {
+    const st = new RedBlackTree([], { isMapMode: false });
+    for (let i = 0; i < randomAdd.length; i++) st.set(randomAdd[i], undefined);
+    this.val = st;
+  })
+  .add(`${N_ADD.toLocaleString()} add js-sdsl`, function () {
+    const st = new OrderedSet();
+    for (let i = 0; i < randomAdd.length; i++) st.insert(randomAdd[i]);
+    this.val = st;
+  })
+
+  // Lookup-only benchmarks (no rebuild).
+  .add(`${N_QUERY.toLocaleString()} has TreeSet`, function () {
+    for (let i = 0; i < randomQuery.length; i++) treeSetOn.has(randomQuery[i]);
+  })
+  .add(`${N_QUERY.toLocaleString()} has TreeSet (Node)`, function () {
+    for (let i = 0; i < randomQuery.length; i++) treeSetOff.has(randomQuery[i]);
+  })
+  .add(`${N_QUERY.toLocaleString()} has RBT`, function () {
+    for (let i = 0; i < randomQuery.length; i++) rbtSetOn.has(randomQuery[i]);
+  })
+  .add(`${N_QUERY.toLocaleString()} has RBT (Node)`, function () {
+    for (let i = 0; i < randomQuery.length; i++) rbtSetOff.has(randomQuery[i]);
+  })
+  .add(`${N_QUERY.toLocaleString()} has js-sdsl`, function () {
+    for (let i = 0; i < randomQuery.length; i++) sdslSet.find(randomQuery[i]).equals(sdslEnd);
+  })
+
+  // Lookup benchmarks: build + lookup.
+  .add(`${N_QUERY.toLocaleString()} build+has TreeSet`, function () {
+    const st = new TreeSet();
+    for (let i = 0; i < randomAdd.length; i++) st.add(randomAdd[i]);
+    for (let i = 0; i < randomQuery.length; i++) st.has(randomQuery[i]);
+    this.val = st;
+  })
+  .add(`${N_QUERY.toLocaleString()} build+has TreeSet (Node)`, function () {
+    const st = new TreeSet([], { isMapMode: false });
+    for (let i = 0; i < randomAdd.length; i++) st.add(randomAdd[i]);
+    for (let i = 0; i < randomQuery.length; i++) st.has(randomQuery[i]);
+    this.val = st;
+  })
+  .add(`${N_QUERY.toLocaleString()} build+has RBT`, function () {
+    const st = new RedBlackTree();
+    for (let i = 0; i < randomAdd.length; i++) st.set(randomAdd[i], undefined);
+    for (let i = 0; i < randomQuery.length; i++) st.has(randomQuery[i]);
+    this.val = st;
+  })
+  .add(`${N_QUERY.toLocaleString()} build+has RBT (Node)`, function () {
+    const st = new RedBlackTree([], { isMapMode: false });
+    for (let i = 0; i < randomAdd.length; i++) st.set(randomAdd[i], undefined);
+    for (let i = 0; i < randomQuery.length; i++) st.has(randomQuery[i]);
+    this.val = st;
+  })
+  .add(`${N_QUERY.toLocaleString()} build+has js-sdsl`, function () {
+    const st = new OrderedSet();
+    for (let i = 0; i < randomAdd.length; i++) st.insert(randomAdd[i]);
+    for (let i = 0; i < randomQuery.length; i++) st.find(randomQuery[i]).equals(st.end());
+    this.val = st;
+  })
+
+  // Range operations (lookup-only).
+  .add(`${N_RANGE.toLocaleString()} rangeSearch TreeSet`, function () {
+    const out = treeSetOn.rangeSearch([0, N_RANGE - 1]);
+    this.val = out.length;
+  })
+  .add(`${N_RANGE.toLocaleString()} rangeSearch TreeSet (Node)`, function () {
+    const out = treeSetOff.rangeSearch([0, N_RANGE - 1]);
+    this.val = out.length;
+  })
+  .add(`${N_RANGE.toLocaleString()} navigable TreeSet`, function () {
+    for (let i = 0; i < N_RANGE; i++) {
+      treeSetOn.ceiling(i);
+      treeSetOn.floor(i);
+      treeSetOn.higher(i);
+      treeSetOn.lower(i);
+    }
+  })
+  .add(`${N_RANGE.toLocaleString()} navigable TreeSet (Node)`, function () {
+    for (let i = 0; i < N_RANGE; i++) {
+      treeSetOff.ceiling(i);
+      treeSetOff.floor(i);
+      treeSetOff.higher(i);
+      treeSetOff.lower(i);
+    }
+  })
+
+  // Range operations (build + range).
+  .add(`${N_RANGE.toLocaleString()} build+rangeSearch TreeSet`, function () {
+    const st = new TreeSet();
+    for (let i = 0; i < randomAdd.length; i++) st.add(randomAdd[i]);
+    const out = st.rangeSearch([0, N_RANGE - 1]);
+    this.val = out.length;
+  })
+  .add(`${N_RANGE.toLocaleString()} build+rangeSearch TreeSet (Node)`, function () {
+    const st = new TreeSet([], { isMapMode: false });
+    for (let i = 0; i < randomAdd.length; i++) st.add(randomAdd[i]);
+    const out = st.rangeSearch([0, N_RANGE - 1]);
+    this.val = out.length;
+  })
+  .add(`${N_RANGE.toLocaleString()} build+navigable TreeSet`, function () {
+    const st = new TreeSet();
+    for (let i = 0; i < randomAdd.length; i++) st.add(randomAdd[i]);
+    for (let i = 0; i < N_RANGE; i++) {
+      st.ceiling(i);
+      st.floor(i);
+      st.higher(i);
+      st.lower(i);
+    }
+    this.val = st;
+  })
+  .add(`${N_RANGE.toLocaleString()} build+navigable TreeSet (Node)`, function () {
+    const st = new TreeSet([], { isMapMode: false });
+    for (let i = 0; i < randomAdd.length; i++) st.add(randomAdd[i]);
+    for (let i = 0; i < N_RANGE; i++) {
+      st.ceiling(i);
+      st.floor(i);
+      st.higher(i);
+      st.lower(i);
+    }
+    this.val = st;
+  });
+
+export { suite };

package/test/performance/data-structures/comparison/{comparison.test.ts → comparison.test.mjs}

@@ -1,4 +1,4 @@
-import { Heap as SRCPriorityQueue } from '../../../../src';
+import { Heap as SRCPriorityQueue } from '../../../../dist/esm/index.mjs';
 import {
   Deque as CDeque,
   HashMap as CHashMap,
@@ -9,29 +9,29 @@ import {
   Stack as CStack
 } from 'js-sdsl';
 
-import * as Benchmark from 'benchmark';
-import { getRandomIntArray, magnitude } from '../../../utils';
-import { isCompetitor } from '../../../config';
+import Benchmark from 'benchmark';
+import { getRandomIntArray, magnitude } from '../../../utils/perf.mjs'
+import { isCompetitor } from '../../../config.mjs';
 
 const suite = new Benchmark.Suite();
 const { HUNDRED_THOUSAND, MILLION } = magnitude;
-const cOrderedMap = new OrderedMap<number, number>();
+const cOrderedMap = new OrderedMap();
 const arrHundredThousand = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSAND, true);
 
 suite.add(`SRC PQ ${MILLION.toLocaleString()} add`, () => {
-  const pq = new SRCPriorityQueue<number>();
+  const pq = new SRCPriorityQueue();
   for (let i = 0; i < MILLION; i++) pq.add(i);
 });
 
 if (isCompetitor) {
   suite.add(`CPT PQ ${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
-    const pq = new CPriorityQueue<number>();
+    const pq = new CPriorityQueue();
     for (let i = 0; i < HUNDRED_THOUSAND; i++) pq.push(i);
   });
 }
 
 suite.add(`SRC PQ ${HUNDRED_THOUSAND.toLocaleString()} add & poll`, () => {
-  const pq = new SRCPriorityQueue<number>([], {
+  const pq = new SRCPriorityQueue([], {
     comparator: (a, b) => b - a
   });
 
@@ -42,7 +42,7 @@ suite.add(`SRC PQ ${HUNDRED_THOUSAND.toLocaleString()} add & poll`, () => {
 if (isCompetitor) {
   suite
     .add(`CPT PQ ${MILLION.toLocaleString()} add & pop`, () => {
-      const pq = new CPriorityQueue<number>();
+      const pq = new CPriorityQueue();
 
       for (let i = 0; i < MILLION; i++) pq.push(i);
       for (let i = 0; i < MILLION; i++) pq.pop();
@@ -52,44 +52,44 @@ if (isCompetitor) {
         cOrderedMap.setElement(arrHundredThousand[i], arrHundredThousand[i]);
     })
     .add(`CPT HM ${HUNDRED_THOUSAND.toLocaleString()} set`, () => {
-      const hm = new CHashMap<number, number>();
+      const hm = new CHashMap();
 
       for (let i = 0; i < HUNDRED_THOUSAND; i++) hm.setElement(i, i);
     })
     .add(`CPT HM ${HUNDRED_THOUSAND.toLocaleString()} set & get`, () => {
-      const hm = new CHashMap<number, number>();
+      const hm = new CHashMap();
 
       for (let i = 0; i < HUNDRED_THOUSAND; i++) hm.setElement(i, i);
       for (let i = 0; i < HUNDRED_THOUSAND; i++) hm.getElementByKey(i);
     })
     .add(`CPT LL ${MILLION.toLocaleString()} unshift`, () => {
-      const list = new CLinkedList<number>();
+      const list = new CLinkedList();
 
       for (let i = 0; i < MILLION; i++) list.pushFront(i);
     })
     .add(`CPT PQ ${HUNDRED_THOUSAND.toLocaleString()} add & pop`, () => {
-      const pq = new CPriorityQueue<number>();
+      const pq = new CPriorityQueue();
 
       for (let i = 0; i < HUNDRED_THOUSAND; i++) pq.push(i);
 
       for (let i = 0; i < HUNDRED_THOUSAND; i++) pq.pop();
     })
     .add(`CPT DQ ${MILLION.toLocaleString()} push`, () => {
-      const deque = new CDeque<number>();
+      const deque = new CDeque();
       for (let i = 0; i < MILLION; i++) deque.pushBack(i);
     })
     .add(`CPT Q ${MILLION.toLocaleString()} push`, () => {
-      const queue = new CQueue<number>();
+      const queue = new CQueue();
 
       for (let i = 0; i < MILLION; i++) queue.push(i);
     })
     .add(`CPT ST ${MILLION.toLocaleString()} push`, () => {
-      const queue = new CStack<number>();
+      const queue = new CStack();
 
       for (let i = 0; i < MILLION; i++) queue.push(i);
     })
     .add(`CPT ST ${MILLION.toLocaleString()} push & pop`, () => {
-      const queue = new CStack<number>();
+      const queue = new CStack();
 
       for (let i = 0; i < MILLION; i++) queue.push(i);
       for (let i = 0; i < MILLION; i++) queue.pop();

package/test/performance/data-structures/graph/{directed-graph.test.ts → directed-graph.test.mjs}

@@ -1,10 +1,10 @@
-import { DirectedGraph } from '../../../../src';
-import * as Benchmark from 'benchmark';
-import { getRandomIndex, getRandomWords, magnitude } from '../../../utils';
+import { DirectedGraph } from '../../../../dist/esm/index.mjs';
+import Benchmark from 'benchmark';
+import { getRandomIndex, getRandomWords, magnitude } from '../../../utils/perf.mjs'
 
 const suite = new Benchmark.Suite();
 const { THOUSAND } = magnitude;
-const graph = new DirectedGraph<number, number>();
+const graph = new DirectedGraph();
 const vertexes = getRandomWords(THOUSAND);
 
 suite

package/test/performance/data-structures/hash/hash-map.test.cpp

@@ -0,0 +1,183 @@
+#include <benchmark/benchmark.h>
+#include <unordered_map>
+#include <unordered_set>
+
+const int MILLION = 1000000;
+
+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 set
+static void Set1M(benchmark::State& state) {
+  for (auto _ : state) {
+    std::unordered_map<int, int> hm;
+    for (int i = 0; i < MILLION; i++) {
+      hm[i] = i;
+    }
+    benchmark::DoNotOptimize(hm);
+  }
+}
+BENCHMARK(Set1M)->Name("1M set");
+
+// Test 2: Native std::map 1M set (for comparison)
+static void StdMapSet1M(benchmark::State& state) {
+  for (auto _ : state) {
+    std::map<int, int> hm;
+    for (int i = 0; i < MILLION; i++) {
+      hm[i] = i;
+    }
+    benchmark::DoNotOptimize(hm);
+  }
+}
+BENCHMARK(StdMapSet1M)->Name("std::map 1M set");
+
+// Test 3: std::unordered_set 1M add
+static void UnorderedSetAdd1M(benchmark::State& state) {
+  for (auto _ : state) {
+    std::unordered_set<int> hs;
+    for (int i = 0; i < MILLION; i++) {
+      hs.insert(i);
+    }
+    benchmark::DoNotOptimize(hs);
+  }
+}
+BENCHMARK(UnorderedSetAdd1M)->Name("std::unordered_set 1M add");
+
+// Test 4: 1M set & get
+static void SetAndGet1M(benchmark::State& state) {
+  for (auto _ : state) {
+    std::unordered_map<int, int> hm;
+    for (int i = 0; i < MILLION; i++) {
+      hm[i] = i;
+    }
+    int count = 0;
+    for (int i = 0; i < MILLION; i++) {
+      if (hm.find(i) != hm.end()) {
+        count++;
+      }
+    }
+    benchmark::DoNotOptimize(count);
+  }
+}
+BENCHMARK(SetAndGet1M)->Name("1M set & get");
+
+// Test 5: std::map 1M set & get
+static void StdMapSetAndGet1M(benchmark::State& state) {
+  for (auto _ : state) {
+    std::map<int, int> hm;
+    for (int i = 0; i < MILLION; i++) {
+      hm[i] = i;
+    }
+    int count = 0;
+    for (int i = 0; i < MILLION; i++) {
+      if (hm.find(i) != hm.end()) {
+        count++;
+      }
+    }
+    benchmark::DoNotOptimize(count);
+  }
+}
+BENCHMARK(StdMapSetAndGet1M)->Name("std::map 1M set & get");
+
+// Test 6: std::unordered_set 1M add & has
+static void UnorderedSetAddAndHas1M(benchmark::State& state) {
+  for (auto _ : state) {
+    std::unordered_set<int> hs;
+    for (int i = 0; i < MILLION; i++) {
+      hs.insert(i);
+    }
+    int count = 0;
+    for (int i = 0; i < MILLION; i++) {
+      if (hs.find(i) != hs.end()) {
+        count++;
+      }
+    }
+    benchmark::DoNotOptimize(count);
+  }
+}
+BENCHMARK(UnorderedSetAddAndHas1M)->Name("std::unordered_set 1M add & has");
+
+// Test 7: 1M ObjKey set & get
+static void ObjKeySetAndGet1M(benchmark::State& state) {
+  for (auto _ : state) {
+    struct Obj { int key; int value; };
+    struct ObjHash { size_t operator()(const Obj& o) const { return std::hash<int>()(o.key); } };
+    struct ObjEqual { bool operator()(const Obj& a, const Obj& b) const { return a.key == b.key; } };
+    
+    std::unordered_map<Obj, int, ObjHash, ObjEqual> hm;
+    std::vector<Obj> objKeys;
+    for (int i = 0; i < MILLION; i++) {
+      Obj obj = {i, i};
+      objKeys.push_back(obj);
+      hm[obj] = i;
+    }
+    
+    int count = 0;
+    for (int i = 0; i < MILLION; i++) {
+      if (hm.find(objKeys[i]) != hm.end()) {
+        count++;
+      }
+    }
+    benchmark::DoNotOptimize(count);
+  }
+}
+BENCHMARK(ObjKeySetAndGet1M)->Name("1M ObjKey set & get");
+
+// Test 8: std::map 1M ObjKey set & get
+static void StdMapObjKeySetAndGet1M(benchmark::State& state) {
+  for (auto _ : state) {
+    struct Obj { int key; int value; bool operator<(const Obj& other) const { return key < other.key; } };
+    
+    std::map<Obj, int> hm;
+    std::vector<Obj> objs;
+    for (int i = 0; i < MILLION; i++) {
+      Obj obj = {i, i};
+      objs.push_back(obj);
+      hm[obj] = i;
+    }
+    
+    int count = 0;
+    for (int i = 0; i < MILLION; i++) {
+      if (hm.find(objs[i]) != hm.end()) {
+        count++;
+      }
+    }
+    benchmark::DoNotOptimize(count);
+  }
+}
+BENCHMARK(StdMapObjKeySetAndGet1M)->Name("std::map 1M ObjKey set & get");
+
+// Test 9: std::unordered_set 1M ObjKey add & has
+static void UnorderedSetObjKeyAddAndHas1M(benchmark::State& state) {
+  for (auto _ : state) {
+    struct Obj { int key; int value; };
+    struct ObjHash { size_t operator()(const Obj& o) const { return std::hash<int>()(o.key); } };
+    struct ObjEqual { bool operator()(const Obj& a, const Obj& b) const { return a.key == b.key; } };
+    
+    std::unordered_set<Obj, ObjHash, ObjEqual> hs;
+    std::vector<Obj> objs;
+    for (int i = 0; i < MILLION; i++) {
+      Obj obj = {i, i};
+      objs.push_back(obj);
+      hs.insert(obj);
+    }
+    
+    int count = 0;
+    for (int i = 0; i < MILLION; i++) {
+      if (hs.find(objs[i]) != hs.end()) {
+        count++;
+      }
+    }
+    benchmark::DoNotOptimize(count);
+  }
+}
+BENCHMARK(UnorderedSetObjKeyAddAndHas1M)->Name("std::unordered_set 1M ObjKey add & has");
+
+BENCHMARK_MAIN();