Iteration 157: 5 new benchmark pairs (503 total, +5 vs best 498)

Added benchmarks for:
- nan_agg_extended: nancount/nanprod/nanmedian (extended nan aggregates)
- rank_methods: rankSeries with min/max/first/dense tie-breaking methods
- dropna_advanced: dropnaDataFrame with thresh/subset/axis=1 options
- get_dummies_opts: getDummies/dataFrameGetDummies with prefix/dropFirst/dummyNa
- factorize_sort: factorize/seriesFactorize with sort=true/useNaSentinel options

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_dropna_advanced.py

@@ -0,0 +1,35 @@
+"""
+Benchmark: DataFrame.dropna with advanced options (thresh, subset, axis=1).
+Outputs JSON: {"function": "dropna_advanced", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 30
+
+# DataFrame with scattered null values
+rng = np.random.default_rng(42)
+df = pd.DataFrame({
+    "a": [None if i % 4 == 0 else i * 0.1 for i in range(SIZE)],
+    "b": [None if i % 6 == 0 else i * 2.0 for i in range(SIZE)],
+    "c": [None if i % 8 == 0 else i % 100 for i in range(SIZE)],
+    "d": [None if i % 3 == 0 else f"val_{i % 20}" for i in range(SIZE)],
+})
+
+for _ in range(WARMUP):
+    df.dropna(thresh=3)
+    df.dropna(subset=["a", "b"])
+    df.dropna(axis=1)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    df.dropna(thresh=3)
+    df.dropna(subset=["a", "b"])
+    df.dropna(axis=1)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({"function": "dropna_advanced", "mean_ms": total / ITERATIONS, "iterations": ITERATIONS, "total_ms": total}))

benchmarks/pandas/bench_factorize_sort.py

@@ -0,0 +1,30 @@
+"""
+Benchmark: pandas.factorize / Series.factorize with sort=True and use_na_sentinel options.
+Outputs JSON: {"function": "factorize_sort", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 30
+
+categories = ["zebra", "apple", "mango", "banana", "coconut", "date"]
+data = [None if i % 15 == 0 else categories[i % len(categories)] for i in range(SIZE)]
+s = pd.Series(data, dtype="object")
+
+for _ in range(WARMUP):
+    pd.factorize(data, sort=True)
+    pd.factorize(data, sort=True, use_na_sentinel=True)
+    s.factorize(sort=True)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    pd.factorize(data, sort=True)
+    pd.factorize(data, sort=True, use_na_sentinel=True)
+    s.factorize(sort=True)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({"function": "factorize_sort", "mean_ms": total / ITERATIONS, "iterations": ITERATIONS, "total_ms": total}))

benchmarks/pandas/bench_get_dummies_opts.py

@@ -0,0 +1,34 @@
+"""
+Benchmark: pandas.get_dummies with prefix, drop_first, dummy_na options.
+Outputs JSON: {"function": "get_dummies_opts", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 30
+
+categories = ["apple", "banana", "cherry", "date", "elderberry"]
+data = [None if i % 20 == 0 else categories[i % len(categories)] for i in range(SIZE)]
+s = pd.Series(data, dtype="object")
+
+df = pd.DataFrame({
+    "fruit": [None if i % 20 == 0 else categories[i % len(categories)] for i in range(SIZE)],
+    "color": [["red", "green", "blue"][i % 3] for i in range(SIZE)],
+})
+
+for _ in range(WARMUP):
+    pd.get_dummies(s, prefix="cat", dummy_na=True)
+    pd.get_dummies(s, drop_first=True)
+    pd.get_dummies(df, columns=["fruit", "color"], prefix="col", drop_first=True)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    pd.get_dummies(s, prefix="cat", dummy_na=True)
+    pd.get_dummies(s, drop_first=True)
+    pd.get_dummies(df, columns=["fruit", "color"], prefix="col", drop_first=True)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({"function": "get_dummies_opts", "mean_ms": total / ITERATIONS, "iterations": ITERATIONS, "total_ms": total}))

benchmarks/pandas/bench_nan_agg_extended.py

@@ -0,0 +1,29 @@
+"""
+Benchmark: np.count_nonzero / np.nanprod / np.nanmedian — extended nan-ignoring aggregates.
+Outputs JSON: {"function": "nan_agg_extended", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import math
+import time
+import numpy as np
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+# Array with ~15% NaN values
+data = np.array([float("nan") if i % 7 == 0 else math.cos(i * 0.02) * 50 + 1 for i in range(SIZE)])
+
+for _ in range(WARMUP):
+    np.sum(~np.isnan(data))
+    np.nanprod(data[:1000])
+    np.nanmedian(data)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    np.sum(~np.isnan(data))
+    np.nanprod(data[:1000])
+    np.nanmedian(data)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({"function": "nan_agg_extended", "mean_ms": total / ITERATIONS, "iterations": ITERATIONS, "total_ms": total}))

