Iteration 187: 5 new benchmark pairs (539 total, +5 vs canonical 534)

Add benchmarks for Hour/Second DateOffset, digitize standalone, toNumeric generic,
NamedAgg class/factory/isNamedAggSpec, and combineFirstSeries standalone.
These cover previously unbenchmarked exported symbols from src/.

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_combine_first_series.py

@@ -0,0 +1,33 @@
+"""Benchmark: Series.combine_first (standalone equivalent) — fill missing values from another Series.
+Mirrors tsb bench_combine_first_series.ts for pandas.
+"""
+import json, time
+import pandas as pd
+import numpy as np
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 50
+
+data1 = [None if i % 3 == 0 else i * 0.5 for i in range(SIZE)]
+data2 = [i * 0.1 for i in range(SIZE)]
+s1 = pd.Series(data1)
+s2 = pd.Series(data2)
+
+for _ in range(WARMUP):
+    s1.combine_first(s2)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s1.combine_first(s2)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total = sum(times)
+mean = total / ITERATIONS
+print(json.dumps({
+    "function": "combine_first_series",
+    "mean_ms": round(mean, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total, 3),
+}))

benchmarks/pandas/bench_date_offset_hour_second.py

@@ -0,0 +1,38 @@
+"""Benchmark: DateOffset Hour and Second — apply operations on 5k dates.
+Mirrors tsb bench_date_offset_hour_second.ts for pandas.
+"""
+import json, time
+from datetime import timedelta
+import pandas as pd
+from pandas.tseries.offsets import Hour, Second
+
+SIZE = 5_000
+WARMUP = 5
+ITERATIONS = 50
+
+hour = Hour(3)
+second = Second(90)
+base = pd.Timestamp("2020-01-15 10:00:00", tz="UTC")
+dates = [base + timedelta(minutes=i) for i in range(SIZE)]
+
+for _ in range(WARMUP):
+    for d in dates[:100]:
+        d + hour
+        d + second
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    for d in dates:
+        d + hour
+        d + second
+    times.append((time.perf_counter() - t0) * 1000)
+
+total = sum(times)
+mean = total / ITERATIONS
+print(json.dumps({
+    "function": "date_offset_hour_second",
+    "mean_ms": round(mean, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total, 3),
+}))

benchmarks/pandas/bench_digitize_fn.py

@@ -0,0 +1,35 @@
+"""Benchmark: numpy.digitize (standalone) — bin 50k values into 10 bins.
+Mirrors tsb bench_digitize_fn.ts for numpy/pandas.
+"""
+import json, time
+import numpy as np
+
+SIZE = 50_000
+WARMUP = 5
+ITERATIONS = 50
+
+rng = np.random.default_rng(42)
+values = np.where(
+    np.arange(SIZE) % 20 == 0,
+    np.nan,
+    (np.arange(SIZE) % 100) * 0.1,
+).tolist()
+bins = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+for _ in range(WARMUP):
+    np.digitize(values, bins)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    np.digitize(values, bins)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total = sum(times)
+mean = total / ITERATIONS
+print(json.dumps({
+    "function": "digitize_fn",
+    "mean_ms": round(mean, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total, 3),
+}))

benchmarks/pandas/bench_named_agg_class.py

@@ -0,0 +1,45 @@
+"""Benchmark: pd.NamedAgg class construction and isinstance validation — 100 specs × 1000 iters.
+Mirrors tsb bench_named_agg_class.ts for pandas.
+"""
+import json, time
+import pandas as pd
+
+WARMUP = 5
+ITERATIONS = 1_000
+N = 100
+
+sample_spec = {
+    "total": pd.NamedAgg(column="salary", aggfunc="sum"),
+    "avg": pd.NamedAgg(column="salary", aggfunc="mean"),
+    "max": pd.NamedAgg(column="salary", aggfunc="max"),
+    "cnt": pd.NamedAgg(column="headcount", aggfunc="count"),
+}
+
+def is_named_agg_spec(spec):
+    return isinstance(spec, dict) and all(isinstance(v, pd.NamedAgg) for v in spec.values())
+
+for _ in range(WARMUP):
+    for _ in range(N):
+        pd.NamedAgg(column="salary", aggfunc="sum")
+        pd.NamedAgg(column="score", aggfunc="mean")
+        is_named_agg_spec(sample_spec)
+        is_named_agg_spec({"x": "not-namedagg"})
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    for _ in range(N):
+        pd.NamedAgg(column="salary", aggfunc="sum")
+        pd.NamedAgg(column="score", aggfunc="mean")
+        is_named_agg_spec(sample_spec)
+        is_named_agg_spec({"x": "not-namedagg"})
+    times.append((time.perf_counter() - t0) * 1000)
+
+total = sum(times)
+mean = total / ITERATIONS
+print(json.dumps({
+    "function": "named_agg_class",
+    "mean_ms": round(mean, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total, 3),
+}))

benchmarks/pandas/bench_to_numeric_generic.py

