Iteration 166: 5 new benchmark pairs (534 total, +5 vs best 529)

Adds benchmarks for: str_split_method, categorical_index_modify,
applySeries_fn, dataframe_apply_stats, dataframe_from_columns.
Cherry-picked iters 159-165 from diverged branch (+21) plus these 5
brings canonical branch from 508 to 534 pairs.

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_applySeries_fn.py

@@ -0,0 +1,34 @@
+"""
+Benchmark: pandas Series.apply() with (value) lambda — 100k-element Series.
+Mirrors tsb's applySeries (stats/apply.ts) behavior.
+Outputs JSON: {"function": "applySeries_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 30
+
+s = pd.Series([i * 0.5 for i in range(SIZE)])
+
+fn = lambda v: v * 2 + 1  # noqa: E731
+
+for _ in range(WARMUP):
+    s.apply(fn)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.apply(fn)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({
+    "function": "applySeries_fn",
+    "mean_ms": mean_ms,
+    "iterations": ITERATIONS,
+    "total_ms": total_ms,
+}))

benchmarks/pandas/bench_categorical_index_modify.py

@@ -0,0 +1,46 @@
+"""
+Benchmark: pandas CategoricalIndex modification — rename_categories, reorder_categories,
+remove_categories, set_categories, remove_unused_categories on a 10k-element index.
+Outputs JSON: {"function": "categorical_index_modify", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 50
+
+CATS = ["alpha", "beta", "gamma", "delta", "epsilon"]
+labels = [CATS[i % len(CATS)] for i in range(SIZE)]
+ci = pd.CategoricalIndex(labels)
+
+for _ in range(WARMUP):
+    ci.rename_categories(["A", "B", "C", "D", "E"])
+    ci.reorder_categories(["epsilon", "delta", "gamma", "beta", "alpha"])
+    ci.remove_categories(["epsilon"])
+    ci.set_categories(["alpha", "beta", "gamma"])
+    ci.remove_unused_categories()
+    ci.as_ordered()
+    ci.as_unordered()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    ci.rename_categories(["A", "B", "C", "D", "E"])
+    ci.reorder_categories(["epsilon", "delta", "gamma", "beta", "alpha"])
+    ci.remove_categories(["epsilon"])
+    ci.set_categories(["alpha", "beta", "gamma"])
+    ci.remove_unused_categories()
+    ci.as_ordered()
+    ci.as_unordered()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({
+    "function": "categorical_index_modify",
+    "mean_ms": mean_ms,
+    "iterations": ITERATIONS,
+    "total_ms": total_ms,
+}))

benchmarks/pandas/bench_dataframe_apply_stats.py

@@ -0,0 +1,41 @@
+"""
+Benchmark: pandas DataFrame.apply() — apply fn to each column (axis=0) and row (axis=1).
+Mirrors tsb's dataFrameApply (stats/apply.ts) behavior.
+Outputs JSON: {"function": "dataframe_apply_stats", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+import numpy as np
+
+SIZE = 10_000
+WARMUP = 3
+ITERATIONS = 20
+
+df = pd.DataFrame({
+    "a": (np.arange(SIZE) * 1.0),
+    "b": (np.arange(SIZE) * 2.0),
+    "c": (np.arange(SIZE) * 3.0),
+})
+
+sum_fn = lambda col: col.mean()  # noqa: E731
+
+for _ in range(WARMUP):
+    df.apply(sum_fn, axis=0)
+    df.apply(sum_fn, axis=1)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.apply(sum_fn, axis=0)
+    df.apply(sum_fn, axis=1)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({
+    "function": "dataframe_apply_stats",
+    "mean_ms": mean_ms,
+    "iterations": ITERATIONS,
+    "total_ms": total_ms,
+}))

benchmarks/pandas/bench_dataframe_from_columns.py

@@ -0,0 +1,36 @@
+"""
+Benchmark: pandas DataFrame() construction — create 100k-row DataFrame from column arrays.
+Mirrors tsb's DataFrame.fromColumns() behavior.
+Outputs JSON: {"function": "dataframe_from_columns", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+import numpy as np
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 30
+
+col_a = np.arange(SIZE, dtype=float)
+col_b = np.arange(SIZE, dtype=float) * 2.5
+col_c = np.arange(SIZE) % 1000
+col_d = np.sin(np.arange(SIZE) * 0.001)
+
+for _ in range(WARMUP):
+    pd.DataFrame({"a": col_a, "b": col_b, "c": col_c, "d": col_d})
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    pd.DataFrame({"a": col_a, "b": col_b, "c": col_c, "d": col_d})
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({
+    "function": "dataframe_from_columns",
+    "mean_ms": mean_ms,
+    "iterations": ITERATIONS,
+    "total_ms": total_ms,
+}))

