Iteration 173: 25 new benchmark pairs (559 total, +20 via merge + 5 new)

Merged 20 benchmark pairs from non-canonical branch (iterations 167-170):
cummax_cummin_str, cumops_skipna, dataframe_cov_options, dataframe_cumops_axis1,
dataframe_rolling_apply_fn, dropna_thresh_subset, histogram_bin_edges,
interpolate_zero_nearest, json_normalize_meta, nan_sum_mean_std, nan_var_min_max,
nancumops_extra, pct_change_fill_method, pivot_table_aggfunc_variants,
pivot_table_fill_value, read_json_all_orients, reindex_fill_methods,
sample_weights, series_cumops_nan, wide_to_long_sep_suffix.

Added 5 new benchmark pairs:
- interpolate_methods: all 5 methods (linear/ffill/bfill/nearest/zero)
- explode_dataframe: explodeDataFrame list-column expansion
- nlargest_dataframe: nlargestDataFrame/nsmallestDataFrame top-N rows
- select_dtypes_options: selectDtypes with include/exclude variants
- get_dummies_drop_first: getDummies/dataFrameGetDummies with drop_first + prefix

Metric: 559 (previous best: 539, delta: +20)

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_explode_dataframe.py

@@ -0,0 +1,23 @@
+"""Benchmark: DataFrame.explode() — explode list-column into rows."""
+import json, time
+import pandas as pd
+
+ROWS = 10_000
+WARMUP = 5
+ITERATIONS = 30
+
+vals = [[i, i + 1, i + 2] for i in range(ROWS)]
+labels = [f"cat_{i % 100}" for i in range(ROWS)]
+df = pd.DataFrame({"vals": vals, "labels": labels})
+
+for _ in range(WARMUP):
+    df.explode("vals")
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.explode("vals")
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function": "explode_dataframe", "mean_ms": round(total_ms / ITERATIONS, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_get_dummies_drop_first.py

@@ -0,0 +1,31 @@
+"""Benchmark: pd.get_dummies with drop_first and prefix options."""
+import json, time
+import pandas as pd
+import numpy as np
+
+ROWS = 50_000
+WARMUP = 5
+ITERATIONS = 30
+
+cat_data = [f"cat_{i % 10}" for i in range(ROWS)]
+s = pd.Categorical(cat_data)
+df = pd.DataFrame({
+    "category": cat_data,
+    "value": np.arange(ROWS, dtype=np.float64) * 0.1,
+})
+
+for _ in range(WARMUP):
+    pd.get_dummies(s, drop_first=True)
+    pd.get_dummies(s, prefix="grp", prefix_sep="_")
+    pd.get_dummies(df, columns=["category"], drop_first=True)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    pd.get_dummies(s, drop_first=True)
+    pd.get_dummies(s, prefix="grp", prefix_sep="_")
+    pd.get_dummies(df, columns=["category"], drop_first=True)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function": "get_dummies_drop_first", "mean_ms": round(total_ms / ITERATIONS, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_interpolate_methods.py

@@ -0,0 +1,31 @@
+"""Benchmark: interpolateSeries with linear, ffill, bfill, nearest, zero methods."""
+import json, time
+import pandas as pd
+import numpy as np
+
+SIZE = 50_000
+WARMUP = 5
+ITERATIONS = 30
+
+data = [float(i) * 0.1 if i % 5 != 0 else None for i in range(SIZE)]
+s = pd.Series(data, dtype=float)
+
+for _ in range(WARMUP):
+    s.interpolate(method="linear")
+    s.ffill()
+    s.bfill()
+    s.interpolate(method="nearest")
+    s.interpolate(method="zero")
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.interpolate(method="linear")
+    s.ffill()
+    s.bfill()
+    s.interpolate(method="nearest")
+    s.interpolate(method="zero")
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function": "interpolate_methods", "mean_ms": round(total_ms / ITERATIONS, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_nlargest_dataframe.py

