Iteration 156: 5 new benchmark pairs

Added benchmarks for DateOffset rollforward/rollback/onOffset, more DateOffset
types (MonthBegin/YearEnd/Week/Minute/Milli), date_range with various frequency
options, combineFirstDataFrame standalone function, and SeriesGroupBy.agg with
custom aggregate functions.

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_combine_first_dataframe.py

@@ -0,0 +1,36 @@
+"""Benchmark: DataFrame.combine_first — fill NaN values from another DataFrame (union of indexes).
+Mirrors tsb bench_combine_first_dataframe.ts.
+"""
+import json, time
+import numpy as np
+import pandas as pd
+
+SIZE = 5_000
+WARMUP = 5
+ITERATIONS = 30
+
+rows1 = list(range(SIZE))
+data1a = [None if i % 3 == 0 else i * 1.5 for i in range(SIZE)]
+data1b = [None if i % 5 == 0 else i * 0.5 for i in range(SIZE)]
+df1 = pd.DataFrame({"a": data1a, "b": data1b}, index=rows1)
+
+rows2 = list(range(SIZE + 500))
+data2a = [i * 2.0 for i in range(SIZE + 500)]
+data2b = [i * 1.0 for i in range(SIZE + 500)]
+data2c = [i * 0.1 for i in range(SIZE + 500)]
+df2 = pd.DataFrame({"a": data2a, "b": data2b, "c": data2c}, index=rows2)
+
+for _ in range(WARMUP):
+    df1.combine_first(df2)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    df1.combine_first(df2)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "combine_first_dataframe",
+    "mean_ms": round(total / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total, 3),
+}))

benchmarks/pandas/bench_date_offset_more_types.py

@@ -0,0 +1,45 @@
+"""Benchmark: DateOffset more types — MonthBegin, YearEnd, Week, Minute, Milli apply.
+Mirrors tsb bench_date_offset_more_types.ts for pandas.tseries.offsets.
+"""
+import json, time
+from datetime import timedelta
+import pandas as pd
+from pandas.tseries.offsets import MonthBegin, YearEnd, Week, Minute, Milli
+
+SIZE = 5_000
+WARMUP = 5
+ITERATIONS = 50
+
+month_begin = MonthBegin(1)
+year_end = YearEnd(1)
+week = Week(2)
+minute = Minute(60)
+milli = Milli(1000)
+
+base = pd.Timestamp("2020-01-15 10:30:00", tz="UTC")
+dates = [base + timedelta(minutes=i) for i in range(SIZE)]
+
+for _ in range(WARMUP):
+    for d in dates[:100]:
+        d + month_begin
+        d + year_end
+        d + week
+        d + minute
+        d + milli
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    for d in dates:
+        d + month_begin
+        d + year_end
+        d + week
+        d + minute
+        d + milli
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "date_offset_more_types",
+    "mean_ms": round(total / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total, 3),
+}))

benchmarks/pandas/bench_date_offset_rollforward.py

@@ -0,0 +1,58 @@
+"""Benchmark: DateOffset.rollforward / rollback / is_on_offset — snap dates to anchors.
+Mirrors tsb bench_date_offset_rollforward.ts for pandas.tseries.offsets.
+"""
+import json, time
+from datetime import datetime, timezone, timedelta
+from pandas.tseries.offsets import MonthEnd, BusinessDay, YearBegin, MonthBegin, YearEnd
+
+SIZE = 5_000
+WARMUP = 5
+ITERATIONS = 50
+
+month_end = MonthEnd(1)
+biz_day = BusinessDay(1)
+year_begin = YearBegin(1)
+month_begin = MonthBegin(1)
+year_end = YearEnd(1)
+
+import pandas as pd
+base = pd.Timestamp("2020-01-15", tz="UTC")
+dates = [base + timedelta(days=i) for i in range(SIZE)]
+
+for _ in range(WARMUP):
+    for d in dates[:100]:
+        month_end.rollforward(d)
+        month_end.rollback(d)
+        month_end.is_on_offset(d)
+        biz_day.rollforward(d)
+        biz_day.rollback(d)
+        biz_day.is_on_offset(d)
+        year_begin.rollforward(d)
+        year_begin.rollback(d)
+        month_begin.rollforward(d)
+        month_begin.rollback(d)
+        year_end.rollforward(d)
+        year_end.rollback(d)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    for d in dates:
+        month_end.rollforward(d)
+        month_end.rollback(d)
+        month_end.is_on_offset(d)
+        biz_day.rollforward(d)
+        biz_day.rollback(d)
+        year_begin.rollforward(d)
+        year_begin.rollback(d)
+        month_begin.rollforward(d)
+        month_begin.rollback(d)
+        year_end.rollforward(d)
+        year_end.rollback(d)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "date_offset_rollforward",
+    "mean_ms": round(total / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total, 3),
+}))

