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

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_clip_dataframe_with_bounds.py

@@ -0,0 +1,39 @@
+"""
+Benchmark: pandas DataFrame.clip with Series bounds (axis=0) on 100k-row DataFrame.
+Outputs JSON: {"function": "clip_dataframe_with_bounds", "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": [(i % 150) - 75 for i in range(SIZE)],
+    "c": [(i % 100) - 50 for i in range(SIZE)],
+})
+
+lower_bounds = pd.Series([(i % 40) - 20 for i in range(SIZE)])
+upper_bounds = pd.Series([(i % 40) + 20 for i in range(SIZE)])
+
+for _ in range(WARMUP):
+    df.clip(lower=lower_bounds, upper=upper_bounds, axis=0)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.clip(lower=lower_bounds, upper=upper_bounds, axis=0)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({
+    "function": "clip_dataframe_with_bounds",
+    "mean_ms": mean_ms,
+    "iterations": ITERATIONS,
+    "total_ms": total_ms,
+}))

benchmarks/pandas/bench_clip_series_with_bounds.py

@@ -0,0 +1,35 @@
+"""
+Benchmark: pandas Series.clip with per-element Series bounds on 100k values.
+Outputs JSON: {"function": "clip_series_with_bounds", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 30
+
+data = [(i % 200) - 100 for i in range(SIZE)]
+lower = pd.Series([(i % 50) - 30 for i in range(SIZE)])
+upper = pd.Series([(i % 50) + 20 for i in range(SIZE)])
+series = pd.Series(data)
+
+for _ in range(WARMUP):
+    series.clip(lower=lower, upper=upper)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    series.clip(lower=lower, upper=upper)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({
+    "function": "clip_series_with_bounds",
+    "mean_ms": mean_ms,
+    "iterations": ITERATIONS,
+    "total_ms": total_ms,
+}))

benchmarks/pandas/bench_dataframe_pipe_to.py

@@ -0,0 +1,42 @@
+"""
+Benchmark: pandas DataFrame.pipe with positional target argument on 100k-row DataFrame.
+Mirrors tsb's dataFramePipeTo — inserting the DataFrame at a specific arg position.
+Outputs JSON: {"function": "dataframe_pipe_to", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+
+def filter_above(threshold: float, df: pd.DataFrame) -> pd.DataFrame:
+    return df[df["val"] > threshold]
+
+
+left = pd.DataFrame({
+    "key": [i % 1000 for i in range(SIZE)],
+    "val": [i * 1.5 for i in range(SIZE)],
+})
+
+for _ in range(WARMUP):
+    # pandas pipe with tuple form: (fn, 'positional_kwarg') — use pipe with lambda here
+    left.pipe(lambda df: filter_above(50_000, df))
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    left.pipe(lambda df: filter_above(50_000, df))
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({
+    "function": "dataframe_pipe_to",
+    "mean_ms": mean_ms,
+    "iterations": ITERATIONS,
+    "total_ms": total_ms,
+}))

benchmarks/pandas/bench_qcut_interval_index.py

@@ -0,0 +1,32 @@
+"""
+Benchmark: pandas qcut with IntervalIndex output on 100k values.
+Outputs JSON: {"function": "qcut_interval_index", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 30
+
+data = (np.arange(SIZE) * 1.1) % 1000
+
+for _ in range(WARMUP):
+    pd.qcut(data, q=10, duplicates="drop", retbins=True)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    pd.qcut(data, q=10, duplicates="drop", retbins=True)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({
+    "function": "qcut_interval_index",
+    "mean_ms": mean_ms,
+    "iterations": ITERATIONS,
+    "total_ms": total_ms,
+}))

benchmarks/pandas/bench_series_log2_log10.py

