data-structure-typed 2.3.0 → 2.4.0

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

@@ -0,0 +1,171 @@
+import { RedBlackTree, TreeMap } from '../../../../dist/esm/index.mjs';
+import { OrderedMap } from 'js-sdsl';
+import Benchmark from 'benchmark';
+import { getRandomIntArray, magnitude } from '../../../utils/perf.mjs';
+
+const suite = new Benchmark.Suite();
+
+const { HUNDRED_THOUSAND, MILLION } = magnitude;
+
+const N_SET = MILLION;
+const N_GET = MILLION;
+const N_RANGE = HUNDRED_THOUSAND;
+
+const randomKeys = getRandomIntArray(N_SET, 0, N_SET - 1, true);
+
+// Prebuilt containers for lookup-only benchmarks (read-only during runs)
+const treeMapOn = new TreeMap();
+const treeMapOff = new TreeMap([], { isMapMode: false });
+const rbtOn = new RedBlackTree();
+const rbtOff = new RedBlackTree([], { isMapMode: false });
+const sdsl = new OrderedMap();
+
+for (let i = 0; i < randomKeys.length; i++) {
+  const k = randomKeys[i];
+  treeMapOn.set(k, k);
+  treeMapOff.set(k, k);
+  rbtOn.set(k, k);
+  rbtOff.set(k, k);
+  sdsl.setElement(k, k);
+}
+
+suite
+  // Insert benchmarks.
+  .add(`${N_SET.toLocaleString()} set TreeMap`, function () {
+    const mp = new TreeMap();
+    for (let i = 0; i < randomKeys.length; i++) mp.set(randomKeys[i], randomKeys[i]);
+    this.val = mp;
+  })
+  .add(`${N_SET.toLocaleString()} set TreeMap (Node)`, function () {
+    const mp = new TreeMap([], { isMapMode: false });
+    for (let i = 0; i < randomKeys.length; i++) mp.set(randomKeys[i], randomKeys[i]);
+    this.val = mp;
+  })
+  .add(`${N_SET.toLocaleString()} set RBT`, function () {
+    const mp = new RedBlackTree();
+    for (let i = 0; i < randomKeys.length; i++) mp.set(randomKeys[i], randomKeys[i]);
+    this.val = mp;
+  })
+  .add(`${N_SET.toLocaleString()} set RBT (Node)`, function () {
+    const mp = new RedBlackTree([], { isMapMode: false });
+    for (let i = 0; i < randomKeys.length; i++) mp.set(randomKeys[i], randomKeys[i]);
+    this.val = mp;
+  })
+  .add(`${N_SET.toLocaleString()} set js-sdsl`, function () {
+    const mp = new OrderedMap();
+    for (let i = 0; i < randomKeys.length; i++) mp.setElement(randomKeys[i], randomKeys[i]);
+    this.val = mp;
+  })
+
+  // Lookup-only benchmarks (no rebuild).
+  .add(`${N_GET.toLocaleString()} get TreeMap`, function () {
+    for (let i = 0; i < randomKeys.length; i++) treeMapOn.get(randomKeys[i]);
+  })
+  .add(`${N_GET.toLocaleString()} get TreeMap (Node)`, function () {
+    for (let i = 0; i < randomKeys.length; i++) treeMapOff.get(randomKeys[i]);
+  })
+  .add(`${N_GET.toLocaleString()} get RBT`, function () {
+    for (let i = 0; i < randomKeys.length; i++) rbtOn.get(randomKeys[i]);
+  })
+  .add(`${N_GET.toLocaleString()} get RBT (Node)`, function () {
+    for (let i = 0; i < randomKeys.length; i++) rbtOff.get(randomKeys[i]);
+  })
+  .add(`${N_GET.toLocaleString()} get js-sdsl`, function () {
+    for (let i = 0; i < randomKeys.length; i++) sdsl.getElementByKey(randomKeys[i]);
+  })
+
+  // Lookup benchmarks: build + lookup.
+  .add(`${N_GET.toLocaleString()} build+get TreeMap`, function () {
+    const mp = new TreeMap();
+    for (let i = 0; i < randomKeys.length; i++) mp.set(randomKeys[i], randomKeys[i]);
+    for (let i = 0; i < randomKeys.length; i++) mp.get(randomKeys[i]);
+    this.val = mp;
+  })
+  .add(`${N_GET.toLocaleString()} build+get TreeMap (Node)`, function () {
+    const mp = new TreeMap([], { isMapMode: false });
+    for (let i = 0; i < randomKeys.length; i++) mp.set(randomKeys[i], randomKeys[i]);
+    for (let i = 0; i < randomKeys.length; i++) mp.get(randomKeys[i]);
+    this.val = mp;
+  })
+  .add(`${N_GET.toLocaleString()} build+get RBT`, function () {
+    const mp = new RedBlackTree();
+    for (let i = 0; i < randomKeys.length; i++) mp.set(randomKeys[i], randomKeys[i]);
+    for (let i = 0; i < randomKeys.length; i++) mp.get(randomKeys[i]);
+    this.val = mp;
+  })
+  .add(`${N_GET.toLocaleString()} build+get RBT (Node)`, function () {
+    const mp = new RedBlackTree([], { isMapMode: false });
+    for (let i = 0; i < randomKeys.length; i++) mp.set(randomKeys[i], randomKeys[i]);
+    for (let i = 0; i < randomKeys.length; i++) mp.get(randomKeys[i]);
+    this.val = mp;
+  })
+  .add(`${N_GET.toLocaleString()} build+get js-sdsl`, function () {
+    const mp = new OrderedMap();
+    for (let i = 0; i < randomKeys.length; i++) mp.setElement(randomKeys[i], randomKeys[i]);
+    for (let i = 0; i < randomKeys.length; i++) mp.getElementByKey(randomKeys[i]);
+    this.val = mp;
+  })
+
+  // Range/Navigable (lookup-only, no rebuild).
+  .add(`${N_RANGE.toLocaleString()} rangeSearch TreeMap`, function () {
+    const out = treeMapOn.rangeSearch([0, N_RANGE - 1]);
+    this.val = out.length;
+  })
+  .add(`${N_RANGE.toLocaleString()} rangeSearch TreeMap (Node)`, function () {
+    const out = treeMapOff.rangeSearch([0, N_RANGE - 1]);
+    this.val = out.length;
+  })
+  .add(`${N_RANGE.toLocaleString()} navigable TreeMap`, function () {
+    for (let i = 0; i < N_RANGE; i++) {
+      treeMapOn.ceiling(i);
+      treeMapOn.floor(i);
+      treeMapOn.higher(i);
+      treeMapOn.lower(i);
+    }
+  })
+  .add(`${N_RANGE.toLocaleString()} navigable TreeMap (Node)`, function () {
+    for (let i = 0; i < N_RANGE; i++) {
+      treeMapOff.ceiling(i);
+      treeMapOff.floor(i);
+      treeMapOff.higher(i);
+      treeMapOff.lower(i);
+    }
+  })
+
+  // Range/Navigable (build inside run).
+  .add(`${N_RANGE.toLocaleString()} build+rangeSearch TreeMap`, function () {
+    const mp = new TreeMap();
+    for (let i = 0; i < randomKeys.length; i++) mp.set(randomKeys[i], randomKeys[i]);
+    const out = mp.rangeSearch([0, N_RANGE - 1]);
+    this.val = out.length;
+  })
+  .add(`${N_RANGE.toLocaleString()} build+rangeSearch TreeMap (Node)`, function () {
+    const mp = new TreeMap([], { isMapMode: false });
+    for (let i = 0; i < randomKeys.length; i++) mp.set(randomKeys[i], randomKeys[i]);
+    const out = mp.rangeSearch([0, N_RANGE - 1]);
+    this.val = out.length;
+  })
+  .add(`${N_RANGE.toLocaleString()} build+navigable TreeMap`, function () {
+    const mp = new TreeMap();
+    for (let i = 0; i < randomKeys.length; i++) mp.set(randomKeys[i], randomKeys[i]);
+    for (let i = 0; i < N_RANGE; i++) {
+      mp.ceiling(i);
+      mp.floor(i);
+      mp.higher(i);
+      mp.lower(i);
+    }
+    this.val = mp;
+  })
+  .add(`${N_RANGE.toLocaleString()} build+navigable TreeMap (Node)`, function () {
+    const mp = new TreeMap([], { isMapMode: false });
+    for (let i = 0; i < randomKeys.length; i++) mp.set(randomKeys[i], randomKeys[i]);
+    for (let i = 0; i < N_RANGE; i++) {
+      mp.ceiling(i);
+      mp.floor(i);
+      mp.higher(i);
+      mp.lower(i);
+    }
+    this.val = mp;
+  });
+
+export { suite };

