Iteration 158: 5 new benchmark pairs (508 total, +5 vs best 503)

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

Author: github-actions[bot]

benchmarks/pandas/bench_dataframe_median.py

@@ -0,0 +1,36 @@
+"""
+Benchmark: pandas DataFrame.median() — column-wise median on a 100k-row DataFrame.
+Outputs JSON: {"function": "dataframe_median", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+import numpy as np
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 30
+
+df = pd.DataFrame({
+    "a": (np.arange(SIZE) * 1.23) % 9000,
+    "b": (np.arange(SIZE) * 4.56) % 7000,
+    "c": (np.arange(SIZE) * 7.89) % 5000,
+})
+
+for _ in range(WARMUP):
+    df.median()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.median()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({
+    "function": "dataframe_median",
+    "mean_ms": mean_ms,
+    "iterations": ITERATIONS,
+    "total_ms": total_ms,
+}))

benchmarks/pandas/bench_dataframe_rolling_min_max.py

@@ -0,0 +1,39 @@
+"""
+Benchmark: pandas DataFrame.rolling().min() / .max() — rolling min/max aggregations.
+Outputs JSON: {"function": "dataframe_rolling_min_max", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+import numpy as np
+
+SIZE = 50_000
+WINDOW = 20
+WARMUP = 5
+ITERATIONS = 30
+
+df = pd.DataFrame({
+    "a": np.sin(np.arange(SIZE) * 0.01) * 100,
+    "b": np.cos(np.arange(SIZE) * 0.01) * 50,
+    "c": (np.arange(SIZE) % 100) * 1.5,
+})
+
+for _ in range(WARMUP):
+    df.rolling(WINDOW).min()
+    df.rolling(WINDOW).max()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.rolling(WINDOW).min()
+    df.rolling(WINDOW).max()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({
+    "function": "dataframe_rolling_min_max",
+    "mean_ms": mean_ms,
+    "iterations": ITERATIONS,
+    "total_ms": total_ms,
+}))

benchmarks/pandas/bench_interval_index_construction.py

@@ -0,0 +1,41 @@
+"""
+Benchmark: pandas IntervalIndex.from_arrays() and IntervalIndex.from_tuples() — alternative constructors.
+Outputs JSON: {"function": "interval_index_construction", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+import numpy as np
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 50
+
+# Prepare data
+left_arr = np.arange(SIZE) * 0.1
+right_arr = left_arr + 0.1
+
+# Prepare tuples for from_tuples
+tuples = [(left_arr[i], right_arr[i]) for i in range(SIZE)]
+
+for _ in range(WARMUP):
+    pd.IntervalIndex.from_arrays(left_arr, right_arr)
+    pd.IntervalIndex.from_arrays(left_arr, right_arr, closed="left")
+    pd.IntervalIndex.from_tuples(tuples)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    pd.IntervalIndex.from_arrays(left_arr, right_arr)
+    pd.IntervalIndex.from_arrays(left_arr, right_arr, closed="left")
+    pd.IntervalIndex.from_tuples(tuples)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({
+    "function": "interval_index_construction",
+    "mean_ms": mean_ms,
+    "iterations": ITERATIONS,
+    "total_ms": total_ms,
+}))

benchmarks/pandas/bench_read_csv_options.py

@@ -0,0 +1,48 @@
+"""
+Benchmark: pandas read_csv with options — sep, header, skiprows, dtype casting.
+Outputs JSON: {"function": "read_csv_options", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import io
+import time
+import pandas as pd
+import numpy as np
+
+ROWS = 10_000
+WARMUP = 3
+ITERATIONS = 20
+
+# Build pipe-separated CSV (no header)
+pipe_lines = [f"{i}|{i * 1.1:.4f}|cat_{i % 50}" for i in range(ROWS)]
+pipe_csv = "\n".join(pipe_lines)
+
+# Build comma-separated CSV (skip first 2 rows)
+skip_lines = ["# comment row 1", "# comment row 2", "id,value,label"] + \
+    [f"{i},{i * 2.2:.4f},grp_{i % 20}" for i in range(ROWS)]
+skip_csv = "\n".join(skip_lines)
+
+# Build CSV for dtype override
+dtype_lines = ["id,value,flag"] + [f"{i},{i * 1.5},{i % 2}" for i in range(ROWS)]
+dtype_csv = "\n".join(dtype_lines)
+
+for _ in range(WARMUP):
+    pd.read_csv(io.StringIO(pipe_csv), sep="|", header=None)
+    pd.read_csv(io.StringIO(skip_csv), skiprows=2)
+    pd.read_csv(io.StringIO(dtype_csv), dtype={"id": "int32", "value": "float32"})
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    pd.read_csv(io.StringIO(pipe_csv), sep="|", header=None)
+    pd.read_csv(io.StringIO(skip_csv), skiprows=2)
+    pd.read_csv(io.StringIO(dtype_csv), dtype={"id": "int32", "value": "float32"})
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({
+    "function": "read_csv_options",
+    "mean_ms": mean_ms,
+    "iterations": ITERATIONS,
+    "total_ms": total_ms,
+}))

benchmarks/pandas/bench_to_csv_options.py

