Iteration 259: 7 new benchmark pairs (606 total, +2 vs best 604)

Added benchmark pairs for:
- dataframe_ffill_bfill_fn (dataFrameFfill/dataFrameBfill standalone)
- series_ffill_bfill_fn (ffillSeries/bfillSeries standalone)
- dataframe_diff_shift_fn (diffDataFrame/shiftDataFrame standalone)
- interval_range_fn (intervalRange standalone)
- date_range_fn (dateRange standalone function)
- format_timedelta_fn (formatTimedelta/parseFrac)
- advance_date_fn (advanceDate/parseFreq)

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_advance_date_fn.py

@@ -0,0 +1,35 @@
+"""
+Benchmark: pandas DateOffset arithmetic — advance a date by a frequency.
+Mirrors tsb bench_advance_date_fn.ts (advanceDate/parseFreq).
+Outputs JSON: {"function": "advance_date_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+from pandas.tseries.offsets import Day, BusinessDay, Hour, MonthBegin, MonthEnd, Week
+
+WARMUP = 5
+ITERATIONS = 50
+
+d = pd.Timestamp("2020-01-15")
+offsets = [Day(1), Day(2), Hour(1), Hour(3), MonthBegin(1), MonthEnd(1), Week(1), BusinessDay(1)]
+
+for _ in range(WARMUP):
+    for off in offsets:
+        d + off
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    for _ in range(1000):
+        for off in offsets:
+            d + off
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "advance_date_fn",
+    "mean_ms": round(total_ms / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total_ms, 3),
+}))

benchmarks/pandas/bench_dataframe_diff_shift_fn.py

@@ -0,0 +1,38 @@
+"""
+Benchmark: pandas DataFrame.diff() / DataFrame.shift() — standalone diff and shift.
+Mirrors tsb bench_dataframe_diff_shift_fn.ts (standalone diffDataFrame/shiftDataFrame).
+Outputs JSON: {"function": "dataframe_diff_shift_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": np.arange(SIZE, dtype=float),
+    "b": np.arange(SIZE, dtype=float) * 0.5 + 100,
+    "c": np.sin(np.arange(SIZE) * 0.01) * 1000,
+})
+
+for _ in range(WARMUP):
+    df.diff(periods=1)
+    df.shift(periods=3)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.diff(periods=1)
+    df.shift(periods=3)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "dataframe_diff_shift_fn",
+    "mean_ms": round(total_ms / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total_ms, 3),
+}))

benchmarks/pandas/bench_dataframe_ffill_bfill_fn.py

@@ -0,0 +1,39 @@
+"""
+Benchmark: pandas DataFrame.ffill() / DataFrame.bfill() — forward/backward fill.
+Mirrors tsb bench_dataframe_ffill_bfill_fn.ts (standalone dataFrameFfill/dataFrameBfill).
+Outputs JSON: {"function": "dataframe_ffill_bfill_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
+
+rng = np.random.default_rng(42)
+a = np.where(np.arange(SIZE) % 5 == 0, np.nan, np.arange(SIZE, dtype=float))
+b = np.where(np.arange(SIZE) % 7 == 0, np.nan, np.arange(SIZE, dtype=float) * 0.5)
+c = np.where(np.arange(SIZE) % 3 == 0, np.nan, np.arange(SIZE, dtype=float) * 2.0)
+
+df = pd.DataFrame({"a": a, "b": b, "c": c})
+
+for _ in range(WARMUP):
+    df.ffill()
+    df.bfill()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.ffill()
+    df.bfill()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "dataframe_ffill_bfill_fn",
+    "mean_ms": round(total_ms / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total_ms, 3),
+}))

benchmarks/pandas/bench_date_range_fn.py

@@ -0,0 +1,33 @@
+"""
+Benchmark: pandas pd.date_range() — generate date sequences.
+Mirrors tsb bench_date_range_fn.ts (dateRange standalone function).
+Outputs JSON: {"function": "date_range_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+WARMUP = 5
+ITERATIONS = 50
+
+start = "2020-01-01"
+end = "2020-12-31"
+
+for _ in range(WARMUP):
+    pd.date_range(start=start, end=end, freq="D")
+    pd.date_range(start=start, periods=1000, freq="h")
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    pd.date_range(start=start, end=end, freq="D")
+    pd.date_range(start=start, periods=1000, freq="h")
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "date_range_fn",
+    "mean_ms": round(total_ms / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total_ms, 3),
+}))

benchmarks/pandas/bench_format_timedelta_fn.py

@@ -0,0 +1,39 @@
+"""
+Benchmark: pandas Timedelta string formatting — str(Timedelta) and parsing.
+Mirrors tsb bench_format_timedelta_fn.ts (formatTimedelta/parseFrac).
+Outputs JSON: {"function": "format_timedelta_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+WARMUP = 5
+ITERATIONS = 50
+
+tds = [
+    pd.Timedelta(days=1),
+    pd.Timedelta(seconds=3661),
+    pd.Timedelta(milliseconds=90061001),
+    pd.Timedelta(seconds=0),
+    pd.Timedelta(seconds=-86400),
+]
+
+for _ in range(WARMUP):
+    for td in tds:
+        str(td)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    for _ in range(1000):
+        for td in tds:
+            str(td)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "format_timedelta_fn",
+    "mean_ms": round(total_ms / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total_ms, 3),
+}))

benchmarks/pandas/bench_interval_range_fn.py

@@ -0,0 +1,30 @@
+"""
+Benchmark: pandas pd.interval_range() — create an IntervalIndex from start/end with periods.
+Mirrors tsb bench_interval_range_fn.ts (intervalRange standalone function).
+Outputs JSON: {"function": "interval_range_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+WARMUP = 5
+ITERATIONS = 50
+
+for _ in range(WARMUP):
+    pd.interval_range(start=0, end=1000, periods=10_000)
+    pd.interval_range(start=0, end=100, freq=0.01)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    pd.interval_range(start=0, end=1000, periods=10_000)
+    pd.interval_range(start=0, end=100, freq=0.01)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "interval_range_fn",
+    "mean_ms": round(total_ms / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total_ms, 3),
+}))

