Iteration 151: Add 5 benchmark pairs (478 total, +5 vs best 473)

Added benchmarks:
- df_any_all_axis1: anyDataFrame/allDataFrame row-wise (axis=1)
- df_nunique_axis1: nuniqueDataFrame row-wise (axis=1)
- cat_codes_accessor: CategoricalAccessor.codes/nCategories/ordered properties
- ewm_adjust: EWM with adjust=false (IIR) vs adjust=true
- interpolate_bfill_limit: interpolateSeries bfill method with limit option

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_cat_codes_accessor.py

@@ -0,0 +1,42 @@
+"""
+Benchmark: pd.Categorical.codes / categories / ordered — category accessor properties
+on a 100k-element categorical Series.
+Outputs JSON: {"function": "cat_codes_accessor", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+CATS = 50
+WARMUP = 5
+ITERATIONS = 30
+
+categories = [f"cat_{i}" for i in range(CATS)]
+data = [categories[i % CATS] for i in range(SIZE)]
+s = pd.Categorical(data, categories=categories)
+ps = pd.Series(s)
+
+for _ in range(WARMUP):
+    _ = ps.cat.codes
+    _ = ps.cat.categories
+    _ = ps.cat.ordered
+    _ = len(ps.cat.categories)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    _ = ps.cat.codes
+    _ = ps.cat.categories
+    _ = ps.cat.ordered
+    _ = len(ps.cat.categories)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "cat_codes_accessor",
+    "mean_ms": round(total_ms / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total_ms, 3),
+}))

benchmarks/pandas/bench_df_any_all_axis1.py

@@ -0,0 +1,38 @@
+"""
+Benchmark: DataFrame.any(axis=1) / all(axis=1) — row-wise boolean reductions on 100k-row DataFrame.
+Outputs JSON: {"function": "df_any_all_axis1", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 20
+
+df = pd.DataFrame({
+    "a": np.arange(SIZE) % 2 == 0,
+    "b": np.arange(SIZE) % 3 != 0,
+    "c": np.arange(SIZE) > 0,
+    "d": np.arange(SIZE) % 5 == 0,
+})
+
+for _ in range(WARMUP):
+    df.any(axis=1)
+    df.all(axis=1)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.any(axis=1)
+    df.all(axis=1)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "df_any_all_axis1",
+    "mean_ms": round(total_ms / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total_ms, 3),
+}))

benchmarks/pandas/bench_df_nunique_axis1.py

@@ -0,0 +1,37 @@
+"""
+Benchmark: DataFrame.nunique(axis=1) — count unique values per row on a 10k-row DataFrame.
+Outputs JSON: {"function": "df_nunique_axis1", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 30
+
+df = pd.DataFrame({
+    "a": np.arange(SIZE) % 5,
+    "b": np.arange(SIZE) % 10,
+    "c": np.arange(SIZE) % 3,
+    "d": np.arange(SIZE) % 7,
+    "e": np.arange(SIZE) % 4,
+})
+
+for _ in range(WARMUP):
+    df.nunique(axis=1)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.nunique(axis=1)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "df_nunique_axis1",
+    "mean_ms": round(total_ms / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total_ms, 3),
+}))

benchmarks/pandas/bench_ewm_adjust.py

@@ -0,0 +1,36 @@
+"""
+Benchmark: EWM with adjust=False — IIR-based exponential weighted mean vs default adjust=True on 100k Series.
+Outputs JSON: {"function": "ewm_adjust", "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 = np.sin(np.arange(SIZE) * 0.01) * 100
+s = pd.Series(data)
+
+for _ in range(WARMUP):
+    s.ewm(alpha=0.3, adjust=False).mean()
+    s.ewm(alpha=0.3, adjust=True).mean()
+    s.ewm(span=20, adjust=False).mean()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.ewm(alpha=0.3, adjust=False).mean()
+    s.ewm(alpha=0.3, adjust=True).mean()
+    s.ewm(span=20, adjust=False).mean()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "ewm_adjust",
+    "mean_ms": round(total_ms / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total_ms, 3),
+}))

benchmarks/pandas/bench_interpolate_bfill_limit.py

