Iteration 188: 6 new benchmark pairs (540 total, +1 vs best 539)

Add standalone function benchmarks: shiftSeries, isin (Series), astype (DataFrame),
combineFirstSeries, toNumeric generic dispatcher, and pivot standalone.

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_astype_df_fn.py

@@ -0,0 +1,31 @@
+"""Benchmark: astype standalone — DataFrame.astype with per-column and uniform dtype on 100k-row DataFrame."""
+import json, time
+import pandas as pd
+import numpy as np
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+df = pd.DataFrame({
+    "a": np.arange(SIZE, dtype=np.float64),
+    "b": np.arange(SIZE, dtype=np.int64),
+    "c": np.where(np.arange(SIZE) % 2 == 0, 1, 0).astype(np.int64),
+})
+
+for _ in range(WARMUP):
+    df.astype({"a": "float32", "b": "int32"})
+    df.astype("float64")
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    df.astype({"a": "float32", "b": "int32"})
+    df.astype("float64")
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "astype_df_fn",
+    "mean_ms": round(total / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total, 3),
+}))

benchmarks/pandas/bench_combine_first_fn.py

@@ -0,0 +1,29 @@
+"""Benchmark: combineFirstSeries standalone — pd.Series.combine_first() on 50k-element Series with 30% NaN."""
+import json, time
+import pandas as pd
+import numpy as np
+
+SIZE = 50_000
+WARMUP = 5
+ITERATIONS = 30
+
+rng = np.random.default_rng(42)
+data1 = rng.standard_normal(SIZE)
+data1[::3] = float("nan")  # ~30% nulls
+s1 = pd.Series(data1)
+s2 = pd.Series(np.arange(SIZE, dtype=np.float64) * 2.0)
+
+for _ in range(WARMUP):
+    s1.combine_first(s2)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    s1.combine_first(s2)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "combine_first_fn",
+    "mean_ms": round(total / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total, 3),
+}))

benchmarks/pandas/bench_isin_series_fn.py

@@ -0,0 +1,28 @@
+"""Benchmark: isin standalone — pd.Series.isin with large and small value sets on 100k-element Series."""
+import json, time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+s = pd.Series([i % 5000 for i in range(SIZE)])
+test_set = list(range(2500))
+test_set2 = [100, 200, 300, 400, 500]
+
+for _ in range(WARMUP):
+    s.isin(test_set)
+    s.isin(test_set2)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    s.isin(test_set)
+    s.isin(test_set2)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "isin_series_fn",
+    "mean_ms": round(total / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total, 3),
+}))

benchmarks/pandas/bench_pivot_fn.py

@@ -0,0 +1,35 @@
+"""Benchmark: pivot standalone — pd.pivot() standalone function on a 100×20 grid DataFrame."""
+import json, time
+import pandas as pd
+import numpy as np
+
+ROWS = 100
+COLS = 20
+WARMUP = 5
+ITERATIONS = 50
+
+row_arr = []
+col_arr = []
+val_arr = []
+for r in range(ROWS):
+    for c in range(COLS):
+        row_arr.append(r)
+        col_arr.append(c)
+        val_arr.append(r * COLS + c + 0.5)
+
+df = pd.DataFrame({"row": row_arr, "col": col_arr, "val": val_arr})
+
+for _ in range(WARMUP):
+    pd.pivot(df, index="row", columns="col", values="val")
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    pd.pivot(df, index="row", columns="col", values="val")
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "pivot_fn",
+    "mean_ms": round(total / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total, 3),
+}))

benchmarks/pandas/bench_shift_series_fn.py

@@ -0,0 +1,29 @@
+"""Benchmark: shiftSeries (standalone) — shift values by 1/−2/5 positions in a 100k-element Series."""
+import json, time
+import pandas as pd
+import numpy as np
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+s = pd.Series(np.arange(SIZE, dtype=np.float64))
+
+for _ in range(WARMUP):
+    s.shift(1)
+    s.shift(-2)
+    s.shift(5)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    s.shift(1)
+    s.shift(-2)
+    s.shift(5)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "shift_series_fn",
+    "mean_ms": round(total / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total, 3),
+}))

benchmarks/pandas/bench_to_numeric_dispatch.py