benchmarks/pandas/bench_series_ffill_bfill_fn.py

@@ -0,0 +1,35 @@
+"""
+Benchmark: pandas Series.ffill() / Series.bfill() — forward/backward fill for Series.
+Mirrors tsb bench_series_ffill_bfill_fn.ts (standalone ffillSeries/bfillSeries).
+Outputs JSON: {"function": "series_ffill_bfill_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+data = [float("nan") if i % 5 == 0 else i * 1.0 for i in range(SIZE)]
+s = pd.Series(data)
+
+for _ in range(WARMUP):
+    s.ffill()
+    s.bfill()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.ffill()
+    s.bfill()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "series_ffill_bfill_fn",
+    "mean_ms": round(total_ms / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total_ms, 3),
+}))

benchmarks/tsb/bench_advance_date_fn.ts

@@ -0,0 +1,42 @@
+/**
+ * Benchmark: advanceDate / parseFreq — advance a Date by a parsed frequency and parse freq strings.
+ * Mirrors pandas DateOffset arithmetic and freq parsing.
+ * Outputs JSON: {"function": "advance_date_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { advanceDate, parseFreq } from "../../src/index.ts";
+
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const d = new Date("2020-01-15");
+const freqs = ["D", "2D", "h", "3h", "MS", "ME", "W", "B"];
+const parsedFreqs = freqs.map((f) => parseFreq(f));
+
+for (let i = 0; i < WARMUP; i++) {
+  for (const pf of parsedFreqs) advanceDate(d, pf);
+  for (const f of freqs) parseFreq(f);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  for (let j = 0; j < 1000; j++) {
+    for (const pf of parsedFreqs) advanceDate(d, pf);
+    for (const f of freqs) parseFreq(f);
+  }
+  times.push(performance.now() - t0);
+}
+
+const total = times.reduce((a, b) => a + b, 0);
+console.log(
+  JSON.stringify({
+    function: "advance_date_fn",
+    mean_ms: round3(total / ITERATIONS),
+    iterations: ITERATIONS,
+    total_ms: round3(total),
+  }),
+);
+
+function round3(v: number): number {
+  return Math.round(v * 1000) / 1000;
+}

benchmarks/tsb/bench_dataframe_diff_shift_fn.ts

@@ -0,0 +1,43 @@
+/**
+ * Benchmark: diffDataFrame / shiftDataFrame — standalone diff and shift for DataFrames.
+ * Mirrors pandas DataFrame.diff() / DataFrame.shift().
+ * Outputs JSON: {"function": "dataframe_diff_shift_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, diffDataFrame, shiftDataFrame } 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.0),
+  b: Array.from({ length: SIZE }, (_, i) => i * 0.5 + 100),
+  c: Array.from({ length: SIZE }, (_, i) => Math.sin(i * 0.01) * 1000),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  diffDataFrame(df, { periods: 1 });
+  shiftDataFrame(df, { periods: 3 });
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  diffDataFrame(df, { periods: 1 });
+  shiftDataFrame(df, { periods: 3 });
+  times.push(performance.now() - t0);
+}
+
+const total = times.reduce((a, b) => a + b, 0);
+console.log(
+  JSON.stringify({
+    function: "dataframe_diff_shift_fn",
+    mean_ms: round3(total / ITERATIONS),
+    iterations: ITERATIONS,
+    total_ms: round3(total),
+  }),
+);
+
+function round3(v: number): number {
+  return Math.round(v * 1000) / 1000;
+}

benchmarks/tsb/bench_dataframe_ffill_bfill_fn.ts

@@ -0,0 +1,43 @@
+/**
+ * Benchmark: dataFrameFfill / dataFrameBfill — standalone forward/backward fill for DataFrames.
+ * Mirrors pandas DataFrame.ffill() / DataFrame.bfill().
+ * Outputs JSON: {"function": "dataframe_ffill_bfill_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, dataFrameFfill, dataFrameBfill } 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 % 5 === 0 ? null : i * 1.0)),
+  b: Array.from({ length: SIZE }, (_, i) => (i % 7 === 0 ? null : i * 0.5)),
+  c: Array.from({ length: SIZE }, (_, i) => (i % 3 === 0 ? null : i * 2.0)),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  dataFrameFfill(df);
+  dataFrameBfill(df);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  dataFrameFfill(df);
+  dataFrameBfill(df);
+  times.push(performance.now() - t0);
+}
+
+const total = times.reduce((a, b) => a + b, 0);
+console.log(
+  JSON.stringify({
+    function: "dataframe_ffill_bfill_fn",
+    mean_ms: round3(total / ITERATIONS),
+    iterations: ITERATIONS,
+    total_ms: round3(total),
+  }),
+);
+
+function round3(v: number): number {
+  return Math.round(v * 1000) / 1000;
+}