Iteration 170: 5 new benchmark pairs (539 total, +5 vs branch 534)

Add cumulative ops and nan-aggregate benchmark pairs:
- nancumops_extra: nanmedian, nancount, nanprod (previously unbenchmarked)
- cumops_skipna: cumsum/cumprod with skipna=false option
- dataframe_cumops_axis1: DataFrame cumsum/cumprod with axis=1 (row-wise)
- series_cumops_nan: cumsum/cumprod/cummax/cummin on Series with NaN values
- cummax_cummin_str: cummax/cummin on string Series

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_cummax_cummin_str.py

@@ -0,0 +1,27 @@
+"""
+Benchmark: Series.cummax() / cummin() on string Series of 10k elements.
+Outputs JSON: {"function": "cummax_cummin_str", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 50
+
+words = ["apple", "banana", "cherry", "date", "elderberry", "fig", "grape", "honeydew"]
+data = [words[i % len(words)] for i in range(SIZE)]
+s = pd.Series(data)
+
+for _ in range(WARMUP):
+    s.cummax()
+    s.cummin()
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    s.cummax()
+    s.cummin()
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({"function": "cummax_cummin_str", "mean_ms": total / ITERATIONS, "iterations": ITERATIONS, "total_ms": total}))

benchmarks/pandas/bench_cumops_skipna.py

@@ -0,0 +1,27 @@
+"""
+Benchmark: cumsum / cumprod with skipna=False on 100k-element Series.
+Outputs JSON: {"function": "cumops_skipna", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 20
+
+data = [(i % 100) * 0.001 + 1 if i % 20 != 0 else float("nan") for i in range(SIZE)]
+s = pd.Series(data)
+
+for _ in range(WARMUP):
+    s.cumsum(skipna=False)
+    s.cumprod(skipna=False)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    s.cumsum(skipna=False)
+    s.cumprod(skipna=False)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({"function": "cumops_skipna", "mean_ms": total / ITERATIONS, "iterations": ITERATIONS, "total_ms": total}))

benchmarks/pandas/bench_dataframe_cumops_axis1.py

@@ -0,0 +1,28 @@
+"""
+Benchmark: DataFrame.cumsum(axis=1) / cumprod(axis=1) (row-wise) on 10k x 8 DataFrame.
+Outputs JSON: {"function": "dataframe_cumops_axis1", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+ROWS = 10_000
+COLS = 8
+WARMUP = 3
+ITERATIONS = 20
+
+data = {f"col{c}": ((np.arange(ROWS) + c) % 10) * 0.1 + 1 for c in range(COLS)}
+df = pd.DataFrame(data)
+
+for _ in range(WARMUP):
+    df.cumsum(axis=1)
+    df.cumprod(axis=1)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    df.cumsum(axis=1)
+    df.cumprod(axis=1)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({"function": "dataframe_cumops_axis1", "mean_ms": total / ITERATIONS, "iterations": ITERATIONS, "total_ms": total}))

benchmarks/pandas/bench_nancumops_extra.py

@@ -0,0 +1,29 @@
+"""
+Benchmark: np.nanmedian / nancount / np.nanprod — additional nan-ignoring aggregates on 100k array.
+Outputs JSON: {"function": "nancumops_extra", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import math
+import time
+import numpy as np
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+# Array with ~10% NaN values
+data = np.array([float("nan") if i % 10 == 0 else math.sin(i * 0.01) * 100 + 50 for i in range(SIZE)])
+
+for _ in range(WARMUP):
+    np.nanmedian(data)
+    np.count_nonzero(~np.isnan(data))
+    np.nanprod(data[:100])  # limit to 100 to avoid overflow
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    np.nanmedian(data)
+    np.count_nonzero(~np.isnan(data))
+    np.nanprod(data[:100])
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({"function": "nancumops_extra", "mean_ms": total / ITERATIONS, "iterations": ITERATIONS, "total_ms": total}))

benchmarks/pandas/bench_series_cumops_nan.py

