Iteration 159: 5 new benchmark pairs (513 total, +5 vs best 508)

Added benchmarks for:
- series_sign: seriesSign element-wise sign function (numpy.sign equivalent)
- groupby_groups_props: DataFrameGroupBy .groups/.groupKeys/.ngroups properties
- merge_sort: merge with sort=true option (pd.merge sort=True equivalent)
- series_groupby_groups: SeriesGroupBy .groups/.groupKeys/.ngroups properties
- pipe_fn: pipe functional composition operator (Series.pipe equivalent)

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_groupby_groups_props.py

@@ -0,0 +1,36 @@
+"""Benchmark: DataFrameGroupBy .groups / .ngroups properties on 100k-row DataFrame."""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+depts = ["eng", "hr", "sales", "finance", "ops", "legal", "mkt", "it", "rd", "ops2"]
+df = pd.DataFrame({
+    "dept": [depts[i % len(depts)] for i in range(SIZE)],
+    "salary": [50_000 + (i % 100) * 1000 for i in range(SIZE)],
+    "score": [(i % 100) * 0.01 for i in range(SIZE)],
+})
+
+gb = df.groupby("dept")
+
+for _ in range(WARMUP):
+    _g = gb.groups
+    _k = list(gb.groups.keys())
+    _n = gb.ngroups
+
+times = []
+for _ in range(ITERATIONS):
+    start = time.perf_counter()
+    _g = gb.groups
+    _k = list(gb.groups.keys())
+    _n = gb.ngroups
+    times.append((time.perf_counter() - start) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+
+print(json.dumps({"function": "groupby_groups_props", "mean_ms": mean_ms, "iterations": ITERATIONS, "total_ms": total_ms}))

benchmarks/pandas/bench_merge_sort.py

@@ -0,0 +1,33 @@
+"""Benchmark: merge with sort=True — sort result by join-key on 50k-row DataFrames."""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+ROWS = 50_000
+WARMUP = 3
+ITERATIONS = 20
+
+left = pd.DataFrame({
+    "id": np.arange(ROWS) % (ROWS // 2),
+    "val_l": np.arange(ROWS) * 1.5,
+})
+
+right = pd.DataFrame({
+    "id": np.arange(ROWS // 2),
+    "val_r": np.arange(ROWS // 2) * 2.0,
+})
+
+for _ in range(WARMUP):
+    pd.merge(left, right, on="id", how="inner", sort=True)
+
+times = []
+for _ in range(ITERATIONS):
+    start = time.perf_counter()
+    pd.merge(left, right, on="id", how="inner", sort=True)
+    times.append((time.perf_counter() - start) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+
+print(json.dumps({"function": "merge_sort", "mean_ms": mean_ms, "iterations": ITERATIONS, "total_ms": total_ms}))

benchmarks/pandas/bench_pipe_fn.py

@@ -0,0 +1,38 @@
+"""Benchmark: pipe — functional pipeline composition via pandas Series.pipe on 100k-element Series."""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+s = pd.Series((np.arange(SIZE) % 200) - 100.0)
+df = pd.DataFrame({
+    "a": (np.arange(SIZE) % 100) - 50.0,
+    "b": np.sin(np.arange(SIZE) * 0.01) * 100,
+})
+
+def double(x: pd.Series) -> pd.Series:
+    return x * 2
+
+def add_hundred(x: pd.Series) -> pd.Series:
+    return x + 100
+
+def abs_series(x: pd.Series) -> pd.Series:
+    return x.abs()
+
+for _ in range(WARMUP):
+    s.pipe(abs_series).pipe(double).pipe(add_hundred)
+
+times = []
+for _ in range(ITERATIONS):
+    start = time.perf_counter()
+    s.pipe(abs_series).pipe(double).pipe(add_hundred)
+    times.append((time.perf_counter() - start) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+
+print(json.dumps({"function": "pipe_fn", "mean_ms": mean_ms, "iterations": ITERATIONS, "total_ms": total_ms}))

benchmarks/pandas/bench_series_groupby_groups.py

@@ -0,0 +1,34 @@
+"""Benchmark: SeriesGroupBy .groups / .ngroups properties on 100k-element Series."""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+categories = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
+data = np.arange(SIZE) * 0.1
+by = [categories[i % len(categories)] for i in range(SIZE)]
+
+s = pd.Series(data)
+gb = s.groupby(by)
+
+for _ in range(WARMUP):
+    _g = gb.groups
+    _k = list(gb.groups.keys())
+    _n = gb.ngroups
+
+times = []
+for _ in range(ITERATIONS):
+    start = time.perf_counter()
+    _g = gb.groups
+    _k = list(gb.groups.keys())
+    _n = gb.ngroups
+    times.append((time.perf_counter() - start) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+
+print(json.dumps({"function": "series_groupby_groups", "mean_ms": mean_ms, "iterations": ITERATIONS, "total_ms": total_ms}))

benchmarks/pandas/bench_series_sign.py

@@ -0,0 +1,26 @@
+"""Benchmark: seriesSign — element-wise sign via numpy.sign on 100k-element Series."""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+data = np.sin(np.arange(SIZE) * 0.01) * 1000
+s = pd.Series(data)
+
+for _ in range(WARMUP):
+    np.sign(s)
+
+times = []
+for _ in range(ITERATIONS):
+    start = time.perf_counter()
+    np.sign(s)
+    times.append((time.perf_counter() - start) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+
+print(json.dumps({"function": "series_sign", "mean_ms": mean_ms, "iterations": ITERATIONS, "total_ms": total_ms}))

benchmarks/tsb/bench_groupby_groups_props.ts

@@ -0,0 +1,45 @@
+/**
+ * Benchmark: DataFrameGroupBy .groups / .groupKeys / .ngroups properties on 100k rows.
+ * Outputs JSON: {"function": "groupby_groups_props", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, DataFrameGroupBy } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const depts = ["eng", "hr", "sales", "finance", "ops", "legal", "mkt", "it", "rd", "ops2"];
+const df = DataFrame.fromColumns({
+  dept: Array.from({ length: SIZE }, (_, i) => depts[i % depts.length]),
+  salary: Array.from({ length: SIZE }, (_, i) => 50_000 + (i % 100) * 1000),
+  score: Array.from({ length: SIZE }, (_, i) => (i % 100) * 0.01),
+});
+
+const gb = new DataFrameGroupBy(df, ["dept"]);
+
+for (let i = 0; i < WARMUP; i++) {
+  const _g = gb.groups;
+  const _k = gb.groupKeys;
+  const _n = gb.ngroups;
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  const _g = gb.groups;
+  const _k = gb.groupKeys;
+  const _n = gb.ngroups;
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+
+console.log(
+  JSON.stringify({
+    function: "groupby_groups_props",
+    mean_ms: meanMs,
+    iterations: ITERATIONS,
+    total_ms: totalMs,
+  }),
+);

benchmarks/tsb/bench_merge_sort.ts

@@ -0,0 +1,42 @@
+/**
+ * Benchmark: merge with sort=true — sort result by join-key values on 50k-row DataFrames.
+ * Outputs JSON: {"function": "merge_sort", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, merge } from "../../src/index.ts";
+
+const ROWS = 50_000;
+const WARMUP = 3;
+const ITERATIONS = 20;
+
+const left = DataFrame.fromColumns({
+  id: Array.from({ length: ROWS }, (_, i) => i % (ROWS / 2)),
+  val_l: Array.from({ length: ROWS }, (_, i) => i * 1.5),
+});
+
+const right = DataFrame.fromColumns({
+  id: Array.from({ length: ROWS / 2 }, (_, i) => i),
+  val_r: Array.from({ length: ROWS / 2 }, (_, i) => i * 2.0),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  merge(left, right, { on: "id", how: "inner", sort: true });
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  merge(left, right, { on: "id", how: "inner", sort: true });
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+
+console.log(
+  JSON.stringify({
+    function: "merge_sort",
+    mean_ms: meanMs,
+    iterations: ITERATIONS,
+    total_ms: totalMs,
+  }),
+);

benchmarks/tsb/bench_pipe_fn.ts

@@ -0,0 +1,45 @@
+/**
+ * Benchmark: pipe — functional pipeline composition operator on 100k-element Series and DataFrame.
+ * Outputs JSON: {"function": "pipe_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, DataFrame, pipe, seriesAbs, seriesMul, seriesAdd } from "../../src/index.ts";
+import type { Scalar } from "../../src/types.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const s = new Series({ data: Array.from({ length: SIZE }, (_, i) => (i % 200) - 100.0) });
+const df = DataFrame.fromColumns({
+  a: Array.from({ length: SIZE }, (_, i) => (i % 100) - 50.0),
+  b: Array.from({ length: SIZE }, (_, i) => Math.sin(i * 0.01) * 100),
+});
+
+const double = (x: Series<Scalar>) => seriesMul(x, 2);
+const addHundred = (x: Series<Scalar>) => seriesAdd(x, 100);
+const abs = (x: Series<Scalar>) => seriesAbs(x);
+
+for (let i = 0; i < WARMUP; i++) {
+  pipe(s, abs, double, addHundred);
+  pipe(42, (x: number) => x * 2, (x: number) => x + 1);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  pipe(s, abs, double, addHundred);
+  pipe(42, (x: number) => x * 2, (x: number) => x + 1);
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+
+console.log(
+  JSON.stringify({
+    function: "pipe_fn",
+    mean_ms: meanMs,
+    iterations: ITERATIONS,
+    total_ms: totalMs,
+  }),
+);

benchmarks/tsb/bench_series_groupby_groups.ts

@@ -0,0 +1,43 @@
+/**
+ * Benchmark: SeriesGroupBy .groups / .groupKeys / .ngroups properties on 100k-element Series.
+ * Outputs JSON: {"function": "series_groupby_groups", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, SeriesGroupBy } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const categories = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"];
+const data = Array.from({ length: SIZE }, (_, i) => i * 0.1);
+const by = Array.from({ length: SIZE }, (_, i) => categories[i % categories.length]);
+
+const s = new Series({ data });
+const gb = new SeriesGroupBy(s, by);
+
+for (let i = 0; i < WARMUP; i++) {
+  const _g = gb.groups;
+  const _k = gb.groupKeys;
+  const _n = gb.ngroups;
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  const _g = gb.groups;
+  const _k = gb.groupKeys;
+  const _n = gb.ngroups;
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+
+console.log(
+  JSON.stringify({
+    function: "series_groupby_groups",
+    mean_ms: meanMs,
+    iterations: ITERATIONS,
+    total_ms: totalMs,
+  }),
+);

benchmarks/tsb/bench_series_sign.ts

@@ -0,0 +1,35 @@
+/**
+ * Benchmark: seriesSign — element-wise sign on 100k-element Series.
+ * Outputs JSON: {"function": "series_sign", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, seriesSign } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const data = Array.from({ length: SIZE }, (_, i) => Math.sin(i * 0.01) * 1000);
+const s = new Series({ data });
+
+for (let i = 0; i < WARMUP; i++) {
+  seriesSign(s);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  seriesSign(s);
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+
+console.log(
+  JSON.stringify({
+    function: "series_sign",
+    mean_ms: meanMs,
+    iterations: ITERATIONS,
+    total_ms: totalMs,
+  }),
+);