Iteration 175: 5 new benchmark pairs (539 total, +5 vs best 534)

Add: str_contains, fillna_col_map, groupby_agg_no_index, crosstab_normalize, pct_change_periods

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_crosstab_normalize.py

@@ -0,0 +1,36 @@
+"""Benchmark: pd.crosstab() with normalize options — proportions by row/col/all."""
+import json, time
+import pandas as pd
+import numpy as np
+
+SIZE = 50_000
+WARMUP = 5
+ITERATIONS = 30
+
+rng = np.random.default_rng(99)
+choices_a = ["north", "south", "east", "west"]
+choices_b = ["red", "green", "blue"]
+
+a = pd.Series(np.array(choices_a)[rng.integers(0, 4, SIZE)])
+b = pd.Series(np.array(choices_b)[rng.integers(0, 3, SIZE)])
+
+for _ in range(WARMUP):
+    pd.crosstab(a, b, normalize=True)
+    pd.crosstab(a, b, normalize="index")
+    pd.crosstab(a, b, normalize="columns")
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    pd.crosstab(a, b, normalize=True)
+    pd.crosstab(a, b, normalize="index")
+    pd.crosstab(a, b, normalize="columns")
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "crosstab_normalize",
+    "mean_ms": round(total_ms / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total_ms, 3),
+}))

benchmarks/pandas/bench_fillna_col_map.py

@@ -0,0 +1,35 @@
+"""Benchmark: DataFrame.fillna() with per-column fill dict."""
+import json, time, random
+import pandas as pd
+import numpy as np
+
+ROWS = 50_000
+WARMUP = 5
+ITERATIONS = 30
+
+random.seed(42)
+rng = np.random.default_rng(42)
+
+col_a = np.where(rng.random(ROWS) < 0.2, np.nan, rng.random(ROWS) * 100)
+col_b = np.where(rng.random(ROWS) < 0.2, np.nan, rng.random(ROWS) * 50)
+col_c = np.where(rng.random(ROWS) < 0.2, np.nan, rng.random(ROWS) * 200)
+
+df = pd.DataFrame({"a": col_a, "b": col_b, "c": col_c})
+fill_map = {"a": 0, "b": -1, "c": 99}
+
+for _ in range(WARMUP):
+    df.fillna(fill_map)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.fillna(fill_map)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "fillna_col_map",
+    "mean_ms": round(total_ms / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total_ms, 3),
+}))

benchmarks/pandas/bench_groupby_agg_no_index.py

@@ -0,0 +1,33 @@
+"""Benchmark: DataFrameGroupBy.agg() with as_index=False — group key as column."""
+import json, time
+import pandas as pd
+import numpy as np
+
+SIZE = 100_000
+WARMUP = 3
+ITERATIONS = 20
+
+rng = np.random.default_rng(42)
+groups = np.array(["alpha", "beta", "gamma", "delta", "epsilon"])
+df = pd.DataFrame({
+    "group": groups[rng.integers(0, 5, SIZE)],
+    "x": rng.random(SIZE) * 100,
+    "y": rng.random(SIZE) * 50,
+})
+
+for _ in range(WARMUP):
+    df.groupby("group", as_index=False).agg({"x": "mean", "y": "sum"})
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.groupby("group", as_index=False).agg({"x": "mean", "y": "sum"})
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "groupby_agg_no_index",
+    "mean_ms": round(total_ms / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total_ms, 3),
+}))

benchmarks/pandas/bench_pct_change_periods.py

@@ -0,0 +1,39 @@
+"""Benchmark: Series.pct_change() / DataFrame.pct_change() with various periods."""
+import json, time
+import pandas as pd
+import numpy as np
+
+ROWS = 100_000
+WARMUP = 5
+ITERATIONS = 30
+
+rng = np.random.default_rng(7)
+data = rng.random(ROWS) * 100 + 10
+
+series = pd.Series(data)
+df = pd.DataFrame({
+    "a": data,
+    "b": data * 1.5,
+    "c": data * 0.8,
+})
+
+for _ in range(WARMUP):
+    series.pct_change(periods=1)
+    series.pct_change(periods=7)
+    df.pct_change(periods=5)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    series.pct_change(periods=1)
+    series.pct_change(periods=7)
+    df.pct_change(periods=5)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "pct_change_periods",
+    "mean_ms": round(total_ms / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total_ms, 3),
+}))

benchmarks/pandas/bench_str_contains.py

@@ -0,0 +1,29 @@
+"""Benchmark: pd.Series.str.contains() — regex and literal substring matching on 100k strings."""
+import json, time
+import pandas as pd
+
+ROWS = 100_000
+WARMUP = 5
+ITERATIONS = 30
+
+data = [f"item_{i % 500}_value_{i % 7}_end" for i in range(ROWS)]
+s = pd.Series(data)
+
+for _ in range(WARMUP):
+    s.str.contains("value", regex=False)
+    s.str.contains(r"_[0-9]+_", regex=True)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.str.contains("value", regex=False)
+    s.str.contains(r"_[0-9]+_", regex=True)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "str_contains",
+    "mean_ms": round(total_ms / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total_ms, 3),
+}))

benchmarks/tsb/bench_crosstab_normalize.ts