@@ -0,0 +1,30 @@
+"""Benchmark: DataFrame.nlargest / nsmallest — top-N rows by column."""
+import json, time
+import pandas as pd
+import numpy as np
+
+ROWS = 100_000
+N = 100
+WARMUP = 5
+ITERATIONS = 30
+
+rng = np.random.default_rng(42)
+df = pd.DataFrame({
+    "a": rng.random(ROWS) * 1000,
+    "b": rng.random(ROWS) * 500,
+    "c": rng.random(ROWS) * 100,
+})
+
+for _ in range(WARMUP):
+    df.nlargest(N, "a")
+    df.nsmallest(N, "b")
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.nlargest(N, "a")
+    df.nsmallest(N, "b")
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function": "nlargest_dataframe", "mean_ms": round(total_ms / ITERATIONS, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_select_dtypes_options.py

@@ -0,0 +1,32 @@
+"""Benchmark: DataFrame.select_dtypes() — filter columns by dtype (include/exclude)."""
+import json, time
+import pandas as pd
+import numpy as np
+
+ROWS = 50_000
+WARMUP = 5
+ITERATIONS = 30
+
+rng = np.random.default_rng(42)
+df = pd.DataFrame({
+    "intCol": np.arange(ROWS, dtype=np.int32),
+    "floatCol": np.arange(ROWS, dtype=np.float64) * 1.5,
+    "boolCol": np.arange(ROWS) % 2 == 0,
+    "strCol": [f"s_{i % 100}" for i in range(ROWS)],
+})
+
+for _ in range(WARMUP):
+    df.select_dtypes(include="number")
+    df.select_dtypes(exclude="number")
+    df.select_dtypes(include=["int", "float"])
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.select_dtypes(include="number")
+    df.select_dtypes(exclude="number")
+    df.select_dtypes(include=["int", "float"])
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function": "select_dtypes_options", "mean_ms": round(total_ms / ITERATIONS, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/tsb/bench_explode_dataframe.ts

