Iteration 247: 5 new benchmark pairs (539 total, +5 vs best 534)

Add 5 new benchmark pairs:
- bench_formatter_factories: makeFloatFormatter/makePercentFormatter/makeCurrencyFormatter applied to Series
- bench_cat_intersect_diff: catIntersectCategories/catDiffCategories on 100k-row Series with 20 categories
- bench_series_shift_fn: standalone shiftSeries (vs old manual-impl bench_series_shift)
- bench_reindex_fill: reindexSeries with ffill/bfill fill methods (extending bench_reindex)
- bench_sample_weighted: sampleSeries with probability weights (extending bench_sample_fn)

Run: https://github.com/githubnext/tsessebe/actions/runs/24650741846

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: github-actions[bot]

benchmarks/pandas/bench_cat_intersect_diff.py

@@ -0,0 +1,53 @@
+"""
+Benchmark: pandas category set operations — intersection and difference of
+categorical Series categories (100k-element, 20 categories each).
+Mirrors tsb's catIntersectCategories / catDiffCategories.
+Outputs JSON: {"function": "cat_intersect_diff", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 30
+
+cats_a = [f"cat_a_{i}" for i in range(20)]
+cats_b = [f"cat_{'a' if i < 10 else 'b'}_{i}" for i in range(20)]
+
+data_a = [cats_a[i % len(cats_a)] for i in range(SIZE)]
+data_b = [cats_b[i % len(cats_b)] for i in range(SIZE)]
+
+s_a = pd.Categorical(data_a, categories=cats_a)
+s_b = pd.Categorical(data_b, categories=cats_b)
+
+def cat_intersect(a, b):
+    """Return new Categorical with categories = intersection of a.categories and b.categories."""
+    b_set = set(b.categories)
+    intersected = [c for c in a.categories if c in b_set]
+    return pd.Categorical(a, categories=intersected)
+
+def cat_diff(a, b):
+    """Return new Categorical with categories = a.categories - b.categories."""
+    b_set = set(b.categories)
+    remaining = [c for c in a.categories if c not in b_set]
+    return pd.Categorical(a, categories=remaining)
+
+for _ in range(WARMUP):
+    cat_intersect(s_a, s_b)
+    cat_diff(s_a, s_b)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    cat_intersect(s_a, s_b)
+    cat_diff(s_a, s_b)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "cat_intersect_diff",
+    "mean_ms": total_ms / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total_ms,
+}))

benchmarks/pandas/bench_formatter_factories.py

@@ -0,0 +1,50 @@
+"""
+Benchmark: pandas formatter factories (lambda closures applied with Series.map)
+Mirrors tsb's makeFloatFormatter / makePercentFormatter / makeCurrencyFormatter
+applied via applySeriesFormatter on a 100k-element Series.
+Outputs JSON: {"function": "formatter_factories", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 30
+
+data = [i * 0.0001234 for i in range(SIZE)]
+s = pd.Series(data)
+
+def make_float_formatter(decimals=3):
+    return lambda v: f"{v:.{decimals}f}" if isinstance(v, (int, float)) else str(v)
+
+def make_percent_formatter(decimals=1):
+    return lambda v: f"{v * 100:.{decimals}f}%" if isinstance(v, (int, float)) else str(v)
+
+def make_currency_formatter(symbol="€", decimals=2):
+    return lambda v: f"{symbol}{v:,.{decimals}f}" if isinstance(v, (int, float)) else str(v)
+
+float_fmt = make_float_formatter(3)
+pct_fmt = make_percent_formatter(1)
+curr_fmt = make_currency_formatter("€", 2)
+
+for _ in range(WARMUP):
+    s.map(float_fmt)
+    s.map(pct_fmt)
+    s.map(curr_fmt)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.map(float_fmt)
+    s.map(pct_fmt)
+    s.map(curr_fmt)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "formatter_factories",
+    "mean_ms": total_ms / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total_ms,
+}))