benchmarks/pandas/bench_date_range_options.py

@@ -0,0 +1,37 @@
+"""Benchmark: date_range — generate DatetimeIndex with various frequency options.
+Mirrors tsb bench_date_range_options.ts using pandas.date_range.
+"""
+import json, time
+import pandas as pd
+
+WARMUP = 5
+ITERATIONS = 100
+
+for _ in range(WARMUP):
+    pd.date_range(start="2020-01-01", periods=1_000, freq="D")
+    pd.date_range(start="2020-01-01", periods=1_000, freq="h")
+    pd.date_range(start="2020-01-01", periods=500, freq="ME")
+    pd.date_range(start="2020-01-01", periods=200, freq="QE")
+    pd.date_range(start="2020-01-01", periods=100, freq="YE")
+    pd.date_range(start="2020-01-01", periods=500, freq="MS")
+    pd.date_range(start="2020-01-01", end="2025-01-01", freq="W")
+    pd.date_range(start="2020-01-01", periods=2_000, freq="min")
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    pd.date_range(start="2020-01-01", periods=1_000, freq="D")
+    pd.date_range(start="2020-01-01", periods=1_000, freq="h")
+    pd.date_range(start="2020-01-01", periods=500, freq="ME")
+    pd.date_range(start="2020-01-01", periods=200, freq="QE")
+    pd.date_range(start="2020-01-01", periods=100, freq="YE")
+    pd.date_range(start="2020-01-01", periods=500, freq="MS")
+    pd.date_range(start="2020-01-01", end="2025-01-01", freq="W")
+    pd.date_range(start="2020-01-01", periods=2_000, freq="min")
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "date_range_options",
+    "mean_ms": round(total / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total, 3),
+}))

benchmarks/pandas/bench_series_groupby_custom_agg.py

@@ -0,0 +1,38 @@
+"""Benchmark: SeriesGroupBy.agg with custom aggregate functions — median, range.
+Mirrors tsb bench_series_groupby_custom_agg.ts.
+"""
+import json, time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 3
+ITERATIONS = 20
+
+data = [(i * 1.5) % 9999 for i in range(SIZE)]
+by = [i % 100 for i in range(SIZE)]
+s = pd.Series(data)
+gb = s.groupby(by)
+
+def median_fn(x):
+    return float(np.median(x))
+
+def range_fn(x):
+    return float(np.max(x) - np.min(x))
+
+for _ in range(WARMUP):
+    gb.agg(median_fn)
+    gb.agg(range_fn)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    gb.agg(median_fn)
+    gb.agg(range_fn)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "series_groupby_custom_agg",
+    "mean_ms": round(total / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total, 3),
+}))

benchmarks/tsb/bench_combine_first_dataframe.ts

