Iteration 242: 5 new benchmark pairs (589 total, +55 vs canonical 534)

Added standalone function benchmarks for uncovered functions:
- dataframe_abs_fn: dataFrameAbs standalone (not .abs() method)
- dataframe_round_fn: dataFrameRound standalone (not .round() method)
- unstack_fn: unstack standalone function (not .unstack() method)
- series_numeric_pipeline: abs → round → clip chain
- dataframe_numeric_pipeline: abs → round → sign chain

Plus cherry-picked 50 pairs from origin/autoloop/perf-comparison-8724e9f9.
Total: 534 (canonical) + 55 new = 589 pairs.

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_dataframe_abs_fn.py

@@ -0,0 +1,41 @@
+"""
+Benchmark: dataFrameAbs standalone — absolute value on a 100k-row × 4-column DataFrame.
+Mirrors bench_dataframe_abs_fn.ts (uses df.abs() which is the pandas equivalent).
+Outputs JSON: {"function": "dataframe_abs_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 30
+
+df = pd.DataFrame(
+    {
+        "a": [(i % 200) - 100 for i in range(SIZE)],
+        "b": [np.sin(i * 0.01) * 100 for i in range(SIZE)],
+        "c": [-i * 0.5 for i in range(SIZE)],
+        "d": [(i % 50) - 25 for i in range(SIZE)],
+    }
+)
+
+for _ in range(WARMUP):
+    df.abs()
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    df.abs()
+total = (time.perf_counter() - start) * 1000
+
+print(
+    json.dumps(
+        {
+            "function": "dataframe_abs_fn",
+            "mean_ms": total / ITERATIONS,
+            "iterations": ITERATIONS,
+            "total_ms": total,
+        }
+    )
+)

benchmarks/pandas/bench_dataframe_numeric_pipeline.py

@@ -0,0 +1,45 @@
+"""
+Benchmark: DataFrame numeric pipeline — chain abs → round → sign on a 100k-row × 3-column DataFrame.
+Mirrors bench_dataframe_numeric_pipeline.ts.
+Outputs JSON: {"function": "dataframe_numeric_pipeline", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import math
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 20
+
+df = pd.DataFrame(
+    {
+        "a": [math.sin(i * 0.01) * 150 - 20 for i in range(SIZE)],
+        "b": [math.cos(i * 0.02) * 80 for i in range(SIZE)],
+        "c": [(i % 1000) * 0.123 - 50 for i in range(SIZE)],
+    }
+)
+
+for _ in range(WARMUP):
+    a = df.abs()
+    b = a.round(1)
+    np.sign(b)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    a = df.abs()
+    b = a.round(1)
+    np.sign(b)
+total = (time.perf_counter() - start) * 1000
+
+print(
+    json.dumps(
+        {
+            "function": "dataframe_numeric_pipeline",
+            "mean_ms": total / ITERATIONS,
+            "iterations": ITERATIONS,
+            "total_ms": total,
+        }
+    )
+)

benchmarks/pandas/bench_dataframe_round_fn.py

@@ -0,0 +1,41 @@
+"""
+Benchmark: dataFrameRound standalone — round a 100k-row × 4-column DataFrame to 2 decimals.
+Mirrors bench_dataframe_round_fn.ts (uses df.round(2) which is the pandas equivalent).
+Outputs JSON: {"function": "dataframe_round_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import math
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 30
+
+df = pd.DataFrame(
+    {
+        "a": [i * 0.123456 for i in range(SIZE)],
+        "b": [math.sin(i * 0.01) * 99.9 for i in range(SIZE)],
+        "c": [-i * 0.987654 for i in range(SIZE)],
+        "d": [(i % 1000) * 3.14159 for i in range(SIZE)],
+    }
+)
+
+for _ in range(WARMUP):
+    df.round(2)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    df.round(2)
+total = (time.perf_counter() - start) * 1000
+
+print(
+    json.dumps(
+        {
+            "function": "dataframe_round_fn",
+            "mean_ms": total / ITERATIONS,
+            "iterations": ITERATIONS,
+            "total_ms": total,
+        }
+    )
+)

benchmarks/pandas/bench_series_numeric_pipeline.py

@@ -0,0 +1,38 @@
+"""
+Benchmark: Series numeric pipeline — chain abs → round → clip on a 100k-element Series.
+Mirrors bench_series_numeric_pipeline.ts.
+Outputs JSON: {"function": "series_numeric_pipeline", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import math
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 30
+
+s = pd.Series([math.sin(i * 0.01) * 150 - 20 for i in range(SIZE)])
+
+for _ in range(WARMUP):
+    a = s.abs()
+    b = a.round(2)
+    b.clip(lower=0, upper=100)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    a = s.abs()
+    b = a.round(2)
+    b.clip(lower=0, upper=100)
+total = (time.perf_counter() - start) * 1000
+
+print(
+    json.dumps(
+        {
+            "function": "series_numeric_pipeline",
+            "mean_ms": total / ITERATIONS,
+            "iterations": ITERATIONS,
+            "total_ms": total,
+        }
+    )
+)

benchmarks/pandas/bench_unstack_fn.py

@@ -0,0 +1,42 @@
+"""
+Benchmark: unstack standalone — pivot innermost MultiIndex level to columns using s.unstack().
+Mirrors bench_unstack_fn.ts.
+Outputs JSON: {"function": "unstack_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+ROWS = 500
+COLS = 10
+WARMUP = 5
+ITERATIONS = 50
+
+data = [i * 1.0 for i in range(ROWS * COLS)]
+index = pd.MultiIndex.from_tuples(
+    [(i // COLS, i % COLS) for i in range(ROWS * COLS)]
+)
+s = pd.Series(data, index=index)
+
+for _ in range(WARMUP):
+    s.unstack()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.unstack()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / len(times)
+
+print(
+    json.dumps(
+        {
+            "function": "unstack_fn",
+            "mean_ms": mean_ms,
+            "iterations": ITERATIONS,
+            "total_ms": total_ms,
+        }
+    )
+)

benchmarks/tsb/bench_dataframe_abs_fn.ts

@@ -0,0 +1,36 @@
+/**
+ * Benchmark: dataFrameAbs standalone — absolute value on a 100k-row × 4-column DataFrame.
+ * Uses the exported dataFrameAbs function (not the .abs() method).
+ * Outputs JSON: {"function": "dataframe_abs_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, dataFrameAbs } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+const df = DataFrame.fromColumns({
+  a: Array.from({ length: SIZE }, (_, i) => (i % 200) - 100),
+  b: Array.from({ length: SIZE }, (_, i) => Math.sin(i * 0.01) * 100),
+  c: Array.from({ length: SIZE }, (_, i) => -i * 0.5),
+  d: Array.from({ length: SIZE }, (_, i) => (i % 50) - 25),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  dataFrameAbs(df);
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  dataFrameAbs(df);
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "dataframe_abs_fn",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_dataframe_numeric_pipeline.ts

@@ -0,0 +1,39 @@
+/**
+ * Benchmark: DataFrame numeric pipeline — chain abs → round → sign on a 100k-row × 3-column DataFrame.
+ * Tests a realistic sequence of standalone DataFrame numeric operations.
+ * Outputs JSON: {"function": "dataframe_numeric_pipeline", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, dataFrameAbs, dataFrameRound, dataFrameSign } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 20;
+
+const df = DataFrame.fromColumns({
+  a: Array.from({ length: SIZE }, (_, i) => Math.sin(i * 0.01) * 150 - 20),
+  b: Array.from({ length: SIZE }, (_, i) => Math.cos(i * 0.02) * 80),
+  c: Array.from({ length: SIZE }, (_, i) => (i % 1000) * 0.123 - 50),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  const a = dataFrameAbs(df);
+  const b = dataFrameRound(a, { decimals: 1 });
+  dataFrameSign(b);
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  const a = dataFrameAbs(df);
+  const b = dataFrameRound(a, { decimals: 1 });
+  dataFrameSign(b);
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "dataframe_numeric_pipeline",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_dataframe_round_fn.ts

@@ -0,0 +1,36 @@
+/**
+ * Benchmark: dataFrameRound standalone — round a 100k-row × 4-column DataFrame to 2 decimals.
+ * Uses the exported dataFrameRound function (not the .round() method).
+ * Outputs JSON: {"function": "dataframe_round_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, dataFrameRound } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+const df = DataFrame.fromColumns({
+  a: Array.from({ length: SIZE }, (_, i) => i * 0.123456),
+  b: Array.from({ length: SIZE }, (_, i) => Math.sin(i * 0.01) * 99.9),
+  c: Array.from({ length: SIZE }, (_, i) => -i * 0.987654),
+  d: Array.from({ length: SIZE }, (_, i) => (i % 1000) * 3.14159),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  dataFrameRound(df, { decimals: 2 });
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  dataFrameRound(df, { decimals: 2 });
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "dataframe_round_fn",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_series_numeric_pipeline.ts

@@ -0,0 +1,37 @@
+/**
+ * Benchmark: Series numeric pipeline — chain abs → round → clip on a 100k-element Series.
+ * Tests a realistic sequence of standalone numeric operations.
+ * Outputs JSON: {"function": "series_numeric_pipeline", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, seriesAbs, seriesRound, clipSeriesWithBounds } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+const s = new Series({
+  data: Array.from({ length: SIZE }, (_, i) => Math.sin(i * 0.01) * 150 - 20),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  const a = seriesAbs(s);
+  const b = seriesRound(a, { decimals: 2 });
+  clipSeriesWithBounds(b, { lower: 0, upper: 100 });
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  const a = seriesAbs(s);
+  const b = seriesRound(a, { decimals: 2 });
+  clipSeriesWithBounds(b, { lower: 0, upper: 100 });
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "series_numeric_pipeline",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);