benchmarks/pandas/bench_reindex_fill.py

@@ -0,0 +1,40 @@
+"""
+Benchmark: pandas Series.reindex() with ffill / bfill fill methods.
+Mirrors tsb's reindexSeries with method="ffill"/"bfill".
+Outputs JSON: {"function": "reindex_fill", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+import numpy as np
+
+SIZE = 50_000
+WARMUP = 5
+ITERATIONS = 30
+
+# Sparse original index: every other position
+orig_index = [i * 2 for i in range(SIZE)]
+data = [np.sin(i * 0.01) for i in range(SIZE)]
+s = pd.Series(data, index=orig_index)
+
+# Dense new index: fills in the gaps
+new_index = list(range(SIZE * 2))
+
+for _ in range(WARMUP):
+    s.reindex(new_index, method="ffill")
+    s.reindex(new_index, method="bfill")
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.reindex(new_index, method="ffill")
+    s.reindex(new_index, method="bfill")
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "reindex_fill",
+    "mean_ms": total_ms / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total_ms,
+}))

benchmarks/pandas/bench_sample_weighted.py

@@ -0,0 +1,36 @@
+"""
+Benchmark: pandas Series.sample() with weights — weighted random sampling.
+Mirrors tsb's sampleSeries with weights option.
+Outputs JSON: {"function": "sample_weighted", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+SIZE = 100_000
+N_SAMPLE = 1_000
+WARMUP = 5
+ITERATIONS = 30
+
+data = [i * 0.5 for i in range(SIZE)]
+# Weights: higher values get more weight (triangular distribution)
+weights = [(i + 1) / SIZE for i in range(SIZE)]
+
+s = pd.Series(data)
+
+for _ in range(WARMUP):
+    s.sample(n=N_SAMPLE, weights=weights, replace=False)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.sample(n=N_SAMPLE, weights=weights, replace=False)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "sample_weighted",
+    "mean_ms": total_ms / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total_ms,
+}))

benchmarks/pandas/bench_series_shift_fn.py

