Iteration 132: Add 8 benchmark pairs (380 total, +8 vs best 372)

Added: searchsorted, astype_series, timestamp, date_offset, timedelta,
json_normalize, period, interval.

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_astype_series.py

@@ -0,0 +1,26 @@
+"""Benchmark: Series.astype() — cast Series dtype."""
+import json, time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+float_series = pd.Series([i * 1.5 for i in range(SIZE)])
+int_series = pd.Series([i for i in range(SIZE)])
+
+for _ in range(WARMUP):
+    float_series.astype("int32")
+    int_series.astype("float64")
+    int_series.astype("str")
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    float_series.astype("int32")
+    int_series.astype("float64")
+    int_series.astype("str")
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"astype_series","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))

benchmarks/pandas/bench_date_offset.py

@@ -0,0 +1,36 @@
+"""Benchmark: DateOffset — MonthEnd, BusinessDay, YearBegin apply."""
+import json, time
+import pandas as pd
+from pandas.tseries.offsets import MonthEnd, BusinessDay, YearBegin, Day
+from datetime import datetime, timezone, timedelta
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 50
+
+month_end = MonthEnd(1)
+biz_day = BusinessDay(5)
+year_begin = YearBegin(1)
+day_off = Day(30)
+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:
+        d + month_end
+        d + biz_day
+        d + year_begin
+        d + day_off
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    for d in dates:
+        d + month_end
+        d + biz_day
+        d + year_begin
+        d + day_off
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"date_offset","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))

benchmarks/pandas/bench_interval.py

@@ -0,0 +1,30 @@
+"""Benchmark: Interval / IntervalIndex — closed/open intervals."""
+import json, time
+import pandas as pd
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 50
+
+intervals = [pd.Interval(i, i + 1) for i in range(SIZE)]
+breaks = list(range(1_001))
+
+for _ in range(WARMUP):
+    for iv in intervals[:100]:
+        iv.mid in iv
+        _ = iv.length
+        str(iv)
+    pd.IntervalIndex.from_breaks(breaks)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    for iv in intervals:
+        iv.mid in iv
+        _ = iv.length
+        str(iv)
+    pd.IntervalIndex.from_breaks(breaks)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"interval","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))

benchmarks/pandas/bench_json_normalize.py

@@ -0,0 +1,24 @@
+"""Benchmark: json_normalize — flatten nested JSON to a flat DataFrame."""
+import json, time
+import pandas as pd
+
+SIZE = 1_000
+WARMUP = 5
+ITERATIONS = 50
+
+records = [
+    {"id": i, "name": f"user_{i}", "address": {"city": f"city_{i % 10}", "zip": str(10000 + i)}, "scores": [i, i+1, i+2]}
+    for i in range(SIZE)
+]
+
+for _ in range(WARMUP):
+    pd.json_normalize(records, max_level=2)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    pd.json_normalize(records, max_level=2)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"json_normalize","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))

benchmarks/pandas/bench_period.py

@@ -0,0 +1,31 @@
+"""Benchmark: Period / PeriodIndex — fixed-frequency time spans."""
+import json, time
+import pandas as pd
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 50
+
+base = pd.Period("2020-01-01", freq="D")
+periods = [base + i for i in range(SIZE)]
+
+start_q = pd.Period("2000Q1", freq="Q")
+end_q = pd.Period("2024Q4", freq="Q")
+
+for _ in range(WARMUP):
+    for p in periods[:100]:
+        str(p)
+        p + 1
+    pd.period_range(start=start_q, end=end_q, freq="Q")
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    for p in periods:
+        str(p)
+        p + 1
+    pd.period_range(start=start_q, end=end_q, freq="Q")
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"period","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))

benchmarks/pandas/bench_searchsorted.py

@@ -0,0 +1,24 @@
+"""Benchmark: searchsorted / searchsortedMany — binary search on sorted arrays."""
+import json, time
+import numpy as np
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+sorted_arr = np.array([i * 2 for i in range(SIZE)])
+needles = np.array([i * 200 for i in range(1_000)])
+
+for _ in range(WARMUP):
+    np.searchsorted(sorted_arr, 50_000)
+    np.searchsorted(sorted_arr, needles)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    np.searchsorted(sorted_arr, 50_000)
+    np.searchsorted(sorted_arr, needles)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"searchsorted","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))

benchmarks/pandas/bench_timedelta.py

@@ -0,0 +1,31 @@
+"""Benchmark: Timedelta — construction and arithmetic."""
+import json, time
+import pandas as pd
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 50
+
+td1 = pd.Timedelta(days=1, hours=2, minutes=30)
+td2 = pd.Timedelta(hours=3, minutes=45, seconds=10)
+deltas = [pd.Timedelta(days=i % 365, hours=i % 24) for i in range(SIZE)]
+
+for _ in range(WARMUP):
+    for d in deltas:
+        d + td1
+        d - td2
+        _ = d.total_seconds() / 3600
+        _ = d.total_seconds()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    for d in deltas:
+        d + td1
+        d - td2
+        _ = d.total_seconds() / 3600
+        _ = d.total_seconds()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"timedelta","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))

benchmarks/pandas/bench_timestamp.py

@@ -0,0 +1,31 @@
+"""Benchmark: Timestamp — construction and component accessors."""
+import json, time
+import pandas as pd
+from datetime import datetime, timezone, timedelta
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 50
+
+base = datetime(2020, 1, 1, tzinfo=timezone.utc)
+dates = [base + timedelta(days=i) for i in range(SIZE)]
+
+for _ in range(WARMUP):
+    for d in dates:
+        ts = pd.Timestamp(d)
+        _ = ts.year
+        _ = ts.month
+        _ = ts.dayofweek
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    for d in dates:
+        ts = pd.Timestamp(d)
+        _ = ts.year
+        _ = ts.month
+        _ = ts.dayofweek
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"timestamp","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))

benchmarks/tsb/bench_astype_series.ts

@@ -0,0 +1,38 @@
+/**
+ * Benchmark: astypeSeries — cast Series dtype.
+ * Outputs JSON: {"function": "astype_series", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, astypeSeries } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const floatSeries = new Series(Array.from({ length: SIZE }, (_, i) => i * 1.5));
+const intSeries = new Series(Array.from({ length: SIZE }, (_, i) => i));
+
+for (let i = 0; i < WARMUP; i++) {
+  astypeSeries(floatSeries, "int32");
+  astypeSeries(intSeries, "float64");
+  astypeSeries(intSeries, "string");
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  astypeSeries(floatSeries, "int32");
+  astypeSeries(intSeries, "float64");
+  astypeSeries(intSeries, "string");
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "astype_series",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);

benchmarks/tsb/bench_date_offset.ts

@@ -0,0 +1,48 @@
+/**
+ * Benchmark: DateOffset — MonthEnd, BusinessDay, YearBegin apply.
+ * Outputs JSON: {"function": "date_offset", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { MonthEnd, BusinessDay, YearBegin, Day } from "../../src/index.ts";
+
+const SIZE = 10_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const monthEnd = new MonthEnd(1);
+const bizDay = new BusinessDay(5);
+const yearBegin = new YearBegin(1);
+const dayOffset = new Day(30);
+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) {
+    monthEnd.apply(d);
+    bizDay.apply(d);
+    yearBegin.apply(d);
+    dayOffset.apply(d);
+  }
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  for (const d of dates) {
+    monthEnd.apply(d);
+    bizDay.apply(d);
+    yearBegin.apply(d);
+    dayOffset.apply(d);
+  }
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "date_offset",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);