@@ -0,0 +1,44 @@
+"""
+Benchmark: pandas Series/DataFrame log2 / log10 on 100k values.
+Outputs JSON: {"function": "series_log2_log10", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 30
+
+data = (np.arange(1, SIZE + 1) * 0.01)
+s = pd.Series(data)
+df = pd.DataFrame({
+    "a": data,
+    "b": np.arange(1, SIZE + 1) * 0.02,
+    "c": np.arange(1, SIZE + 1) * 0.03,
+})
+
+for _ in range(WARMUP):
+    np.log2(s)
+    np.log10(s)
+    np.log2(df)
+    np.log10(df)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    np.log2(s)
+    np.log10(s)
+    np.log2(df)
+    np.log10(df)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({
+    "function": "series_log2_log10",
+    "mean_ms": mean_ms,
+    "iterations": ITERATIONS,
+    "total_ms": total_ms,
+}))

benchmarks/tsb/bench_clip_dataframe_with_bounds.ts

@@ -0,0 +1,40 @@
+/**
+ * Benchmark: clipDataFrameWithBounds with Series bounds (axis=0) on 100k-row DataFrame.
+ * Outputs JSON: {"function": "clip_dataframe_with_bounds", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, DataFrame, clipDataFrameWithBounds } 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) => (i % 150) - 75),
+  c: Array.from({ length: SIZE }, (_, i) => (i % 100) - 50),
+});
+
+const lowerBounds = new Series({ data: Array.from({ length: SIZE }, (_, i) => (i % 40) - 20) });
+const upperBounds = new Series({ data: Array.from({ length: SIZE }, (_, i) => (i % 40) + 20) });
+
+for (let i = 0; i < WARMUP; i++) {
+  clipDataFrameWithBounds(df, { lower: lowerBounds, upper: upperBounds, axis: 0 });
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  clipDataFrameWithBounds(df, { lower: lowerBounds, upper: upperBounds, axis: 0 });
+  times.push(performance.now() - t0);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "clip_dataframe_with_bounds",
+    mean_ms: meanMs,
+    iterations: ITERATIONS,
+    total_ms: totalMs,
+  }),
+);

benchmarks/tsb/bench_clip_series_with_bounds.ts

@@ -0,0 +1,39 @@
+/**
+ * Benchmark: clipSeriesWithBounds with per-element Series bounds on 100k values.
+ * Outputs JSON: {"function": "clip_series_with_bounds", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, clipSeriesWithBounds } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+const data = Array.from({ length: SIZE }, (_, i) => (i % 200) - 100);
+const lower = Array.from({ length: SIZE }, (_, i) => (i % 50) - 30);
+const upper = Array.from({ length: SIZE }, (_, i) => (i % 50) + 20);
+
+const series = new Series({ data });
+const lowerSeries = new Series({ data: lower });
+const upperSeries = new Series({ data: upper });
+
+for (let i = 0; i < WARMUP; i++) {
+  clipSeriesWithBounds(series, { lower: lowerSeries, upper: upperSeries });
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  clipSeriesWithBounds(series, { lower: lowerSeries, upper: upperSeries });
+  times.push(performance.now() - t0);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "clip_series_with_bounds",
+    mean_ms: meanMs,
+    iterations: ITERATIONS,
+    total_ms: totalMs,
+  }),
+);

benchmarks/tsb/bench_dataframe_pipe_to.ts

@@ -0,0 +1,47 @@
+/**
+ * Benchmark: dataFramePipeTo — insert DataFrame at a specific argument position in a pipeline.
+ * Outputs JSON: {"function": "dataframe_pipe_to", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, dataFramePipeTo } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const left = DataFrame.fromColumns({
+  key: Array.from({ length: SIZE }, (_, i) => i % 1000),
+  val: Array.from({ length: SIZE }, (_, i) => i * 1.5),
+});
+
+const right = DataFrame.fromColumns({
+  key: Array.from({ length: 1000 }, (_, i) => i),
+  label: Array.from({ length: 1000 }, (_, i) => `item_${i}`),
+});
+
+// A simple transform: filter df rows where col > threshold
+function filterAbove(threshold: number, df: DataFrame): DataFrame {
+  return df.filter((row) => (row["val"] as number) > threshold);
+}
+
+for (let i = 0; i < WARMUP; i++) {
+  // dataFramePipeTo inserts `left` at position 1: filterAbove(threshold, left)
+  dataFramePipeTo(left, 1, filterAbove, 50_000);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  dataFramePipeTo(left, 1, filterAbove, 50_000);
+  times.push(performance.now() - t0);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "dataframe_pipe_to",
+    mean_ms: meanMs,
+    iterations: ITERATIONS,
+    total_ms: totalMs,
+  }),
+);

benchmarks/tsb/bench_qcut_interval_index.ts

@@ -0,0 +1,34 @@
+/**
+ * Benchmark: qcutIntervalIndex — compute quantile-based IntervalIndex from 100k values.
+ * Outputs JSON: {"function": "qcut_interval_index", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { qcutIntervalIndex } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+const data = Array.from({ length: SIZE }, (_, i) => (i * 1.1) % 1000);
+
+// Quantile-based binning into 10 equal-frequency bins
+for (let i = 0; i < WARMUP; i++) {
+  qcutIntervalIndex(data, 10);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  qcutIntervalIndex(data, 10);
+  times.push(performance.now() - t0);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "qcut_interval_index",
+    mean_ms: meanMs,
+    iterations: ITERATIONS,
+    total_ms: totalMs,
+  }),
+);