@@ -0,0 +1,46 @@
+/**
+ * Benchmark: crosstab() with normalize options — proportions by row/col/all.
+ * Outputs JSON: {"function": "crosstab_normalize", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, crosstab } from "../../src/index.ts";
+
+const SIZE = 50_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+let seed = 99;
+const rand = () => {
+  seed = (seed * 1664525 + 1013904223) & 0x7fffffff;
+  return seed;
+};
+
+const choices_a = ["north", "south", "east", "west"];
+const choices_b = ["red", "green", "blue"];
+
+const a = new Series({ data: Array.from({ length: SIZE }, () => choices_a[rand() % 4]) });
+const b = new Series({ data: Array.from({ length: SIZE }, () => choices_b[rand() % 3]) });
+
+for (let i = 0; i < WARMUP; i++) {
+  crosstab(a, b, { normalize: true });
+  crosstab(a, b, { normalize: "index" });
+  crosstab(a, b, { normalize: "columns" });
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  crosstab(a, b, { normalize: true });
+  crosstab(a, b, { normalize: "index" });
+  crosstab(a, b, { normalize: "columns" });
+  times.push(performance.now() - t0);
+}
+
+const total_ms = times.reduce((a, b) => a + b, 0);
+console.log(
+  JSON.stringify({
+    function: "crosstab_normalize",
+    mean_ms: Math.round((total_ms / ITERATIONS) * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(total_ms * 1000) / 1000,
+  }),
+);

benchmarks/tsb/bench_fillna_col_map.ts

@@ -0,0 +1,50 @@
+/**
+ * Benchmark: fillnaDataFrame with ColumnFillMap — per-column fill values.
+ * Outputs JSON: {"function": "fillna_col_map", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, Series, fillnaDataFrame } from "../../src/index.ts";
+
+const ROWS = 50_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+function seededRand(seed: number) {
+  let s = seed;
+  return () => {
+    s = (s * 1664525 + 1013904223) & 0x7fffffff;
+    return s / 0x7fffffff;
+  };
+}
+
+const rand = seededRand(42);
+
+// Build a DataFrame with ~20% NaN in each column
+const colA = Array.from({ length: ROWS }, () => (rand() < 0.2 ? null : rand() * 100));
+const colB = Array.from({ length: ROWS }, () => (rand() < 0.2 ? null : rand() * 50));
+const colC = Array.from({ length: ROWS }, () => (rand() < 0.2 ? null : rand() * 200));
+
+const df = new DataFrame({ a: colA, b: colB, c: colC });
+
+// Per-column fill values
+const fillMap: Record<string, number> = { a: 0, b: -1, c: 99 };
+
+for (let i = 0; i < WARMUP; i++) {
+  fillnaDataFrame(df, { value: fillMap });
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  fillnaDataFrame(df, { value: fillMap });
+  times.push(performance.now() - t0);
+}
+
+const total_ms = times.reduce((a, b) => a + b, 0);
+console.log(
+  JSON.stringify({
+    function: "fillna_col_map",
+    mean_ms: Math.round((total_ms / ITERATIONS) * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(total_ms * 1000) / 1000,
+  }),
+);

benchmarks/tsb/bench_groupby_agg_no_index.ts

@@ -0,0 +1,43 @@
+/**
+ * Benchmark: DataFrameGroupBy.agg() with asIndex=false — group key as column.
+ * Outputs JSON: {"function": "groupby_agg_no_index", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 3;
+const ITERATIONS = 20;
+
+let s = 42;
+const rand = () => {
+  s = (s * 1664525 + 1013904223) & 0x7fffffff;
+  return s / 0x7fffffff;
+};
+
+const groups = ["alpha", "beta", "gamma", "delta", "epsilon"];
+const df = new DataFrame({
+  group: Array.from({ length: SIZE }, () => groups[Math.floor(rand() * 5)]),
+  x: Array.from({ length: SIZE }, () => rand() * 100),
+  y: Array.from({ length: SIZE }, () => rand() * 50),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  df.groupby("group").agg({ x: "mean", y: "sum" }, false);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  df.groupby("group").agg({ x: "mean", y: "sum" }, false);
+  times.push(performance.now() - t0);
+}
+
+const total_ms = times.reduce((a, b) => a + b, 0);
+console.log(
+  JSON.stringify({
+    function: "groupby_agg_no_index",
+    mean_ms: Math.round((total_ms / ITERATIONS) * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(total_ms * 1000) / 1000,
+  }),
+);

benchmarks/tsb/bench_pct_change_periods.ts

@@ -0,0 +1,49 @@
+/**
+ * Benchmark: pctChangeSeries / pctChangeDataFrame with various period values.
+ * Outputs JSON: {"function": "pct_change_periods", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, DataFrame, pctChangeSeries, pctChangeDataFrame } from "../../src/index.ts";
+
+const ROWS = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+let s = 7;
+const rand = () => {
+  s = (s * 1664525 + 1013904223) & 0x7fffffff;
+  return s / 0x7fffffff;
+};
+
+const data = Array.from({ length: ROWS }, () => rand() * 100 + 10);
+const series = new Series({ data });
+
+const df = new DataFrame({
+  a: data,
+  b: data.map((v) => v * 1.5),
+  c: data.map((v) => v * 0.8),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  pctChangeSeries(series, { periods: 1 });
+  pctChangeSeries(series, { periods: 7 });
+  pctChangeDataFrame(df, { periods: 5 });
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  pctChangeSeries(series, { periods: 1 });
+  pctChangeSeries(series, { periods: 7 });
+  pctChangeDataFrame(df, { periods: 5 });
+  times.push(performance.now() - t0);
+}
+
+const total_ms = times.reduce((a, b) => a + b, 0);
+console.log(
+  JSON.stringify({
+    function: "pct_change_periods",
+    mean_ms: Math.round((total_ms / ITERATIONS) * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(total_ms * 1000) / 1000,
+  }),
+);