Iteration 139: Add 8 benchmark pairs (420 total, +8 vs 412)

Added benchmark pairs:
- cut_interval_index: cutIntervalIndex/qcutIntervalIndex vs pd.cut/qcut
- dataframe_sign: dataFrameSign vs np.sign(df)
- argsort_scalars: argsortScalars/searchsortedMany vs np.argsort/searchsorted
- interval_index_ops: IntervalIndex.contains/get_loc vs pd.IntervalIndex ops
- period_index_range: PeriodIndex.periodRange/fromPeriods vs pd.period_range
- datetime_index_from: DatetimeIndex.fromDates/fromTimestamps vs pd.DatetimeIndex
- timedelta_index: TimedeltaIndex.fromTimedeltas/fromRange/fromStrings vs pd.TimedeltaIndex
- resolve_freq: resolveFreq vs pd.tseries.frequencies.to_offset

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_argsort_scalars.py

@@ -0,0 +1,24 @@
+"""Benchmark: np.argsort / np.searchsorted — sort/search utilities on 100k-element arrays."""
+import json
+import time
+import numpy as np
+
+SIZE = 100_000
+WARMUP = 3
+ITERATIONS = 20
+
+arr = np.sin(np.arange(SIZE) * 0.001) * SIZE
+sorted_arr = np.sort(arr)
+queries = (np.arange(1000) - 500) * SIZE / 500
+
+for _ in range(WARMUP):
+    np.argsort(arr)
+    np.searchsorted(sorted_arr, queries)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    np.argsort(arr)
+    np.searchsorted(sorted_arr, queries)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({"function": "argsort_scalars", "mean_ms": total / ITERATIONS, "iterations": ITERATIONS, "total_ms": total}))

benchmarks/pandas/bench_cut_interval_index.py

@@ -0,0 +1,24 @@
+"""Benchmark: cutIntervalIndex / qcutIntervalIndex — pd.cut/qcut returning IntervalIndex on 100k-element Series."""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 30
+
+data = (np.arange(SIZE) % 1000) * 0.1
+s = pd.Series(data)
+
+for _ in range(WARMUP):
+    pd.cut(s, 20, retbins=False)
+    pd.qcut(s, 10, duplicates="drop")
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    pd.cut(s, 20, retbins=False)
+    pd.qcut(s, 10, duplicates="drop")
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({"function": "cut_interval_index", "mean_ms": total / ITERATIONS, "iterations": ITERATIONS, "total_ms": total}))

benchmarks/pandas/bench_dataframe_sign.py

@@ -0,0 +1,25 @@
+"""Benchmark: DataFrame sign operation — np.sign on 100k-row DataFrame."""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+ROWS = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+df = pd.DataFrame({
+    "a": (np.arange(ROWS) % 200) - 100,
+    "b": np.sin(np.arange(ROWS) * 0.01) * 1000,
+    "c": (np.arange(ROWS) % 3) - 1,
+})
+
+for _ in range(WARMUP):
+    np.sign(df)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    np.sign(df)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({"function": "dataframe_sign", "mean_ms": total / ITERATIONS, "iterations": ITERATIONS, "total_ms": total}))

benchmarks/pandas/bench_datetime_index_from.py

@@ -0,0 +1,25 @@
+"""Benchmark: pd.DatetimeIndex from dates/timestamps — DatetimeIndex construction from raw data."""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 50
+
+base = pd.Timestamp("2000-01-01")
+dates = [base + pd.Timedelta(days=i) for i in range(SIZE)]
+timestamps = np.arange(SIZE) * 86_400 * 1_000_000_000 + base.value  # nanosecond timestamps
+
+for _ in range(WARMUP):
+    pd.DatetimeIndex(dates)
+    pd.DatetimeIndex(timestamps)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    pd.DatetimeIndex(dates)
+    pd.DatetimeIndex(timestamps)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({"function": "datetime_index_from", "mean_ms": total / ITERATIONS, "iterations": ITERATIONS, "total_ms": total}))

benchmarks/pandas/bench_interval_index_ops.py

@@ -0,0 +1,30 @@
+"""Benchmark: IntervalIndex contains / get_loc — interval index lookup ops on 1k-interval index."""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+BREAKS = 1_001  # 1000 intervals
+QUERIES = 10_000
+WARMUP = 5
+ITERATIONS = 50
+
+breaks = np.arange(BREAKS) * 0.1
+idx = pd.IntervalIndex.from_breaks(breaks)
+
+# Query values spread across the range
+query_values = (np.arange(QUERIES) / QUERIES) * (BREAKS - 1) * 0.1
+
+for _ in range(WARMUP):
+    for q in query_values[:100]:
+        idx.contains(q)
+        idx.get_loc(q)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    for q in query_values:
+        idx.contains(q)
+        idx.get_loc(q)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({"function": "interval_index_ops", "mean_ms": total / ITERATIONS, "iterations": ITERATIONS, "total_ms": total}))