package/test/performance/data-structures/binary-tree/tree-multi-map.test.cpp

@@ -0,0 +1,205 @@
+#include <benchmark/benchmark.h>
+#include <map>
+#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;
+}
+
+// Use fewer unique keys to create duplicates (multimap scenario)
+static const auto randomKeys = generateRandomArray(MILLION, HUNDRED_THOUSAND);
+
+// Prebuilt multimap for lookup-only benchmarks
+static std::multimap<int, int> prebuiltMultiMap;
+static bool multiMapInitialized = false;
+
+static void initializeMultiMap() {
+  if (!multiMapInitialized) {
+    for (int i = 0; i < MILLION; i++) {
+      prebuiltMultiMap.insert({randomKeys[i], i});
+    }
+    multiMapInitialized = true;
+  }
+}
+
+// -----------------
+// ADD (insert with duplicates)
+// -----------------
+static void Add1M(benchmark::State& state) {
+  for (auto _ : state) {
+    std::multimap<int, int> mm;
+    for (int i = 0; i < MILLION; i++) {
+      mm.insert({randomKeys[i], i});
+    }
+    benchmark::DoNotOptimize(mm);
+  }
+}
+BENCHMARK(Add1M)->Name("1M add std::multimap")->Unit(benchmark::kMillisecond);
+
+// -----------------
+// HAS (count > 0)
+// -----------------
+static void Has1M(benchmark::State& state) {
+  initializeMultiMap();
+  for (auto _ : state) {
+    int found = 0;
+    for (int i = 0; i < MILLION; i++) {
+      if (prebuiltMultiMap.count(randomKeys[i]) > 0) found++;
+    }
+    benchmark::DoNotOptimize(found);
+  }
+}
+BENCHMARK(Has1M)->Name("1M has std::multimap")->Unit(benchmark::kMillisecond);
+
+// -----------------
+// GET (equal_range iteration)
+// -----------------
+static void Get1M(benchmark::State& state) {
+  initializeMultiMap();
+  for (auto _ : state) {
+    int sum = 0;
+    for (int i = 0; i < MILLION; i++) {
+      auto range = prebuiltMultiMap.equal_range(randomKeys[i]);
+      for (auto it = range.first; it != range.second; ++it) {
+        sum += it->second;
+      }
+    }
+    benchmark::DoNotOptimize(sum);
+  }
+}
+BENCHMARK(Get1M)->Name("1M get std::multimap")->Unit(benchmark::kMillisecond);
+
+// -----------------
+// COUNT
+// -----------------
+static void Count1M(benchmark::State& state) {
+  initializeMultiMap();
+  for (auto _ : state) {
+    size_t total = 0;
+    for (int i = 0; i < MILLION; i++) {
+      total += prebuiltMultiMap.count(randomKeys[i]);
+    }
+    benchmark::DoNotOptimize(total);
+  }
+}
+BENCHMARK(Count1M)->Name("1M count std::multimap")->Unit(benchmark::kMillisecond);
+
+// -----------------
+// BUILD + HAS
+// -----------------
+static void BuildHas1M(benchmark::State& state) {
+  for (auto _ : state) {
+    std::multimap<int, int> mm;
+    for (int i = 0; i < MILLION; i++) {
+      mm.insert({randomKeys[i], i});
+    }
+    int found = 0;
+    for (int i = 0; i < MILLION; i++) {
+      if (mm.count(randomKeys[i]) > 0) found++;
+    }
+    benchmark::DoNotOptimize(found);
+  }
+}
+BENCHMARK(BuildHas1M)->Name("1M build+has std::multimap")->Unit(benchmark::kMillisecond);
+
+// -----------------
+// BUILD + GET
+// -----------------
+static void BuildGet1M(benchmark::State& state) {
+  for (auto _ : state) {
+    std::multimap<int, int> mm;
+    for (int i = 0; i < MILLION; i++) {
+      mm.insert({randomKeys[i], i});
+    }
+    int sum = 0;
+    for (int i = 0; i < MILLION; i++) {
+      auto range = mm.equal_range(randomKeys[i]);
+      for (auto it = range.first; it != range.second; ++it) {
+        sum += it->second;
+      }
+    }
+    benchmark::DoNotOptimize(sum);
+  }
+}
+BENCHMARK(BuildGet1M)->Name("1M build+get std::multimap")->Unit(benchmark::kMillisecond);
+
+// -----------------
+// FIRST/LAST ENTRY
+// -----------------
+static void FirstLast100K(benchmark::State& state) {
+  initializeMultiMap();
+  for (auto _ : state) {
+    int sum = 0;
+    for (int i = 0; i < HUNDRED_THOUSAND; i++) {
+      auto first = prebuiltMultiMap.begin();
+      auto last = prebuiltMultiMap.rbegin();
+      if (first != prebuiltMultiMap.end()) sum += first->second;
+      sum += last->second;
+    }
+    benchmark::DoNotOptimize(sum);
+  }
+}
+BENCHMARK(FirstLast100K)->Name("100K first/last std::multimap")->Unit(benchmark::kMillisecond);
+
+// -----------------
+// CEILING/FLOOR (lower_bound/upper_bound)
+// -----------------
+static void CeilingFloor100K(benchmark::State& state) {
+  initializeMultiMap();
+  for (auto _ : state) {
+    int sum = 0;
+    for (int i = 0; i < HUNDRED_THOUSAND; i++) {
+      // ceiling = lower_bound
+      auto ceiling = prebuiltMultiMap.lower_bound(i);
+      // floor = --upper_bound (if not begin)
+      auto floor = prebuiltMultiMap.upper_bound(i);
+      if (floor != prebuiltMultiMap.begin()) --floor;
+      
+      if (ceiling != prebuiltMultiMap.end()) sum += ceiling->second;
+      sum += floor->second;
+    }
+    benchmark::DoNotOptimize(sum);
+  }
+}
+BENCHMARK(CeilingFloor100K)->Name("100K ceiling/floor std::multimap")->Unit(benchmark::kMillisecond);
+
+// -----------------
+// ITERATION (all entries)
+// -----------------
+static void Iterate1M(benchmark::State& state) {
+  initializeMultiMap();
+  for (auto _ : state) {
+    int sum = 0;
+    for (const auto& [k, v] : prebuiltMultiMap) {
+      sum += v;
+    }
+    benchmark::DoNotOptimize(sum);
+  }
+}
+BENCHMARK(Iterate1M)->Name("1M iterate std::multimap")->Unit(benchmark::kMillisecond);
+
+// -----------------
+// SIZE
+// -----------------
+static void Size1M(benchmark::State& state) {
+  initializeMultiMap();
+  for (auto _ : state) {
+    size_t s = prebuiltMultiMap.size();
+    benchmark::DoNotOptimize(s);
+  }
+}
+BENCHMARK(Size1M)->Name("1M size std::multimap")->Unit(benchmark::kMillisecond);
+
+BENCHMARK_MAIN();

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