benchmarks/pandas/bench_rank_methods.py

@@ -0,0 +1,31 @@
+"""
+Benchmark: Series.rank with different tie-breaking methods (min/max/first/dense).
+Outputs JSON: {"function": "rank_methods", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 30
+
+# Data with many ties to stress different tie-breaking methods
+data = [float((i // 5) * 1.0) for i in range(SIZE)]
+s = pd.Series(data)
+
+for _ in range(WARMUP):
+    s.rank(method="min")
+    s.rank(method="max")
+    s.rank(method="first")
+    s.rank(method="dense")
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    s.rank(method="min")
+    s.rank(method="max")
+    s.rank(method="first")
+    s.rank(method="dense")
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({"function": "rank_methods", "mean_ms": total / ITERATIONS, "iterations": ITERATIONS, "total_ms": total}))

benchmarks/tsb/bench_dropna_advanced.ts

@@ -0,0 +1,33 @@
+/**
+ * Benchmark: dropnaDataFrame with advanced options (thresh, subset, axis=1).
+ * Outputs JSON: {"function": "dropna_advanced", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, dropnaDataFrame } from "../../src/index.ts";
+
+const SIZE = 10_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+// DataFrame with scattered null values
+const df = DataFrame.fromColumns({
+  a: Array.from({ length: SIZE }, (_, i) => (i % 4 === 0 ? null : i * 0.1)),
+  b: Array.from({ length: SIZE }, (_, i) => (i % 6 === 0 ? null : i * 2.0)),
+  c: Array.from({ length: SIZE }, (_, i) => (i % 8 === 0 ? null : i % 100)),
+  d: Array.from({ length: SIZE }, (_, i) => (i % 3 === 0 ? null : `val_${i % 20}`)),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  dropnaDataFrame(df, { thresh: 3 });
+  dropnaDataFrame(df, { subset: ["a", "b"] });
+  dropnaDataFrame(df, { axis: 1 });
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  dropnaDataFrame(df, { thresh: 3 });
+  dropnaDataFrame(df, { subset: ["a", "b"] });
+  dropnaDataFrame(df, { axis: 1 });
+}
+const total = performance.now() - start;
+
+console.log(JSON.stringify({ function: "dropna_advanced", mean_ms: total / ITERATIONS, iterations: ITERATIONS, total_ms: total }));

benchmarks/tsb/bench_factorize_sort.ts

@@ -0,0 +1,31 @@
+/**
+ * Benchmark: factorize / seriesFactorize with sort=true and useNaSentinel options.
+ * Outputs JSON: {"function": "factorize_sort", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { factorize, seriesFactorize, Series } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+const categories = ["zebra", "apple", "mango", "banana", "coconut", "date"];
+const data = Array.from({ length: SIZE }, (_, i) =>
+  i % 15 === 0 ? null : categories[i % categories.length],
+);
+const s = new Series({ data });
+
+for (let i = 0; i < WARMUP; i++) {
+  factorize(data, { sort: true });
+  factorize(data, { sort: true, useNaSentinel: true });
+  seriesFactorize(s, { sort: true });
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  factorize(data, { sort: true });
+  factorize(data, { sort: true, useNaSentinel: true });
+  seriesFactorize(s, { sort: true });
+}
+const total = performance.now() - start;
+
+console.log(JSON.stringify({ function: "factorize_sort", mean_ms: total / ITERATIONS, iterations: ITERATIONS, total_ms: total }));

benchmarks/tsb/bench_get_dummies_opts.ts

@@ -0,0 +1,38 @@
+/**
+ * Benchmark: getDummies / dataFrameGetDummies with prefix, dropFirst, dummyNa options.
+ * Outputs JSON: {"function": "get_dummies_opts", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { getDummies, dataFrameGetDummies, Series, DataFrame } from "../../src/index.ts";
+
+const SIZE = 10_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+const categories = ["apple", "banana", "cherry", "date", "elderberry"];
+const data = Array.from({ length: SIZE }, (_, i) =>
+  i % 20 === 0 ? null : categories[i % categories.length],
+);
+const s = new Series({ data });
+
+const df = DataFrame.fromColumns({
+  fruit: Array.from({ length: SIZE }, (_, i) =>
+    i % 20 === 0 ? null : categories[i % categories.length],
+  ),
+  color: Array.from({ length: SIZE }, (_, i) => ["red", "green", "blue"][i % 3]),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  getDummies(s, { prefix: "cat", dummyNa: true });
+  getDummies(s, { dropFirst: true });
+  dataFrameGetDummies(df, { columns: ["fruit", "color"], prefix: "col", dropFirst: true });
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  getDummies(s, { prefix: "cat", dummyNa: true });
+  getDummies(s, { dropFirst: true });
+  dataFrameGetDummies(df, { columns: ["fruit", "color"], prefix: "col", dropFirst: true });
+}
+const total = performance.now() - start;
+
+console.log(JSON.stringify({ function: "get_dummies_opts", mean_ms: total / ITERATIONS, iterations: ITERATIONS, total_ms: total }));

benchmarks/tsb/bench_nan_agg_extended.ts

@@ -0,0 +1,30 @@
+/**
+ * Benchmark: nancount / nanprod / nanmedian — extended nan-ignoring aggregates.
+ * Outputs JSON: {"function": "nan_agg_extended", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { nancount, nanprod, nanmedian } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+// Array with ~15% NaN values
+const data: (number | null)[] = Array.from({ length: SIZE }, (_, i) =>
+  i % 7 === 0 ? null : Math.cos(i * 0.02) * 50 + 1,
+);
+
+for (let i = 0; i < WARMUP; i++) {
+  nancount(data);
+  nanprod(data.slice(0, 1000)); // nanprod on small slice to avoid overflow
+  nanmedian(data);
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  nancount(data);
+  nanprod(data.slice(0, 1000));
+  nanmedian(data);
+}
+const total = performance.now() - start;
+
+console.log(JSON.stringify({ function: "nan_agg_extended", mean_ms: total / ITERATIONS, iterations: ITERATIONS, total_ms: total }));

benchmarks/tsb/bench_rank_methods.ts

@@ -0,0 +1,31 @@
+/**
+ * Benchmark: rankSeries with different tie-breaking methods (min/max/first/dense).
+ * Outputs JSON: {"function": "rank_methods", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, rankSeries } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+// Data with many ties to stress different tie-breaking methods
+const data = Array.from({ length: SIZE }, (_, i) => Math.floor(i / 5) * 1.0);
+const s = new Series({ data });
+
+for (let i = 0; i < WARMUP; i++) {
+  rankSeries(s, { method: "min" });
+  rankSeries(s, { method: "max" });
+  rankSeries(s, { method: "first" });
+  rankSeries(s, { method: "dense" });
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  rankSeries(s, { method: "min" });
+  rankSeries(s, { method: "max" });
+  rankSeries(s, { method: "first" });
+  rankSeries(s, { method: "dense" });
+}
+const total = performance.now() - start;
+
+console.log(JSON.stringify({ function: "rank_methods", mean_ms: total / ITERATIONS, iterations: ITERATIONS, total_ms: total }));