@@ -0,0 +1,35 @@
+"""
+Benchmark: pandas Series.shift() — shift a 100k-element Series by 1, 3,
+and -2 periods. Mirrors tsb's shiftSeries standalone function.
+Outputs JSON: {"function": "series_shift_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 30
+
+s = pd.Series([i * 0.5 for i in range(SIZE)])
+
+for _ in range(WARMUP):
+    s.shift(1)
+    s.shift(3)
+    s.shift(-2)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.shift(1)
+    s.shift(3)
+    s.shift(-2)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "series_shift_fn",
+    "mean_ms": total_ms / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total_ms,
+}))

benchmarks/tsb/bench_cat_intersect_diff.ts

@@ -0,0 +1,43 @@
+/**
+ * Benchmark: catIntersectCategories / catDiffCategories — set operations on
+ * categorical Series categories (100k-element Series with 20 categories each).
+ * Outputs JSON: {"function": "cat_intersect_diff", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, catIntersectCategories, catDiffCategories } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+// Build two categorical Series with overlapping but not identical category sets
+const catsA = Array.from({ length: 20 }, (_, i) => `cat_a_${i}`);
+const catsB = Array.from({ length: 20 }, (_, i) => `cat_${i < 10 ? "a" : "b"}_${i}`);
+
+const dataA = Array.from({ length: SIZE }, (_, i) => catsA[i % catsA.length]);
+const dataB = Array.from({ length: SIZE }, (_, i) => catsB[i % catsB.length]);
+
+const sA = new Series({ data: dataA }).cat.setCategories(catsA);
+const sB = new Series({ data: dataB }).cat.setCategories(catsB);
+
+for (let i = 0; i < WARMUP; i++) {
+  catIntersectCategories(sA, sB);
+  catDiffCategories(sA, sB);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  catIntersectCategories(sA, sB);
+  catDiffCategories(sA, sB);
+  times.push(performance.now() - t0);
+}
+
+const total = times.reduce((a, b) => a + b, 0);
+console.log(
+  JSON.stringify({
+    function: "cat_intersect_diff",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_formatter_factories.ts

@@ -0,0 +1,48 @@
+/**
+ * Benchmark: makeFloatFormatter / makePercentFormatter / makeCurrencyFormatter
+ * — create formatter functions and apply each to a 100k-element Series.
+ * Outputs JSON: {"function": "formatter_factories", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import {
+  Series,
+  makeFloatFormatter,
+  makePercentFormatter,
+  makeCurrencyFormatter,
+  applySeriesFormatter,
+} from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+const data = Array.from({ length: SIZE }, (_, i) => i * 0.0001234);
+const s = new Series({ data });
+
+const floatFmt = makeFloatFormatter(3);
+const pctFmt = makePercentFormatter(1);
+const currFmt = makeCurrencyFormatter("€", 2);
+
+for (let i = 0; i < WARMUP; i++) {
+  applySeriesFormatter(s, floatFmt);
+  applySeriesFormatter(s, pctFmt);
+  applySeriesFormatter(s, currFmt);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  applySeriesFormatter(s, floatFmt);
+  applySeriesFormatter(s, pctFmt);
+  applySeriesFormatter(s, currFmt);
+  times.push(performance.now() - t0);
+}
+
+const total = times.reduce((a, b) => a + b, 0);
+console.log(
+  JSON.stringify({
+    function: "formatter_factories",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_reindex_fill.ts

@@ -0,0 +1,42 @@
+/**
+ * Benchmark: reindexSeries with fill methods (ffill / bfill) — realign a
+ * 100k-element Series to a larger index using forward-fill and backward-fill.
+ * Extends bench_reindex which only tests the no-fill case.
+ * Outputs JSON: {"function": "reindex_fill", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, Index, reindexSeries } from "../../src/index.ts";
+
+const SIZE = 50_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+// Sparse original index: every other position
+const origLabels = Array.from({ length: SIZE }, (_, i) => i * 2);
+const data = Array.from({ length: SIZE }, (_, i) => Math.sin(i * 0.01));
+const s = new Series({ data, index: new Index(origLabels) });
+
+// Dense new index: fills in the gaps
+const newIndex = Array.from({ length: SIZE * 2 }, (_, i) => i);
+
+for (let i = 0; i < WARMUP; i++) {
+  reindexSeries(s, newIndex, { method: "ffill" });
+  reindexSeries(s, newIndex, { method: "bfill" });
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  reindexSeries(s, newIndex, { method: "ffill" });
+  reindexSeries(s, newIndex, { method: "bfill" });
+  times.push(performance.now() - t0);
+}
+
+const total = times.reduce((a, b) => a + b, 0);
+console.log(
+  JSON.stringify({
+    function: "reindex_fill",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_sample_weighted.ts

@@ -0,0 +1,38 @@
+/**
+ * Benchmark: sampleSeries with weights — weighted random sampling from a
+ * 100k-element Series. Extends bench_sample_fn which tests unweighted sampling.
+ * Outputs JSON: {"function": "sample_weighted", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, sampleSeries } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const N_SAMPLE = 1_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+const data = Array.from({ length: SIZE }, (_, i) => i * 0.5);
+// Weights: higher values get more weight (triangular distribution)
+const weights = Array.from({ length: SIZE }, (_, i) => (i + 1) / SIZE);
+
+const s = new Series({ data });
+
+for (let i = 0; i < WARMUP; i++) {
+  sampleSeries(s, { n: N_SAMPLE, weights });
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  sampleSeries(s, { n: N_SAMPLE, weights });
+  times.push(performance.now() - t0);
+}
+
+const total = times.reduce((a, b) => a + b, 0);
+console.log(
+  JSON.stringify({
+    function: "sample_weighted",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);