@@ -0,0 +1,36 @@
+/**
+ * Benchmark: explodeDataFrame — explode list-column into rows.
+ * Outputs JSON: {"function": "explode_dataframe", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, Series, explodeDataFrame } from "../../src/index.ts";
+
+const ROWS = 10_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+// Each row has a list of 3-5 elements in column "vals"
+const vals = Array.from({ length: ROWS }, (_, i) => [i, i + 1, i + 2]);
+const labels = Array.from({ length: ROWS }, (_, i) => `cat_${i % 100}`);
+const df = DataFrame.fromColumns({ vals, labels });
+
+for (let i = 0; i < WARMUP; i++) {
+  explodeDataFrame(df, "vals");
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  explodeDataFrame(df, "vals");
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "explode_dataframe",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);

benchmarks/tsb/bench_get_dummies_drop_first.ts

@@ -0,0 +1,43 @@
+/**
+ * Benchmark: getDummies / dataFrameGetDummies with drop_first and prefix options.
+ * Outputs JSON: {"function": "get_dummies_drop_first", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, DataFrame, getDummies, dataFrameGetDummies } from "../../src/index.ts";
+
+const ROWS = 50_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+// Categorical series with 10 distinct values
+const catData = Array.from({ length: ROWS }, (_, i) => `cat_${i % 10}`);
+const s = new Series({ data: catData });
+const df = DataFrame.fromColumns({
+  category: catData,
+  value: Float64Array.from({ length: ROWS }, (_, i) => i * 0.1),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  getDummies(s, { dropFirst: true });
+  getDummies(s, { prefix: "grp", prefixSep: "_" });
+  dataFrameGetDummies(df, { columns: ["category"], dropFirst: true });
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  getDummies(s, { dropFirst: true });
+  getDummies(s, { prefix: "grp", prefixSep: "_" });
+  dataFrameGetDummies(df, { columns: ["category"], dropFirst: true });
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "get_dummies_drop_first",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);

benchmarks/tsb/bench_interpolate_methods.ts

@@ -0,0 +1,45 @@
+/**
+ * Benchmark: interpolateSeries with linear, ffill, bfill, nearest, zero methods.
+ * Outputs JSON: {"function": "interpolate_methods", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, interpolateSeries } from "../../src/index.ts";
+
+const SIZE = 50_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+// Build a series with ~20% NaN scattered
+const data: (number | null)[] = Array.from({ length: SIZE }, (_, i) =>
+  i % 5 === 0 ? null : i * 0.1,
+);
+const s = new Series({ data });
+
+for (let i = 0; i < WARMUP; i++) {
+  interpolateSeries(s, { method: "linear" });
+  interpolateSeries(s, { method: "ffill" });
+  interpolateSeries(s, { method: "bfill" });
+  interpolateSeries(s, { method: "nearest" });
+  interpolateSeries(s, { method: "zero" });
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  interpolateSeries(s, { method: "linear" });
+  interpolateSeries(s, { method: "ffill" });
+  interpolateSeries(s, { method: "bfill" });
+  interpolateSeries(s, { method: "nearest" });
+  interpolateSeries(s, { method: "zero" });
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "interpolate_methods",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);

benchmarks/tsb/bench_nlargest_dataframe.ts

@@ -0,0 +1,39 @@
+/**
+ * Benchmark: nlargestDataFrame / nsmallestDataFrame — top-N rows by multiple columns.
+ * Outputs JSON: {"function": "nlargest_dataframe", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, Series, nlargestDataFrame, nsmallestDataFrame } from "../../src/index.ts";
+
+const ROWS = 100_000;
+const N = 100;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+const a = new Series({ data: Float64Array.from({ length: ROWS }, () => Math.random() * 1000) });
+const b = new Series({ data: Float64Array.from({ length: ROWS }, () => Math.random() * 500) });
+const c = new Series({ data: Float64Array.from({ length: ROWS }, () => Math.random() * 100) });
+const df = DataFrame.fromColumns({ a, b, c });
+
+for (let i = 0; i < WARMUP; i++) {
+  nlargestDataFrame(df, N, { columns: ["a"] });
+  nsmallestDataFrame(df, N, { columns: ["b"] });
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  nlargestDataFrame(df, N, { columns: ["a"] });
+  nsmallestDataFrame(df, N, { columns: ["b"] });
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "nlargest_dataframe",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);

benchmarks/tsb/bench_select_dtypes_options.ts

@@ -0,0 +1,42 @@
+/**
+ * Benchmark: selectDtypes — filter DataFrame columns by dtype (include/exclude).
+ * Outputs JSON: {"function": "select_dtypes_options", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, Series, selectDtypes } from "../../src/index.ts";
+
+const ROWS = 50_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+// Build a mixed-dtype DataFrame
+const intCol = new Series({ data: Int32Array.from({ length: ROWS }, (_, i) => i) });
+const floatCol = new Series({ data: Float64Array.from({ length: ROWS }, (_, i) => i * 1.5) });
+const boolCol = new Series({ data: Array.from({ length: ROWS }, (_, i) => i % 2 === 0) });
+const strCol = new Series({ data: Array.from({ length: ROWS }, (_, i) => `s_${i % 100}`) });
+const df = DataFrame.fromColumns({ intCol, floatCol, boolCol, strCol });
+
+for (let i = 0; i < WARMUP; i++) {
+  selectDtypes(df, { include: "number" });
+  selectDtypes(df, { exclude: "number" });
+  selectDtypes(df, { include: ["integer", "float"] });
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  selectDtypes(df, { include: "number" });
+  selectDtypes(df, { exclude: "number" });
+  selectDtypes(df, { include: ["integer", "float"] });
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "select_dtypes_options",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);