@@ -0,0 +1,106 @@
+import { TreeMultiMap } 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;
+
+// MultiMap operations: add/get/hasEntry/deleteValue
+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 (MultiMap scenario)
+const randomQuery = getRandomIntArray(N_QUERY, 0, N_ADD / 10, false);
+
+// Prebuilt for lookup-only benchmarks
+const tmmPrebuilt = new TreeMultiMap();
+for (let i = 0; i < randomAdd.length; i++) {
+  tmmPrebuilt.add(randomAdd[i], randomAdd[i]); // key -> [values]
+}
+
+suite
+  // Add benchmarks: fresh container inside each run
+  .add(`${N_ADD.toLocaleString()} add (TreeMultiMap, bucketed)`, function () {
+    const tmm = new TreeMultiMap();
+    for (let i = 0; i < randomAdd.length; i++) tmm.add(randomAdd[i], randomAdd[i]);
+    this.val = tmm;
+  })
+
+  // Lookup-only benchmarks (no rebuild)
+  .add(`${N_QUERY.toLocaleString()} has-only (TreeMultiMap)`, function () {
+    for (let i = 0; i < randomQuery.length; i++) tmmPrebuilt.has(randomQuery[i]);
+  })
+  .add(`${N_QUERY.toLocaleString()} get-only (TreeMultiMap)`, function () {
+    for (let i = 0; i < randomQuery.length; i++) tmmPrebuilt.get(randomQuery[i]);
+  })
+  .add(`${N_QUERY.toLocaleString()} count-only (TreeMultiMap)`, function () {
+    for (let i = 0; i < randomQuery.length; i++) tmmPrebuilt.count(randomQuery[i]);
+  })
+
+  // Build + lookup
+  .add(`${N_QUERY.toLocaleString()} build+has (TreeMultiMap)`, function () {
+    const tmm = new TreeMultiMap();
+    for (let i = 0; i < randomAdd.length; i++) tmm.add(randomAdd[i], randomAdd[i]);
+    for (let i = 0; i < randomQuery.length; i++) tmm.has(randomQuery[i]);
+    this.val = tmm;
+  })
+  .add(`${N_QUERY.toLocaleString()} build+get (TreeMultiMap)`, function () {
+    const tmm = new TreeMultiMap();
+    for (let i = 0; i < randomAdd.length; i++) tmm.add(randomAdd[i], randomAdd[i]);
+    for (let i = 0; i < randomQuery.length; i++) tmm.get(randomQuery[i]);
+    this.val = tmm;
+  })
+
+  // Value equality operations
+  .add(`${N_MUTATE.toLocaleString()} hasEntry (TreeMultiMap, Object.is)`, function () {
+    const tmm = new TreeMultiMap();
+    for (let i = 0; i < randomAdd.length; i++) tmm.add(randomAdd[i], randomAdd[i]);
+    for (let i = 0; i < N_MUTATE; i++) tmm.hasEntry(randomQuery[i], randomQuery[i]);
+    this.val = tmm;
+  })
+  .add(`${N_MUTATE.toLocaleString()} deleteValue (TreeMultiMap, Object.is)`, function () {
+    const tmm = new TreeMultiMap();
+    for (let i = 0; i < randomAdd.length; i++) tmm.add(randomAdd[i], randomAdd[i]);
+    for (let i = 0; i < N_MUTATE; i++) tmm.deleteValue(randomQuery[i], randomQuery[i]);
+    this.val = tmm;
+  })
+
+  // Navigable entry methods (RFC additions)
+  .add(`${N_MUTATE.toLocaleString()} firstEntry/lastEntry (TreeMultiMap)`, function () {
+    for (let i = 0; i < N_MUTATE; i++) {
+      tmmPrebuilt.firstEntry();
+      tmmPrebuilt.lastEntry();
+    }
+  })
+  .add(`${N_MUTATE.toLocaleString()} ceilingEntry/floorEntry (TreeMultiMap)`, function () {
+    for (let i = 0; i < N_MUTATE; i++) {
+      tmmPrebuilt.ceilingEntry(randomQuery[i]);
+      tmmPrebuilt.floorEntry(randomQuery[i]);
+    }
+  })
+
+  // Iteration: bucket view (default)
+  .add(`${N_ADD.toLocaleString()} bucket iteration (TreeMultiMap)`, function () {
+    let sum = 0;
+    for (const [key, bucket] of tmmPrebuilt) sum += key + bucket.length;
+    this.val = sum;
+  })
+
+  // Iteration: flat entries view (RFC addition)
+  .add(`${N_ADD.toLocaleString()} flatEntries iteration (TreeMultiMap)`, function () {
+    let sum = 0;
+    for (const [key, val] of tmmPrebuilt.flatEntries()) sum += key + val;
+    this.val = sum;
+  })
+
+  // Size operations
+  .add(`${N_ADD.toLocaleString()} size property (TreeMultiMap)`, function () {
+    this.val = tmmPrebuilt.size;
+  })
+  .add(`${N_ADD.toLocaleString()} totalSize property (TreeMultiMap)`, function () {
+    this.val = tmmPrebuilt.totalSize;
+  });
+
+export { suite };

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