@@ -0,0 +1,34 @@
+"""Benchmark: pd.to_numeric generic dispatcher — coerce scalars, lists, and Series.
+Mirrors tsb bench_to_numeric_generic.ts for pandas.
+"""
+import json, time
+import pandas as pd
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 50
+
+str_nums = [str(i * 0.1) for i in range(SIZE)]
+series = pd.Series(str_nums)
+
+for _ in range(WARMUP):
+    pd.to_numeric("3.14")
+    pd.to_numeric(str_nums[:100], errors="coerce")
+    pd.to_numeric(series, errors="coerce")
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    pd.to_numeric("3.14")
+    pd.to_numeric(str_nums, errors="coerce")
+    pd.to_numeric(series, errors="coerce")
+    times.append((time.perf_counter() - t0) * 1000)
+
+total = sum(times)
+mean = total / ITERATIONS
+print(json.dumps({
+    "function": "to_numeric_generic",
+    "mean_ms": round(mean, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total, 3),
+}))

benchmarks/tsb/bench_combine_first_series.ts

@@ -0,0 +1,38 @@
+/**
+ * Benchmark: combineFirstSeries (standalone) — fill missing values from another Series.
+ * Outputs JSON: {"function": "combine_first_series", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { combineFirstSeries, Series } from "../../src/index.ts";
+
+const SIZE = 10_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const data1: (number | null)[] = Array.from({ length: SIZE }, (_, i) =>
+  i % 3 === 0 ? null : i * 0.5,
+);
+const data2 = Array.from({ length: SIZE }, (_, i) => i * 0.1);
+const s1 = new Series({ data: data1 });
+const s2 = new Series({ data: data2 });
+
+for (let i = 0; i < WARMUP; i++) {
+  combineFirstSeries(s1, s2);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  combineFirstSeries(s1, s2);
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "combine_first_series",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);

benchmarks/tsb/bench_date_offset_hour_second.ts

@@ -0,0 +1,42 @@
+/**
+ * Benchmark: DateOffset Hour and Second — apply operations on 5k dates.
+ * Outputs JSON: {"function": "date_offset_hour_second", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Hour, Second } from "../../src/index.ts";
+
+const SIZE = 5_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const hour = new Hour(3);
+const second = new Second(90);
+const base = new Date(Date.UTC(2020, 0, 15, 10, 0, 0));
+const dates = Array.from({ length: SIZE }, (_, i) => new Date(base.getTime() + i * 60_000));
+
+for (let i = 0; i < WARMUP; i++) {
+  for (const d of dates.slice(0, 100)) {
+    hour.apply(d);
+    second.apply(d);
+  }
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  for (const d of dates) {
+    hour.apply(d);
+    second.apply(d);
+  }
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "date_offset_hour_second",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);

benchmarks/tsb/bench_digitize_fn.ts

@@ -0,0 +1,36 @@
+/**
+ * Benchmark: digitize (standalone) — bin 50k values into 10 bins.
+ * Outputs JSON: {"function": "digitize_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { digitize } from "../../src/index.ts";
+
+const SIZE = 50_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const values: (number | null)[] = Array.from({ length: SIZE }, (_, i) =>
+  i % 20 === 0 ? null : (i % 100) * 0.1,
+);
+const bins = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+
+for (let i = 0; i < WARMUP; i++) {
+  digitize(values, bins);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  digitize(values, bins);
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "digitize_fn",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);

benchmarks/tsb/bench_named_agg_class.ts

@@ -0,0 +1,48 @@
+/**
+ * Benchmark: NamedAgg class, namedAgg factory, isNamedAggSpec — construct and validate 10k specs.
+ * Outputs JSON: {"function": "named_agg_class", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { NamedAgg, namedAgg, isNamedAggSpec } from "../../src/index.ts";
+
+const WARMUP = 5;
+const ITERATIONS = 1_000;
+const N = 100;
+
+const sampleSpec = {
+  total: namedAgg("salary", "sum"),
+  avg: namedAgg("salary", "mean"),
+  max: namedAgg("salary", "max"),
+  cnt: namedAgg("headcount", "count"),
+};
+
+for (let i = 0; i < WARMUP; i++) {
+  for (let j = 0; j < N; j++) {
+    new NamedAgg("salary", "sum");
+    namedAgg("score", "mean");
+    isNamedAggSpec(sampleSpec);
+    isNamedAggSpec({ x: "not-namedagg" });
+  }
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  for (let j = 0; j < N; j++) {
+    new NamedAgg("salary", "sum");
+    namedAgg("score", "mean");
+    isNamedAggSpec(sampleSpec);
+    isNamedAggSpec({ x: "not-namedagg" });
+  }
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "named_agg_class",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);

benchmarks/tsb/bench_to_numeric_generic.ts

@@ -0,0 +1,38 @@
+/**
+ * Benchmark: toNumeric (generic dispatcher) — coerce scalars, arrays, and Series.
+ * Outputs JSON: {"function": "to_numeric_generic", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { toNumeric, Series } from "../../src/index.ts";
+
+const SIZE = 10_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const strNums = Array.from({ length: SIZE }, (_, i) => String(i * 0.1));
+const series = new Series({ data: strNums });
+
+for (let i = 0; i < WARMUP; i++) {
+  toNumeric("3.14");
+  toNumeric(strNums.slice(0, 100), { errors: "coerce" });
+  toNumeric(series, { errors: "coerce" });
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  toNumeric("3.14");
+  toNumeric(strNums, { errors: "coerce" });
+  toNumeric(series, { errors: "coerce" });
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "to_numeric_generic",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);