@@ -0,0 +1,44 @@
+/**
+ * Benchmark: combineFirstDataFrame — fill NaN values from another DataFrame (union of indexes).
+ * Mirrors pandas DataFrame.combine_first.
+ * Outputs JSON: {"function": "combine_first_dataframe", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, Index, combineFirstDataFrame } from "../../src/index.ts";
+
+const SIZE = 5_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+// df1: rows 0..SIZE-1, ~30% nulls
+const rows1 = Array.from({ length: SIZE }, (_, i) => i);
+const data1a = Array.from({ length: SIZE }, (_, i) => (i % 3 === 0 ? null : i * 1.5));
+const data1b = Array.from({ length: SIZE }, (_, i) => (i % 5 === 0 ? null : i * 0.5));
+const idx1 = new Index(rows1);
+const df1 = new DataFrame({ a: data1a, b: data1b }, idx1);
+
+// df2: rows 0..SIZE+500-1 (overlapping + extra), fills missing in df1
+const rows2 = Array.from({ length: SIZE + 500 }, (_, i) => i);
+const data2a = Array.from({ length: SIZE + 500 }, (_, i) => i * 2.0);
+const data2b = Array.from({ length: SIZE + 500 }, (_, i) => i * 1.0);
+const data2c = Array.from({ length: SIZE + 500 }, (_, i) => i * 0.1);
+const idx2 = new Index(rows2);
+const df2 = new DataFrame({ a: data2a, b: data2b, c: data2c }, idx2);
+
+for (let i = 0; i < WARMUP; i++) {
+  combineFirstDataFrame(df1, df2);
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  combineFirstDataFrame(df1, df2);
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "combine_first_dataframe",
+    mean_ms: Math.round((total / ITERATIONS) * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(total * 1000) / 1000,
+  }),
+);

benchmarks/tsb/bench_date_offset_more_types.ts

@@ -0,0 +1,50 @@
+/**
+ * Benchmark: DateOffset more types — apply operations for MonthBegin, YearEnd, Week, Minute, Milli.
+ * These DateOffset classes haven't been covered in existing benchmarks.
+ * Outputs JSON: {"function": "date_offset_more_types", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { MonthBegin, YearEnd, Week, Minute, Milli } from "../../src/index.ts";
+
+const SIZE = 5_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const monthBegin = new MonthBegin(1);
+const yearEnd = new YearEnd(1);
+const week = new Week(2);
+const minute = new Minute(60);
+const milli = new Milli(1000);
+
+const base = new Date(Date.UTC(2020, 0, 15, 10, 30, 0));
+const dates = Array.from({ length: SIZE }, (_, i) => new Date(base.getTime() + i * 60_000));
+
+for (let i = 0; i < WARMUP; i++) {
+  for (const d of dates.slice(0, 100)) {
+    monthBegin.apply(d);
+    yearEnd.apply(d);
+    week.apply(d);
+    minute.apply(d);
+    milli.apply(d);
+  }
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  for (const d of dates) {
+    monthBegin.apply(d);
+    yearEnd.apply(d);
+    week.apply(d);
+    minute.apply(d);
+    milli.apply(d);
+  }
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "date_offset_more_types",
+    mean_ms: Math.round((total / ITERATIONS) * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(total * 1000) / 1000,
+  }),
+);

benchmarks/tsb/bench_date_offset_rollforward.ts

@@ -0,0 +1,63 @@
+/**
+ * Benchmark: DateOffset.rollforward / rollback / onOffset — snap dates to offset anchors.
+ * Tests MonthEnd, BusinessDay, YearBegin, MonthBegin, YearEnd.
+ * Outputs JSON: {"function": "date_offset_rollforward", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { MonthEnd, BusinessDay, YearBegin, MonthBegin, YearEnd } from "../../src/index.ts";
+
+const SIZE = 5_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const monthEnd = new MonthEnd(1);
+const bizDay = new BusinessDay(1);
+const yearBegin = new YearBegin(1);
+const monthBegin = new MonthBegin(1);
+const yearEnd = new YearEnd(1);
+
+const base = new Date(Date.UTC(2020, 0, 15));
+const dates = Array.from({ length: SIZE }, (_, i) => new Date(base.getTime() + i * 86_400_000));
+
+for (let i = 0; i < WARMUP; i++) {
+  for (const d of dates.slice(0, 100)) {
+    monthEnd.rollforward(d);
+    monthEnd.rollback(d);
+    monthEnd.onOffset(d);
+    bizDay.rollforward(d);
+    bizDay.rollback(d);
+    bizDay.onOffset(d);
+    yearBegin.rollforward(d);
+    yearBegin.rollback(d);
+    monthBegin.rollforward(d);
+    monthBegin.rollback(d);
+    yearEnd.rollforward(d);
+    yearEnd.rollback(d);
+  }
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  for (const d of dates) {
+    monthEnd.rollforward(d);
+    monthEnd.rollback(d);
+    monthEnd.onOffset(d);
+    bizDay.rollforward(d);
+    bizDay.rollback(d);
+    yearBegin.rollforward(d);
+    yearBegin.rollback(d);
+    monthBegin.rollforward(d);
+    monthBegin.rollback(d);
+    yearEnd.rollforward(d);
+    yearEnd.rollback(d);
+  }
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "date_offset_rollforward",
+    mean_ms: Math.round((total / ITERATIONS) * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(total * 1000) / 1000,
+  }),
+);