@@ -0,0 +1,36 @@
+"""
+Benchmark: Series.interpolate with bfill method and limit option — backward fill with gap limit on 50k Series.
+Outputs JSON: {"function": "interpolate_bfill_limit", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 50_000
+WARMUP = 5
+ITERATIONS = 30
+
+data = np.where(np.arange(SIZE) % 7 < 2, np.nan, np.sin(np.arange(SIZE) * 0.01) * 100)
+s = pd.Series(data)
+
+for _ in range(WARMUP):
+    s.interpolate(method="bfill")
+    s.ffill(limit=2)
+    s.bfill(limit=1)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.interpolate(method="bfill")
+    s.ffill(limit=2)
+    s.bfill(limit=1)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "interpolate_bfill_limit",
+    "mean_ms": round(total_ms / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total_ms, 3),
+}))

benchmarks/tsb/bench_cat_codes_accessor.ts

@@ -0,0 +1,40 @@
+/**
+ * Benchmark: CategoricalAccessor.codes / nCategories / ordered — category accessor
+ * properties on a 100k-element categorical Series.
+ * Outputs JSON: {"function": "cat_codes_accessor", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const CATS = 50;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+const categories = Array.from({ length: CATS }, (_, i) => `cat_${i}`);
+const data = Array.from({ length: SIZE }, (_, i) => categories[i % CATS]);
+const s = new Series({ data });
+
+for (let i = 0; i < WARMUP; i++) {
+  void s.cat.codes;
+  void s.cat.nCategories;
+  void s.cat.ordered;
+  void s.cat.categories;
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  void s.cat.codes;
+  void s.cat.nCategories;
+  void s.cat.ordered;
+  void s.cat.categories;
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "cat_codes_accessor",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_df_any_all_axis1.ts

@@ -0,0 +1,39 @@
+/**
+ * Benchmark: anyDataFrame / allDataFrame with axis=1 — row-wise boolean reductions on 100k-row DataFrame.
+ * Outputs JSON: {"function": "df_any_all_axis1", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, Series, anyDataFrame, allDataFrame } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 20;
+
+const df = new DataFrame({
+  columns: new Map([
+    ["a", new Series({ data: Array.from({ length: SIZE }, (_, i) => i % 2 === 0) })],
+    ["b", new Series({ data: Array.from({ length: SIZE }, (_, i) => i % 3 !== 0) })],
+    ["c", new Series({ data: Array.from({ length: SIZE }, (_, i) => i > 0) })],
+    ["d", new Series({ data: Array.from({ length: SIZE }, (_, i) => i % 5 === 0) })],
+  ]),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  anyDataFrame(df, { axis: 1 });
+  allDataFrame(df, { axis: 1 });
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  anyDataFrame(df, { axis: 1 });
+  allDataFrame(df, { axis: 1 });
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "df_any_all_axis1",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_df_nunique_axis1.ts

@@ -0,0 +1,38 @@
+/**
+ * Benchmark: nuniqueDataFrame with axis=1 — count unique values per row on a 10k-row DataFrame.
+ * Outputs JSON: {"function": "df_nunique_axis1", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, Series, nuniqueDataFrame } from "../../src/index.ts";
+
+const SIZE = 10_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+const df = new DataFrame({
+  columns: new Map([
+    ["a", new Series({ data: Array.from({ length: SIZE }, (_, i) => i % 5) })],
+    ["b", new Series({ data: Array.from({ length: SIZE }, (_, i) => i % 10) })],
+    ["c", new Series({ data: Array.from({ length: SIZE }, (_, i) => i % 3) })],
+    ["d", new Series({ data: Array.from({ length: SIZE }, (_, i) => i % 7) })],
+    ["e", new Series({ data: Array.from({ length: SIZE }, (_, i) => i % 4) })],
+  ]),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  nuniqueDataFrame(df, { axis: 1 });
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  nuniqueDataFrame(df, { axis: 1 });
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "df_nunique_axis1",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_ewm_adjust.ts

@@ -0,0 +1,35 @@
+/**
+ * Benchmark: EWM with adjust=false — IIR-based exponential weighted mean vs default adjust=true on 100k Series.
+ * Outputs JSON: {"function": "ewm_adjust", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 20;
+
+const data = Array.from({ length: SIZE }, (_, i) => Math.sin(i * 0.01) * 100);
+const s = new Series({ data });
+
+for (let i = 0; i < WARMUP; i++) {
+  s.ewm({ alpha: 0.3, adjust: false }).mean();
+  s.ewm({ alpha: 0.3, adjust: true }).mean();
+  s.ewm({ span: 20, adjust: false }).mean();
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  s.ewm({ alpha: 0.3, adjust: false }).mean();
+  s.ewm({ alpha: 0.3, adjust: true }).mean();
+  s.ewm({ span: 20, adjust: false }).mean();
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "ewm_adjust",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_interpolate_bfill_limit.ts

@@ -0,0 +1,40 @@
+/**
+ * Benchmark: interpolateSeries with bfill method and limit option — backward fill with gap limit on 50k Series.
+ * Outputs JSON: {"function": "interpolate_bfill_limit", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, interpolateSeries } from "../../src/index.ts";
+
+const SIZE = 50_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+// ~15% NaN values with consecutive gaps of up to 5
+const data = Array.from({ length: SIZE }, (_, i) => {
+  const gap = i % 7;
+  if (gap === 0 || gap === 1) return null;
+  return Math.sin(i * 0.01) * 100;
+});
+const s = new Series({ data });
+
+for (let i = 0; i < WARMUP; i++) {
+  interpolateSeries(s, { method: "bfill" });
+  interpolateSeries(s, { method: "ffill", limit: 2 });
+  interpolateSeries(s, { method: "bfill", limit: 1 });
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  interpolateSeries(s, { method: "bfill" });
+  interpolateSeries(s, { method: "ffill", limit: 2 });
+  interpolateSeries(s, { method: "bfill", limit: 1 });
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "interpolate_bfill_limit",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);