@@ -0,0 +1,29 @@
+"""Benchmark: toNumeric generic — pd.to_numeric() with array, Series, and scalar inputs."""
+import json, time
+import pandas as pd
+
+SIZE = 50_000
+WARMUP = 5
+ITERATIONS = 30
+
+str_nums = [str(i * 1.5) for i in range(SIZE)]
+s = pd.Series(str_nums)
+
+for _ in range(WARMUP):
+    pd.to_numeric(str_nums, errors="coerce")
+    pd.to_numeric(s, errors="coerce")
+    pd.to_numeric("42.7")
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    pd.to_numeric(str_nums, errors="coerce")
+    pd.to_numeric(s, errors="coerce")
+    pd.to_numeric("42.7")
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "to_numeric_dispatch",
+    "mean_ms": round(total / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total, 3),
+}))

benchmarks/tsb/bench_astype_df_fn.ts

@@ -0,0 +1,37 @@
+/**
+ * Benchmark: astype (standalone DataFrame) — exported astype(df, dtype) function on 100k-row DataFrame.
+ * Mirrors pandas DataFrame.astype() called via standalone function.
+ * Outputs JSON: {"function": "astype_df_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, astype } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const df = new DataFrame({
+  a: Array.from({ length: SIZE }, (_, i) => i * 1.0),
+  b: Array.from({ length: SIZE }, (_, i) => i),
+  c: Array.from({ length: SIZE }, (_, i) => (i % 2 === 0 ? 1 : 0)),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  astype(df, { a: "float32", b: "int32" });
+  astype(df, "float64");
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  astype(df, { a: "float32", b: "int32" });
+  astype(df, "float64");
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "astype_df_fn",
+    mean_ms: Math.round((total / ITERATIONS) * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(total * 1000) / 1000,
+  }),
+);

benchmarks/tsb/bench_combine_first_fn.ts

@@ -0,0 +1,37 @@
+/**
+ * Benchmark: combineFirstSeries standalone — exported combineFirstSeries(s1, s2) function.
+ * Mirrors pandas Series.combine_first().
+ * Outputs JSON: {"function": "combine_first_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, combineFirstSeries } from "../../src/index.ts";
+
+const SIZE = 50_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+// s1: 50k elements with ~30% nulls
+const data1 = Array.from({ length: SIZE }, (_, i) => (i % 3 === 0 ? null : i * 1.5));
+// s2: 50k elements, fills in the nulls
+const data2 = Array.from({ length: SIZE }, (_, i) => i * 2.0);
+
+const s1 = new Series({ data: data1 });
+const s2 = new Series({ data: data2 });
+
+for (let i = 0; i < WARMUP; i++) {
+  combineFirstSeries(s1, s2);
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  combineFirstSeries(s1, s2);
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "combine_first_fn",
+    mean_ms: Math.round((total / ITERATIONS) * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(total * 1000) / 1000,
+  }),
+);

benchmarks/tsb/bench_isin_series_fn.ts

@@ -0,0 +1,35 @@
+/**
+ * Benchmark: isin standalone — exported isin(series, values) function on 100k-element Series.
+ * Mirrors pandas Series.isin() called as a standalone function.
+ * Outputs JSON: {"function": "isin_series_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, isin } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const s = new Series({ data: Array.from({ length: SIZE }, (_, i) => i % 5000) });
+const testSet = Array.from({ length: 2500 }, (_, i) => i);
+const testSet2 = [100, 200, 300, 400, 500];
+
+for (let i = 0; i < WARMUP; i++) {
+  isin(s, testSet);
+  isin(s, testSet2);
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  isin(s, testSet);
+  isin(s, testSet2);
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "isin_series_fn",
+    mean_ms: Math.round((total / ITERATIONS) * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(total * 1000) / 1000,
+  }),
+);

benchmarks/tsb/bench_pivot_fn.ts

@@ -0,0 +1,43 @@
+/**
+ * Benchmark: pivot standalone — exported pivot(df, options) function on a DataFrame.
+ * Mirrors pandas pd.pivot() standalone function.
+ * Outputs JSON: {"function": "pivot_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, pivot } from "../../src/index.ts";
+
+const ROWS = 100;
+const COLS = 20;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+// Build a ROWS×COLS grid of (row, col, val) triples
+const rowArr: number[] = [];
+const colArr: number[] = [];
+const valArr: number[] = [];
+for (let r = 0; r < ROWS; r++) {
+  for (let c = 0; c < COLS; c++) {
+    rowArr.push(r);
+    colArr.push(c);
+    valArr.push(r * COLS + c + 0.5);
+  }
+}
+const df = new DataFrame({ row: rowArr, col: colArr, val: valArr });
+
+for (let i = 0; i < WARMUP; i++) {
+  pivot(df, { index: "row", columns: "col", values: "val" });
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  pivot(df, { index: "row", columns: "col", values: "val" });
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "pivot_fn",
+    mean_ms: Math.round((total / ITERATIONS) * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(total * 1000) / 1000,
+  }),
+);