@@ -0,0 +1,217 @@
+#include <benchmark/benchmark.h>
+#include <set>
+#include <vector>
+#include <random>
+
+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;
+}
+
+// Use fewer unique keys to create duplicates (multiset scenario)
+static const auto randomKeys = generateRandomArray(MILLION, HUNDRED_THOUSAND);
+
+// Prebuilt multiset for lookup-only benchmarks
+static std::multiset<int> prebuiltMultiSet;
+static bool multiSetInitialized = false;
+
+static void initializeMultiSet() {
+  if (!multiSetInitialized) {
+    for (int i = 0; i < MILLION; i++) {
+      prebuiltMultiSet.insert(randomKeys[i]);
+    }
+    multiSetInitialized = true;
+  }
+}
+
+// -----------------
+// ADD (insert with duplicates)
+// -----------------
+static void Add1M(benchmark::State& state) {
+  for (auto _ : state) {
+    std::multiset<int> ms;
+    for (int i = 0; i < MILLION; i++) {
+      ms.insert(randomKeys[i]);
+    }
+    benchmark::DoNotOptimize(ms);
+  }
+}
+BENCHMARK(Add1M)->Name("1M add std::multiset")->Unit(benchmark::kMillisecond);
+
+// -----------------
+// HAS (count > 0)
+// -----------------
+static void Has1M(benchmark::State& state) {
+  initializeMultiSet();
+  for (auto _ : state) {
+    int found = 0;
+    for (int i = 0; i < MILLION; i++) {
+      if (prebuiltMultiSet.count(randomKeys[i]) > 0) found++;
+    }
+    benchmark::DoNotOptimize(found);
+  }
+}
+BENCHMARK(Has1M)->Name("1M has std::multiset")->Unit(benchmark::kMillisecond);
+
+// -----------------
+// COUNT
+// -----------------
+static void Count1M(benchmark::State& state) {
+  initializeMultiSet();
+  for (auto _ : state) {
+    size_t total = 0;
+    for (int i = 0; i < MILLION; i++) {
+      total += prebuiltMultiSet.count(randomKeys[i]);
+    }
+    benchmark::DoNotOptimize(total);
+  }
+}
+BENCHMARK(Count1M)->Name("1M count std::multiset")->Unit(benchmark::kMillisecond);
+
+// -----------------
+// BUILD + HAS
+// -----------------
+static void BuildHas1M(benchmark::State& state) {
+  for (auto _ : state) {
+    std::multiset<int> ms;
+    for (int i = 0; i < MILLION; i++) {
+      ms.insert(randomKeys[i]);
+    }
+    int found = 0;
+    for (int i = 0; i < MILLION; i++) {
+      if (ms.count(randomKeys[i]) > 0) found++;
+    }
+    benchmark::DoNotOptimize(found);
+  }
+}
+BENCHMARK(BuildHas1M)->Name("1M build+has std::multiset")->Unit(benchmark::kMillisecond);
+
+// -----------------
+// BUILD + COUNT
+// -----------------
+static void BuildCount1M(benchmark::State& state) {
+  for (auto _ : state) {
+    std::multiset<int> ms;
+    for (int i = 0; i < MILLION; i++) {
+      ms.insert(randomKeys[i]);
+    }
+    size_t total = 0;
+    for (int i = 0; i < MILLION; i++) {
+      total += ms.count(randomKeys[i]);
+    }
+    benchmark::DoNotOptimize(total);
+  }
+}
+BENCHMARK(BuildCount1M)->Name("1M build+count std::multiset")->Unit(benchmark::kMillisecond);
+
+// -----------------
+// DELETE ONE (erase single occurrence)
+// -----------------
+static void DeleteOne100K(benchmark::State& state) {
+  for (auto _ : state) {
+    std::multiset<int> ms;
+    for (int i = 0; i < HUNDRED_THOUSAND; i++) {
+      ms.insert(randomKeys[i]);
+    }
+    for (int i = 0; i < HUNDRED_THOUSAND; i++) {
+      auto it = ms.find(randomKeys[i]);
+      if (it != ms.end()) ms.erase(it);
+    }
+    benchmark::DoNotOptimize(ms);
+  }
+}
+BENCHMARK(DeleteOne100K)->Name("100K delete-one std::multiset")->Unit(benchmark::kMillisecond);
+
+// -----------------
+// FIRST/LAST
+// -----------------
+static void FirstLast100K(benchmark::State& state) {
+  initializeMultiSet();
+  for (auto _ : state) {
+    int sum = 0;
+    for (int i = 0; i < HUNDRED_THOUSAND; i++) {
+      auto first = *prebuiltMultiSet.begin();
+      auto last = *prebuiltMultiSet.rbegin();
+      sum += first + last;
+    }
+    benchmark::DoNotOptimize(sum);
+  }
+}
+BENCHMARK(FirstLast100K)->Name("100K first/last std::multiset")->Unit(benchmark::kMillisecond);
+
+// -----------------
+// CEILING/FLOOR (lower_bound/upper_bound)
+// -----------------
+static void CeilingFloor100K(benchmark::State& state) {
+  initializeMultiSet();
+  for (auto _ : state) {
+    int sum = 0;
+    for (int i = 0; i < HUNDRED_THOUSAND; i++) {
+      // ceiling = lower_bound
+      auto ceiling = prebuiltMultiSet.lower_bound(i);
+      // floor = --upper_bound (if not begin)
+      auto floor = prebuiltMultiSet.upper_bound(i);
+      if (floor != prebuiltMultiSet.begin()) --floor;
+      
+      if (ceiling != prebuiltMultiSet.end()) sum += *ceiling;
+      sum += *floor;
+    }
+    benchmark::DoNotOptimize(sum);
+  }
+}
+BENCHMARK(CeilingFloor100K)->Name("100K ceiling/floor std::multiset")->Unit(benchmark::kMillisecond);
+
+// -----------------
+// ITERATION (expanded - all elements)
+// -----------------
+static void Iterate1M(benchmark::State& state) {
+  initializeMultiSet();
+  for (auto _ : state) {
+    int sum = 0;
+    for (const auto& v : prebuiltMultiSet) {
+      sum += v;
+    }
+    benchmark::DoNotOptimize(sum);
+  }
+}
+BENCHMARK(Iterate1M)->Name("1M iterate std::multiset")->Unit(benchmark::kMillisecond);
+
+// -----------------
+// SIZE
+// -----------------
+static void Size1M(benchmark::State& state) {
+  initializeMultiSet();
+  for (auto _ : state) {
+    size_t s = prebuiltMultiSet.size();
+    benchmark::DoNotOptimize(s);
+  }
+}
+BENCHMARK(Size1M)->Name("1M size std::multiset")->Unit(benchmark::kMillisecond);
+
+// -----------------
+// DISTINCT SIZE (unique element count - need to iterate)
+// -----------------
+static void DistinctSize1M(benchmark::State& state) {
+  initializeMultiSet();
+  for (auto _ : state) {
+    size_t distinct = 0;
+    auto it = prebuiltMultiSet.begin();
+    while (it != prebuiltMultiSet.end()) {
+      distinct++;
+      it = prebuiltMultiSet.upper_bound(*it);
+    }
+    benchmark::DoNotOptimize(distinct);
+  }
+}
+BENCHMARK(DistinctSize1M)->Name("1M distinctSize std::multiset")->Unit(benchmark::kMillisecond);
+
+BENCHMARK_MAIN();