@@ -0,0 +1,32 @@
+"""
+Benchmark: cumsum / cumprod / cummax / cummin on 100k Series with NaN values.
+Outputs JSON: {"function": "series_cumops_nan", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import math
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 20
+
+raw = [float("nan") if i % 10 == 0 else math.sin(i * 0.01) * 50 + 100 for i in range(SIZE)]
+s = pd.Series(raw)
+
+for _ in range(WARMUP):
+    s.cumsum()
+    s.cumprod()
+    s.cummax()
+    s.cummin()
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    s.cumsum()
+    s.cumprod()
+    s.cummax()
+    s.cummin()
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({"function": "series_cumops_nan", "mean_ms": total / ITERATIONS, "iterations": ITERATIONS, "total_ms": total}))

benchmarks/tsb/bench_cummax_cummin_str.ts

@@ -0,0 +1,27 @@
+/**
+ * Benchmark: cummax / cummin on string Series of 10k elements.
+ * Outputs JSON: {"function": "cummax_cummin_str", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, cummax, cummin } from "../../src/index.ts";
+
+const SIZE = 10_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const words = ["apple", "banana", "cherry", "date", "elderberry", "fig", "grape", "honeydew"];
+const data: string[] = Array.from({ length: SIZE }, (_, i) => words[i % words.length]);
+const s = new Series({ data });
+
+for (let i = 0; i < WARMUP; i++) {
+  cummax(s);
+  cummin(s);
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  cummax(s);
+  cummin(s);
+}
+const total = performance.now() - start;
+
+console.log(JSON.stringify({ function: "cummax_cummin_str", mean_ms: total / ITERATIONS, iterations: ITERATIONS, total_ms: total }));

benchmarks/tsb/bench_cumops_skipna.ts

@@ -0,0 +1,29 @@
+/**
+ * Benchmark: cumsum / cumprod with skipna=false on 100k-element Series.
+ * Outputs JSON: {"function": "cumops_skipna", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, cumsum, cumprod } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 20;
+
+// Series with ~5% NaN values
+const data: (number | null)[] = Array.from({ length: SIZE }, (_, i) =>
+  i % 20 === 0 ? null : (i % 100) * 0.001 + 1,
+);
+const s = new Series({ data });
+
+for (let i = 0; i < WARMUP; i++) {
+  cumsum(s, { skipna: false });
+  cumprod(s, { skipna: false });
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  cumsum(s, { skipna: false });
+  cumprod(s, { skipna: false });
+}
+const total = performance.now() - start;
+
+console.log(JSON.stringify({ function: "cumops_skipna", mean_ms: total / ITERATIONS, iterations: ITERATIONS, total_ms: total }));

benchmarks/tsb/bench_dataframe_cumops_axis1.ts

@@ -0,0 +1,30 @@
+/**
+ * Benchmark: dataFrameCumsum / dataFrameCumprod with axis=1 (row-wise) on 10k x 8 DataFrame.
+ * Outputs JSON: {"function": "dataframe_cumops_axis1", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, dataFrameCumsum, dataFrameCumprod } from "../../src/index.ts";
+
+const ROWS = 10_000;
+const COLS = 8;
+const WARMUP = 3;
+const ITERATIONS = 20;
+
+const data: Record<string, number[]> = {};
+for (let c = 0; c < COLS; c++) {
+  data[`col${c}`] = Array.from({ length: ROWS }, (_, i) => ((i + c) % 10) * 0.1 + 1);
+}
+const df = new DataFrame(data);
+
+for (let i = 0; i < WARMUP; i++) {
+  dataFrameCumsum(df, { axis: 1 });
+  dataFrameCumprod(df, { axis: 1 });
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  dataFrameCumsum(df, { axis: 1 });
+  dataFrameCumprod(df, { axis: 1 });
+}
+const total = performance.now() - start;
+
+console.log(JSON.stringify({ function: "dataframe_cumops_axis1", mean_ms: total / ITERATIONS, iterations: ITERATIONS, total_ms: total }));

benchmarks/tsb/bench_nancumops_extra.ts

@@ -0,0 +1,30 @@
+/**
+ * Benchmark: nanmedian / nancount / nanprod — additional nan-ignoring aggregates on 100k array.
+ * Outputs JSON: {"function": "nancumops_extra", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { nanmedian, nancount, nanprod } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+// Array with ~10% NaN values
+const data: (number | null)[] = Array.from({ length: SIZE }, (_, i) =>
+  i % 10 === 0 ? null : Math.sin(i * 0.01) * 100 + 50,
+);
+
+for (let i = 0; i < WARMUP; i++) {
+  nanmedian(data);
+  nancount(data);
+  nanprod(data);
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  nanmedian(data);
+  nancount(data);
+  nanprod(data);
+}
+const total = performance.now() - start;
+
+console.log(JSON.stringify({ function: "nancumops_extra", mean_ms: total / ITERATIONS, iterations: ITERATIONS, total_ms: total }));

benchmarks/tsb/bench_series_cumops_nan.ts

@@ -0,0 +1,33 @@
+/**
+ * Benchmark: cumsum / cumprod / cummax / cummin on 100k-element Series with NaN values (skipna=true).
+ * Outputs JSON: {"function": "series_cumops_nan", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, cumsum, cumprod, cummax, cummin } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 20;
+
+// ~10% NaN values
+const data: (number | null)[] = Array.from({ length: SIZE }, (_, i) =>
+  i % 10 === 0 ? null : Math.sin(i * 0.01) * 50 + 100,
+);
+const s = new Series({ data });
+
+for (let i = 0; i < WARMUP; i++) {
+  cumsum(s);
+  cumprod(s);
+  cummax(s);
+  cummin(s);
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  cumsum(s);
+  cumprod(s);
+  cummax(s);
+  cummin(s);
+}
+const total = performance.now() - start;
+
+console.log(JSON.stringify({ function: "series_cumops_nan", mean_ms: total / ITERATIONS, iterations: ITERATIONS, total_ms: total }));