Iteration 145: Add 9 benchmark pairs (454 total, +9 vs best 445)

Added benchmarks for standalone functional forms not yet covered:
- mode_dataframe_fn: modeDataFrame standalone vs pandas df.mode()
- where_mask_series_fn: whereSeries/maskSeries standalone vs pandas
- where_mask_df_fn: whereDataFrame/maskDataFrame standalone vs pandas
- idxmin_max_df: idxminDataFrame/idxmaxDataFrame vs pandas df.idxmin/idxmax
- interpolate_fn: interpolateSeries/dataFrameInterpolate standalone vs pandas
- explode_fn: explodeSeries/explodeDataFrame standalone vs pandas
- fillna_fn: fillnaSeries/fillnaDataFrame standalone vs pandas
- dropna_fn: dropnaSeries/dropnaDataFrame standalone vs pandas
- diff_applymap_fn: diffSeries/applymap standalone vs pandas

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_diff_applymap_fn.py

@@ -0,0 +1,37 @@
+"""
+Benchmark: pandas Series.diff() + DataFrame.applymap() — diff and element-wise map.
+Outputs JSON: {"function": "diff_applymap_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+import numpy as np
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 30
+
+s = pd.Series([i * 1.0 + np.sin(i * 0.01) for i in range(SIZE)])
+
+df = pd.DataFrame({
+    "a": [i * 0.1 for i in range(SIZE)],
+    "b": [i * 0.2 + 1 for i in range(SIZE)],
+    "c": [i * -0.1 for i in range(SIZE)],
+})
+
+for _ in range(WARMUP):
+    s.diff()
+    s.diff(2)
+    df.map(lambda v: v ** 2)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.diff()
+    s.diff(2)
+    df.map(lambda v: v ** 2)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({"function": "diff_applymap_fn", "mean_ms": round(mean_ms, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_dropna_fn.py

@@ -0,0 +1,39 @@
+"""
+Benchmark: pandas Series.dropna() / DataFrame.dropna() — drop missing values.
+Outputs JSON: {"function": "dropna_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+import numpy as np
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 30
+
+series_data = [float("nan") if i % 5 == 0 else i * 1.0 for i in range(SIZE)]
+s = pd.Series(series_data)
+
+df = pd.DataFrame({
+    "a": [float("nan") if i % 5 == 0 else i * 0.1 for i in range(SIZE)],
+    "b": [float("nan") if i % 7 == 0 else i * 2.0 for i in range(SIZE)],
+    "c": [float("nan") if i % 3 == 0 else i % 100 for i in range(SIZE)],
+})
+
+for _ in range(WARMUP):
+    s.dropna()
+    df.dropna()
+    df.dropna(how="any")
+    df.dropna(how="all")
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.dropna()
+    df.dropna()
+    df.dropna(how="any")
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({"function": "dropna_fn", "mean_ms": round(mean_ms, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_explode_fn.py

@@ -0,0 +1,36 @@
+"""
+Benchmark: pandas Series.explode() / DataFrame.explode() — expand list-like elements.
+Outputs JSON: {"function": "explode_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+import numpy as np
+
+ROWS = 10_000
+WARMUP = 5
+ITERATIONS = 20
+
+series_data = [list(range(i * 10 + j for j in range((i % 4) + 2))) for i in range(ROWS)]
+series_data = [[i * 10 + j for j in range((i % 4) + 2)] for i in range(ROWS)]
+s = pd.Series(series_data)
+
+df = pd.DataFrame({
+    "a": [[i + j for j in range((i % 3) + 1)] for i in range(ROWS)],
+    "b": [f"key_{i % 100}" for i in range(ROWS)],
+})
+
+for _ in range(WARMUP):
+    s.explode()
+    df.explode("a")
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.explode()
+    df.explode("a")
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({"function": "explode_fn", "mean_ms": round(mean_ms, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_fillna_fn.py

@@ -0,0 +1,40 @@
+"""
+Benchmark: pandas Series.fillna() / DataFrame.fillna() — fill missing values.
+Outputs JSON: {"function": "fillna_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+import numpy as np
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 30
+
+series_data = [float("nan") if i % 5 == 0 else i * 1.0 for i in range(SIZE)]
+s = pd.Series(series_data)
+
+df = pd.DataFrame({
+    "a": [float("nan") if i % 5 == 0 else i * 0.1 for i in range(SIZE)],
+    "b": [float("nan") if i % 7 == 0 else i * 2.0 for i in range(SIZE)],
+    "c": [None if i % 3 == 0 else f"cat{i % 10}" for i in range(SIZE)],
+})
+
+for _ in range(WARMUP):
+    s.fillna(0)
+    s.fillna(method="ffill")
+    df.fillna(0)
+    df.fillna(method="bfill")
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.fillna(0)
+    s.fillna(method="ffill")
+    df.fillna(0)
+    df.fillna(method="bfill")
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({"function": "fillna_fn", "mean_ms": round(mean_ms, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_idxmin_max_df.py

@@ -0,0 +1,34 @@
+"""
+Benchmark: pandas DataFrame.idxmin() / DataFrame.idxmax() — index of min/max per column.
+Outputs JSON: {"function": "idxmin_max_df", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+import numpy as np
+
+ROWS = 100_000
+WARMUP = 5
+ITERATIONS = 30
+
+df = pd.DataFrame({
+    "a": [np.sin(i * 0.001) * 100 for i in range(ROWS)],
+    "b": [float("nan") if i % 100 == 0 else i * 0.1 for i in range(ROWS)],
+    "c": [i * 1.0 if i % 2 == 0 else -i * 1.0 for i in range(ROWS)],
+})
+
+for _ in range(WARMUP):
+    df.idxmin()
+    df.idxmax()
+    df.idxmin(skipna=False)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.idxmin()
+    df.idxmax()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({"function": "idxmin_max_df", "mean_ms": round(mean_ms, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_interpolate_fn.py

@@ -0,0 +1,37 @@
+"""
+Benchmark: pandas Series.interpolate() / DataFrame.interpolate() — fill NaN by interpolation.
+Outputs JSON: {"function": "interpolate_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+import numpy as np
+
+SIZE = 50_000
+WARMUP = 5
+ITERATIONS = 20
+
+series_data = [float("nan") if i % 10 == 0 else i * 1.0 for i in range(SIZE)]
+s = pd.Series(series_data)
+
+df = pd.DataFrame({
+    "a": [float("nan") if i % 7 == 0 else i * 0.5 for i in range(SIZE)],
+    "b": [float("nan") if i % 11 == 0 else np.sin(i * 0.01) * 100 for i in range(SIZE)],
+})
+
+for _ in range(WARMUP):
+    s.interpolate(method="linear")
+    s.interpolate(method="pad")
+    df.interpolate()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.interpolate(method="linear")
+    s.interpolate(method="pad")
+    df.interpolate()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({"function": "interpolate_fn", "mean_ms": round(mean_ms, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_mode_dataframe_fn.py

@@ -0,0 +1,33 @@
+"""
+Benchmark: pandas DataFrame.mode() — column-wise mode.
+Outputs JSON: {"function": "mode_dataframe_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+import numpy as np
+
+ROWS = 10_000
+WARMUP = 5
+ITERATIONS = 20
+
+df = pd.DataFrame({
+    "a": [i % 10 for i in range(ROWS)],
+    "b": [float("nan") if i % 50 == 0 else i % 5 for i in range(ROWS)],
+    "c": [i % 3 for i in range(ROWS)],
+})
+
+for _ in range(WARMUP):
+    df.mode()
+    df.mode(dropna=False)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.mode()
+    df.mode(dropna=False)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({"function": "mode_dataframe_fn", "mean_ms": round(mean_ms, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_where_mask_df_fn.py

@@ -0,0 +1,35 @@
+"""
+Benchmark: pandas DataFrame.where() / DataFrame.mask() — conditional replacement.
+Outputs JSON: {"function": "where_mask_df_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+import numpy as np
+
+ROWS = 100_000
+WARMUP = 5
+ITERATIONS = 20
+
+df = pd.DataFrame({
+    "a": [i * 1.0 for i in range(ROWS)],
+    "b": [float("nan") if i % 2 == 0 else i * 0.5 for i in range(ROWS)],
+    "c": [i * -1.0 for i in range(ROWS)],
+})
+
+cond = df > 0
+
+for _ in range(WARMUP):
+    df.where(cond, other=0)
+    df.mask(cond, other=-1)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.where(cond, other=0)
+    df.mask(cond, other=-1)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({"function": "where_mask_df_fn", "mean_ms": round(mean_ms, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_where_mask_series_fn.py

@@ -0,0 +1,31 @@
+"""
+Benchmark: pandas Series.where() / Series.mask() — conditional replacement.
+Outputs JSON: {"function": "where_mask_series_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+import numpy as np
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 30
+
+s = pd.Series([i * 0.1 for i in range(SIZE)])
+cond = s > SIZE * 0.05
+cond_arr = pd.Series([i > SIZE * 0.5 for i in range(SIZE)])
+
+for _ in range(WARMUP):
+    s.where(cond, 0)
+    s.mask(cond_arr, -1)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.where(cond, 0)
+    s.mask(cond_arr, -1)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({"function": "where_mask_series_fn", "mean_ms": round(mean_ms, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/tsb/bench_diff_applymap_fn.ts

@@ -0,0 +1,43 @@
+/**
+ * Benchmark: diffSeries standalone + applymap — diff and element-wise map.
+ * Outputs JSON: {"function": "diff_applymap_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, DataFrame, diffSeries, applymap } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+const s = new Series({ data: Array.from({ length: SIZE }, (_, i) => i * 1.0 + Math.sin(i * 0.01)) });
+
+const df = DataFrame.fromColumns({
+  a: Array.from({ length: SIZE }, (_, i) => i * 0.1),
+  b: Array.from({ length: SIZE }, (_, i) => i * 0.2 + 1),
+  c: Array.from({ length: SIZE }, (_, i) => i * -0.1),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  diffSeries(s);
+  diffSeries(s, 2);
+  applymap(df, (v) => (v as number) ** 2);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  diffSeries(s);
+  diffSeries(s, 2);
+  applymap(df, (v) => (v as number) ** 2);
+  times.push(performance.now() - t0);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "diff_applymap_fn",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);