benchmarks/pandas/bench_str_split_method.py

@@ -0,0 +1,34 @@
+"""
+Benchmark: pandas Series.str.split() — split strings by delimiter on 100k strings.
+Outputs JSON: {"function": "str_split_method", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 30
+
+data = [f"part{i % 100}_b{i % 50}_c{i % 25}" for i in range(SIZE)]
+s = pd.Series(data)
+
+for _ in range(WARMUP):
+    s.str.split("_")
+    s.str.split("_", n=2)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.str.split("_")
+    s.str.split("_", n=2)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({
+    "function": "str_split_method",
+    "mean_ms": mean_ms,
+    "iterations": ITERATIONS,
+    "total_ms": total_ms,
+}))

benchmarks/tsb/bench_applySeries_fn.ts

@@ -0,0 +1,36 @@
+/**
+ * Benchmark: applySeries (stats/apply.ts) — element-wise fn receiving (value, label) on 100k-element Series.
+ * This is the standalone stats version, distinct from seriesApply (core/pipe_apply.ts).
+ * Outputs JSON: {"function": "applySeries_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, applySeries } from "../../src/index.ts";
+import type { Scalar, Label } from "../../src/types.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+const s = new Series({ data: Array.from({ length: SIZE }, (_, i) => i * 0.5) });
+
+const fn = (v: Scalar, _label: Label): Scalar => (v as number) * 2 + 1;
+
+for (let i = 0; i < WARMUP; i++) {
+  applySeries(s, fn);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  applySeries(s, fn);
+  times.push(performance.now() - t0);
+}
+
+const total = times.reduce((a, b) => a + b, 0);
+console.log(
+  JSON.stringify({
+    function: "applySeries_fn",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_categorical_index_modify.ts

@@ -0,0 +1,47 @@
+/**
+ * Benchmark: CategoricalIndex modification — renameCategories, reorderCategories, removeCategories,
+ * setCategories, removeUnusedCategories, asOrdered/asUnordered on a 10k-element index.
+ * Outputs JSON: {"function": "categorical_index_modify", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { CategoricalIndex } from "../../src/index.ts";
+
+const SIZE = 10_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const CATS = ["alpha", "beta", "gamma", "delta", "epsilon"];
+const labels = Array.from({ length: SIZE }, (_, i) => CATS[i % CATS.length]);
+const ci = CategoricalIndex.fromArray(labels);
+
+for (let i = 0; i < WARMUP; i++) {
+  ci.renameCategories(["A", "B", "C", "D", "E"]);
+  ci.reorderCategories(["epsilon", "delta", "gamma", "beta", "alpha"]);
+  ci.removeCategories(["epsilon"]);
+  ci.setCategories(["alpha", "beta", "gamma"]);
+  ci.removeUnusedCategories();
+  ci.asOrdered();
+  ci.asUnordered();
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  ci.renameCategories(["A", "B", "C", "D", "E"]);
+  ci.reorderCategories(["epsilon", "delta", "gamma", "beta", "alpha"]);
+  ci.removeCategories(["epsilon"]);
+  ci.setCategories(["alpha", "beta", "gamma"]);
+  ci.removeUnusedCategories();
+  ci.asOrdered();
+  ci.asUnordered();
+  times.push(performance.now() - t0);
+}
+
+const total = times.reduce((a, b) => a + b, 0);
+console.log(
+  JSON.stringify({
+    function: "categorical_index_modify",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_dataframe_apply_stats.ts

@@ -0,0 +1,43 @@
+/**
+ * Benchmark: dataFrameApply (stats/apply.ts) — apply fn to each column (axis=0) and each row (axis=1)
+ * on a 10k-row DataFrame. This is the standalone stats function, not df.apply().
+ * Outputs JSON: {"function": "dataframe_apply_stats", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, Series, dataFrameApply } from "../../src/index.ts";
+import type { Scalar } from "../../src/types.ts";
+
+const SIZE = 10_000;
+const WARMUP = 3;
+const ITERATIONS = 20;
+
+const df = DataFrame.fromColumns({
+  a: Array.from({ length: SIZE }, (_, i) => i * 1.0),
+  b: Array.from({ length: SIZE }, (_, i) => i * 2.0),
+  c: Array.from({ length: SIZE }, (_, i) => i * 3.0),
+});
+
+const sumFn = (slice: Series<Scalar>) =>
+  slice.values.reduce((acc, v) => acc + (v as number), 0) / slice.length;
+
+for (let i = 0; i < WARMUP; i++) {
+  dataFrameApply(df, sumFn, { axis: 0 });
+  dataFrameApply(df, sumFn, { axis: 1 });
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  dataFrameApply(df, sumFn, { axis: 0 });
+  dataFrameApply(df, sumFn, { axis: 1 });
+  times.push(performance.now() - t0);
+}
+
+const total = times.reduce((a, b) => a + b, 0);
+console.log(
+  JSON.stringify({
+    function: "dataframe_apply_stats",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_dataframe_from_columns.ts

@@ -0,0 +1,36 @@
+/**
+ * Benchmark: DataFrame.fromColumns() — construct a 100k-row DataFrame from column arrays.
+ * Tests the performance of the most common DataFrame construction path.
+ * Outputs JSON: {"function": "dataframe_from_columns", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+const colA = Array.from({ length: SIZE }, (_, i) => i * 1.0);
+const colB = Array.from({ length: SIZE }, (_, i) => i * 2.5);
+const colC = Array.from({ length: SIZE }, (_, i) => i % 1000);
+const colD = Array.from({ length: SIZE }, (_, i) => Math.sin(i * 0.001));
+
+for (let i = 0; i < WARMUP; i++) {
+  DataFrame.fromColumns({ a: colA, b: colB, c: colC, d: colD });
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  DataFrame.fromColumns({ a: colA, b: colB, c: colC, d: colD });
+  times.push(performance.now() - t0);
+}
+
+const total = times.reduce((a, b) => a + b, 0);
+console.log(
+  JSON.stringify({
+    function: "dataframe_from_columns",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_str_split_method.ts

@@ -0,0 +1,36 @@
+/**
+ * Benchmark: StringAccessor.split() — s.str.split(pat, n) on 100k strings.
+ * Distinct from strSplitExpand (which uses the standalone function).
+ * Outputs JSON: {"function": "str_split_method", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+const data = Array.from({ length: SIZE }, (_, i) => `part${i % 100}_b${i % 50}_c${i % 25}`);
+const s = new Series({ data });
+
+for (let i = 0; i < WARMUP; i++) {
+  s.str.split("_");
+  s.str.split("_", undefined, 2);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  s.str.split("_");
+  s.str.split("_", undefined, 2);
+  times.push(performance.now() - t0);
+}
+
+const total = times.reduce((a, b) => a + b, 0);
+console.log(
+  JSON.stringify({
+    function: "str_split_method",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);