benchmarks/pandas/bench_period_index_range.py

@@ -0,0 +1,25 @@
+"""Benchmark: pd.period_range / pd.PeriodIndex — PeriodIndex construction."""
+import json
+import time
+import pandas as pd
+
+WARMUP = 5
+ITERATIONS = 50
+
+start_d = pd.Period("2000-01-01", freq="D")
+start_m = pd.Period("2000-01", freq="M")
+day_periods = pd.period_range(start="2000-01-01", periods=365 * 10, freq="D")
+
+for _ in range(WARMUP):
+    pd.period_range(start=start_d, periods=3650, freq="D")
+    pd.period_range(start=start_m, periods=120, freq="ME")
+    pd.PeriodIndex(day_periods[:365])
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    pd.period_range(start=start_d, periods=3650, freq="D")
+    pd.period_range(start=start_m, periods=120, freq="ME")
+    pd.PeriodIndex(day_periods[:365])
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({"function": "period_index_range", "mean_ms": total / ITERATIONS, "iterations": ITERATIONS, "total_ms": total}))

benchmarks/pandas/bench_resolve_freq.py

@@ -0,0 +1,24 @@
+"""Benchmark: pd.tseries.frequencies.to_offset — frequency string-to-offset resolution."""
+import json
+import time
+import pandas as pd
+from pandas.tseries.frequencies import to_offset
+
+WARMUP = 5
+ITERATIONS = 1_000
+
+freqs = ["D", "h", "min", "s", "ms", "ME", "QE", "YE", "W", "B"]
+
+for _ in range(WARMUP):
+    for f in freqs:
+        to_offset(f)
+        to_offset(f"2{f}")
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    for f in freqs:
+        to_offset(f)
+        to_offset(f"2{f}")
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({"function": "resolve_freq", "mean_ms": total / ITERATIONS, "iterations": ITERATIONS, "total_ms": total}))

benchmarks/pandas/bench_timedelta_index.py

@@ -0,0 +1,29 @@
+"""Benchmark: pd.TimedeltaIndex construction from timedeltas/range/strings."""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 1_000
+WARMUP = 5
+ITERATIONS = 100
+
+deltas = [pd.Timedelta(days=i, hours=i % 24) for i in range(SIZE)]
+start_td = pd.Timedelta(days=0)
+stop_td = pd.Timedelta(days=SIZE)
+step_td = pd.Timedelta(days=1)
+strings = [f"{i}D" for i in range(SIZE)]
+
+for _ in range(WARMUP):
+    pd.TimedeltaIndex(deltas)
+    pd.timedelta_range(start=start_td, end=stop_td, freq=step_td)
+    pd.to_timedelta(strings)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    pd.TimedeltaIndex(deltas)
+    pd.timedelta_range(start=start_td, end=stop_td, freq=step_td)
+    pd.to_timedelta(strings)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({"function": "timedelta_index", "mean_ms": total / ITERATIONS, "iterations": ITERATIONS, "total_ms": total}))

benchmarks/tsb/bench_argsort_scalars.ts

@@ -0,0 +1,37 @@
+/**
+ * Benchmark: argsortScalars / searchsortedMany — sort/search utilities on 100k-element arrays.
+ * Outputs JSON: {"function": "argsort_scalars", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { argsortScalars, searchsortedMany } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 3;
+const ITERATIONS = 20;
+
+// Array of numbers to sort/search
+const arr = Array.from({ length: SIZE }, (_, i) => Math.sin(i * 0.001) * SIZE);
+// Sorted version for searchsortedMany
+const sorted = [...arr].sort((a, b) => (a as number) - (b as number));
+// Query values for searchsortedMany
+const queries = Array.from({ length: 1000 }, (_, i) => (i - 500) * SIZE / 500);
+
+for (let i = 0; i < WARMUP; i++) {
+  argsortScalars(arr);
+  searchsortedMany(sorted, queries);
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  argsortScalars(arr);
+  searchsortedMany(sorted, queries);
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "argsort_scalars",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_cut_interval_index.ts

@@ -0,0 +1,33 @@
+/**
+ * Benchmark: cutIntervalIndex / qcutIntervalIndex — cut/qcut returning IntervalIndex on 100k-element Series.
+ * Outputs JSON: {"function": "cut_interval_index", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, cutIntervalIndex, qcutIntervalIndex } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+const data = Array.from({ length: SIZE }, (_, i) => (i % 1000) * 0.1);
+const s = new Series({ data });
+
+for (let i = 0; i < WARMUP; i++) {
+  cutIntervalIndex(s, 20);
+  qcutIntervalIndex(s, 10);
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  cutIntervalIndex(s, 20);
+  qcutIntervalIndex(s, 10);
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "cut_interval_index",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);