@@ -0,0 +1,42 @@
+"""
+Benchmark: pandas DataFrame.to_csv() with options — sep, header, index settings.
+Outputs JSON: {"function": "to_csv_options", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+import numpy as np
+
+ROWS = 10_000
+WARMUP = 3
+ITERATIONS = 20
+
+df = pd.DataFrame({
+    "id": np.arange(ROWS),
+    "value": np.arange(ROWS) * 1.1,
+    "label": [f"cat_{i % 50}" for i in range(ROWS)],
+})
+
+for _ in range(WARMUP):
+    df.to_csv(sep="\t")
+    df.to_csv(header=False)
+    df.to_csv(index=False)
+    df.to_csv(sep="|", header=False, index=False)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.to_csv(sep="\t")
+    df.to_csv(header=False)
+    df.to_csv(index=False)
+    df.to_csv(sep="|", header=False, index=False)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({
+    "function": "to_csv_options",
+    "mean_ms": mean_ms,
+    "iterations": ITERATIONS,
+    "total_ms": total_ms,
+}))

benchmarks/tsb/bench_dataframe_median.ts

@@ -0,0 +1,37 @@
+/**
+ * Benchmark: DataFrame.median() — column-wise median on a 100k-row DataFrame.
+ * Outputs JSON: {"function": "dataframe_median", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame } 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 * 1.23) % 9000),
+  b: Array.from({ length: SIZE }, (_, i) => (i * 4.56) % 7000),
+  c: Array.from({ length: SIZE }, (_, i) => (i * 7.89) % 5000),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  df.median();
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  df.median();
+  times.push(performance.now() - t0);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "dataframe_median",
+    mean_ms: meanMs,
+    iterations: ITERATIONS,
+    total_ms: totalMs,
+  }),
+);

benchmarks/tsb/bench_dataframe_rolling_min_max.ts

@@ -0,0 +1,40 @@
+/**
+ * Benchmark: DataFrameRolling.min() and DataFrameRolling.max() on a 50k-row DataFrame.
+ * Outputs JSON: {"function": "dataframe_rolling_min_max", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame } from "../../src/index.ts";
+
+const SIZE = 50_000;
+const WINDOW = 20;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+const df = DataFrame.fromColumns({
+  a: Array.from({ length: SIZE }, (_, i) => Math.sin(i * 0.01) * 100),
+  b: Array.from({ length: SIZE }, (_, i) => Math.cos(i * 0.01) * 50),
+  c: Array.from({ length: SIZE }, (_, i) => (i % 100) * 1.5),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  df.rolling(WINDOW).min();
+  df.rolling(WINDOW).max();
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  df.rolling(WINDOW).min();
+  df.rolling(WINDOW).max();
+  times.push(performance.now() - t0);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "dataframe_rolling_min_max",
+    mean_ms: meanMs,
+    iterations: ITERATIONS,
+    total_ms: totalMs,
+  }),
+);

benchmarks/tsb/bench_interval_index_construction.ts

@@ -0,0 +1,42 @@
+/**
+ * Benchmark: IntervalIndex.fromArrays() and IntervalIndex.fromIntervals() — alternative constructors.
+ * Outputs JSON: {"function": "interval_index_construction", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Interval, IntervalIndex } from "../../src/index.ts";
+
+const SIZE = 10_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+// Prepare data for fromArrays
+const leftArr = Array.from({ length: SIZE }, (_, i) => i * 0.1);
+const rightArr = Array.from({ length: SIZE }, (_, i) => i * 0.1 + 0.1);
+
+// Prepare interval objects for fromIntervals
+const intervals = Array.from({ length: SIZE }, (_, i) => new Interval(i * 0.1, i * 0.1 + 0.1));
+
+for (let i = 0; i < WARMUP; i++) {
+  IntervalIndex.fromArrays(leftArr, rightArr);
+  IntervalIndex.fromArrays(leftArr, rightArr, "left");
+  IntervalIndex.fromIntervals(intervals);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  IntervalIndex.fromArrays(leftArr, rightArr);
+  IntervalIndex.fromArrays(leftArr, rightArr, "left");
+  IntervalIndex.fromIntervals(intervals);
+  times.push(performance.now() - t0);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "interval_index_construction",
+    mean_ms: meanMs,
+    iterations: ITERATIONS,
+    total_ms: totalMs,
+  }),
+);

benchmarks/tsb/bench_read_csv_options.ts

@@ -0,0 +1,56 @@
+/**
+ * Benchmark: readCsv with options — sep, header, skipRows, dtype casting.
+ * Outputs JSON: {"function": "read_csv_options", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { readCsv } from "../../src/index.ts";
+
+const ROWS = 10_000;
+const WARMUP = 3;
+const ITERATIONS = 20;
+
+// Build pipe-separated CSV (no header)
+const pipeLines: string[] = [];
+for (let i = 0; i < ROWS; i++) {
+  pipeLines.push(`${i}|${(i * 1.1).toFixed(4)}|cat_${i % 50}`);
+}
+const pipeCsv = pipeLines.join("\n");
+
+// Build comma-separated CSV (skip first 2 rows)
+const skipLines: string[] = ["# comment row 1", "# comment row 2", "id,value,label"];
+for (let i = 0; i < ROWS; i++) {
+  skipLines.push(`${i},${(i * 2.2).toFixed(4)},grp_${i % 20}`);
+}
+const skipCsv = skipLines.join("\n");
+
+// Build CSV for dtype override
+const dtypeLines: string[] = ["id,value,flag"];
+for (let i = 0; i < ROWS; i++) {
+  dtypeLines.push(`${i},${i * 1.5},${i % 2}`);
+}
+const dtypeCsv = dtypeLines.join("\n");
+
+for (let i = 0; i < WARMUP; i++) {
+  readCsv(pipeCsv, { sep: "|", header: null });
+  readCsv(skipCsv, { skipRows: 2 });
+  readCsv(dtypeCsv, { dtype: { id: "int32", value: "float32" } });
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  readCsv(pipeCsv, { sep: "|", header: null });
+  readCsv(skipCsv, { skipRows: 2 });
+  readCsv(dtypeCsv, { dtype: { id: "int32", value: "float32" } });
+  times.push(performance.now() - t0);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "read_csv_options",
+    mean_ms: meanMs,
+    iterations: ITERATIONS,
+    total_ms: totalMs,
+  }),
+);