Iteration 154: Add 5 benchmark pairs (488 total, +5 vs best 483)

Added 5 new pairs:
- datetime_index_normalize_filter_shift (DatetimeIndex.normalize/filter/shift)
- index_map (Index.map transform function)
- multi_index_fromtuples (MultiIndex.fromTuples construction)
- timedelta_advanced_ops (Timedelta.parse/toISOString/divBy/negate/mul/compareTo)
- dataframe_rolling_var_std_sum_count (DataFrameRolling.var/std/sum/count)

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_dataframe_rolling_var_std_sum_count.py

@@ -0,0 +1,43 @@
+"""
+Benchmark: pandas DataFrame.rolling().var() / std() / sum() / count() — rolling aggregations.
+Outputs JSON: {"function": "dataframe_rolling_var_std_sum_count", "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).var()
+    df.rolling(WINDOW).std()
+    df.rolling(WINDOW).sum()
+    df.rolling(WINDOW).count()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.rolling(WINDOW).var()
+    df.rolling(WINDOW).std()
+    df.rolling(WINDOW).sum()
+    df.rolling(WINDOW).count()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({
+    "function": "dataframe_rolling_var_std_sum_count",
+    "mean_ms": round(mean_ms, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total_ms, 3),
+}))

benchmarks/pandas/bench_datetime_index_normalize_filter_shift.py

@@ -0,0 +1,36 @@
+"""
+Benchmark: pandas DatetimeIndex.normalize() / date filtering / shift — DatetimeIndex transforms.
+Outputs JSON: {"function": "datetime_index_normalize_filter_shift", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+SIZE = 5_000
+WARMUP = 5
+ITERATIONS = 50
+
+idx = pd.date_range(start="2020-01-01 12:30:00", periods=SIZE, freq="h")
+cutoff = pd.Timestamp("2021-01-01")
+
+for _ in range(WARMUP):
+    idx.normalize()
+    idx[idx < cutoff]
+    idx.shift(7, freq="D")
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    idx.normalize()
+    idx[idx < cutoff]
+    idx.shift(7, freq="D")
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({
+    "function": "datetime_index_normalize_filter_shift",
+    "mean_ms": round(mean_ms, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total_ms, 3),
+}))

benchmarks/pandas/bench_index_map.py

@@ -0,0 +1,34 @@
+"""
+Benchmark: pandas Index.map(fn) — transform Index values with a mapping function.
+Outputs JSON: {"function": "index_map", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+SIZE = 50_000
+WARMUP = 5
+ITERATIONS = 50
+
+num_idx = pd.Index(range(SIZE))
+str_idx = pd.Index([f"key_{i % 1000}" for i in range(SIZE)])
+
+for _ in range(WARMUP):
+    num_idx.map(lambda v: v * 2)
+    str_idx.map(lambda v: v.upper())
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    num_idx.map(lambda v: v * 2)
+    str_idx.map(lambda v: v.upper())
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({
+    "function": "index_map",
+    "mean_ms": round(mean_ms, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total_ms, 3),
+}))

benchmarks/pandas/bench_multi_index_fromtuples.py

@@ -0,0 +1,34 @@
+"""
+Benchmark: pandas MultiIndex.from_tuples — construct MultiIndex from array of tuples.
+Outputs JSON: {"function": "multi_index_fromtuples", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+SIZE = 5_000
+WARMUP = 3
+ITERATIONS = 20
+
+tuples2 = [(f"dept_{i % 20}", i % 100) for i in range(SIZE)]
+tuples3 = [(f"region_{i % 5}", f"dept_{i % 20}", i % 50) for i in range(SIZE)]
+
+for _ in range(WARMUP):
+    pd.MultiIndex.from_tuples(tuples2)
+    pd.MultiIndex.from_tuples(tuples3)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    pd.MultiIndex.from_tuples(tuples2)
+    pd.MultiIndex.from_tuples(tuples3)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({
+    "function": "multi_index_fromtuples",
+    "mean_ms": round(mean_ms, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total_ms, 3),
+}))

benchmarks/pandas/bench_timedelta_advanced_ops.py

@@ -0,0 +1,56 @@
+"""
+Benchmark: pandas Timedelta advanced operations — parse, isoformat, division, negation, multiplication, comparison.
+Outputs JSON: {"function": "timedelta_advanced_ops", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+SIZE = 1_000
+WARMUP = 5
+ITERATIONS = 100
+
+iso_strings = [
+    "1 days 02:30:00",
+    "0 days 00:45:00",
+    "7 days 00:00:00",
+    "-1 days +22:30:00",
+    "10 days 05:20:15",
+]
+
+td1 = pd.Timedelta(days=2, hours=3)
+td2 = pd.Timedelta(hours=5, minutes=30)
+deltas = [pd.Timedelta(days=i % 365, hours=i % 24) for i in range(SIZE)]
+
+for _ in range(WARMUP):
+    for s in iso_strings:
+        pd.Timedelta(s)
+    for td in deltas[:50]:
+        td.isoformat()
+        td / td1 if td1.total_seconds() != 0 else None
+        -td
+        td * 2
+        td < td2
+        td == td1
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    for s in iso_strings:
+        pd.Timedelta(s)
+    for td in deltas:
+        td.isoformat()
+        -td
+        td * 3
+        td < td2
+        td == td1
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({
+    "function": "timedelta_advanced_ops",
+    "mean_ms": round(mean_ms, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total_ms, 3),
+}))

benchmarks/tsb/bench_dataframe_rolling_var_std_sum_count.ts

@@ -0,0 +1,44 @@
+/**
+ * Benchmark: DataFrameRolling.var / std / sum / count — rolling aggregations on a 50k-row DataFrame.
+ * Outputs JSON: {"function": "dataframe_rolling_var_std_sum_count", "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).var();
+  df.rolling(WINDOW).std();
+  df.rolling(WINDOW).sum();
+  df.rolling(WINDOW).count();
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  df.rolling(WINDOW).var();
+  df.rolling(WINDOW).std();
+  df.rolling(WINDOW).sum();
+  df.rolling(WINDOW).count();
+  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_var_std_sum_count",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);

benchmarks/tsb/bench_datetime_index_normalize_filter_shift.ts

@@ -0,0 +1,39 @@
+/**
+ * Benchmark: DatetimeIndex.normalize() / filter() / shift(n, freq) — DatetimeIndex transforms.
+ * Outputs JSON: {"function": "datetime_index_normalize_filter_shift", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { date_range } from "../../src/index.ts";
+
+const SIZE = 5_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+// Index with non-midnight times (so normalize actually changes something)
+const idx = date_range({ start: "2020-01-01T12:30:00", periods: SIZE, freq: "h" });
+const cutoff = new Date("2021-01-01T00:00:00Z");
+
+for (let i = 0; i < WARMUP; i++) {
+  idx.normalize();
+  idx.filter((d) => d < cutoff);
+  idx.shift(7, "D");
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  idx.normalize();
+  idx.filter((d) => d < cutoff);
+  idx.shift(7, "D");
+  times.push(performance.now() - t0);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "datetime_index_normalize_filter_shift",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);

benchmarks/tsb/bench_index_map.ts

@@ -0,0 +1,36 @@
+/**
+ * Benchmark: Index.map(fn) — transform Index values to a new Index using a mapping function.
+ * Outputs JSON: {"function": "index_map", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Index } from "../../src/index.ts";
+
+const SIZE = 50_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const numIdx = new Index(Array.from({ length: SIZE }, (_, i) => i));
+const strIdx = new Index(Array.from({ length: SIZE }, (_, i) => `key_${i % 1000}`));
+
+for (let i = 0; i < WARMUP; i++) {
+  numIdx.map((v) => (v as number) * 2);
+  strIdx.map((v) => (v as string).toUpperCase());
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  numIdx.map((v) => (v as number) * 2);
+  strIdx.map((v) => (v as string).toUpperCase());
+  times.push(performance.now() - t0);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "index_map",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);

benchmarks/tsb/bench_multi_index_fromtuples.ts

@@ -0,0 +1,46 @@
+/**
+ * Benchmark: MultiIndex.fromTuples — construct a MultiIndex from an array of tuples.
+ * Outputs JSON: {"function": "multi_index_fromtuples", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { MultiIndex } from "../../src/index.ts";
+
+const SIZE = 5_000;
+const WARMUP = 3;
+const ITERATIONS = 20;
+
+// Build an array of 2-level tuples [string, number]
+const tuples: (readonly (string | number)[])[] = Array.from({ length: SIZE }, (_, i) => [
+  `dept_${i % 20}`,
+  i % 100,
+]);
+
+// Also build 3-level tuples to test deeper nesting
+const tuples3: (readonly (string | number)[])[] = Array.from({ length: SIZE }, (_, i) => [
+  `region_${i % 5}`,
+  `dept_${i % 20}`,
+  i % 50,
+]);
+
+for (let i = 0; i < WARMUP; i++) {
+  MultiIndex.fromTuples(tuples);
+  MultiIndex.fromTuples(tuples3);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  MultiIndex.fromTuples(tuples);
+  MultiIndex.fromTuples(tuples3);
+  times.push(performance.now() - t0);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "multi_index_fromtuples",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);