Iteration 260: 7 new benchmark pairs (613 total, +7 vs best 606)

Added benchmark pairs for toTimedelta conversion, toDateInput utility,
Timedelta arithmetic (add/subtract/abs/scale), Timedelta property getters,
Timedelta toString/formatTimedelta, IntervalIndex.indexOf/overlapping,
and Interval closed-type variants.

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

Author: github-actions[bot]

benchmarks/pandas/bench_interval_closed_types.py

@@ -0,0 +1,44 @@
+"""
+Benchmark: Interval closed types — both, neither, left, right endpoint variants.
+Tests pandas Interval properties with all 4 closed types.
+Outputs JSON: {"function": "interval_closed_types", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+WARMUP = 5
+ITERATIONS = 100
+SIZE = 1_000
+
+closed_types = ["both", "neither", "left", "right"]
+all_intervals = []
+for closed in closed_types:
+    for i in range(SIZE // 4):
+        all_intervals.append(pd.Interval(i, i + 1, closed=closed))
+
+ref = pd.Interval(0, 1, closed="right")
+
+for _ in range(WARMUP):
+    for iv in all_intervals[:50]:
+        _ = iv.closed
+        _ = iv.mid
+        _ = iv.length
+        _ = (0.5 + all_intervals.index(iv) % (SIZE // 4)) in iv
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    for iv in all_intervals:
+        _ = iv.closed
+        _ = iv.mid
+        _ = iv.length
+    times.append((time.perf_counter() - t0) * 1000)
+
+total = sum(times)
+print(json.dumps({
+    "function": "interval_closed_types",
+    "mean_ms": round(total / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total, 3),
+}))

benchmarks/pandas/bench_interval_index_query.py

@@ -0,0 +1,38 @@
+"""
+Benchmark: IntervalIndex.get_indexer / IntervalIndex.overlaps — interval lookup and overlap queries.
+Mirrors tsb IntervalIndex.indexOf / IntervalIndex.overlapping methods.
+Outputs JSON: {"function": "interval_index_query", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+import numpy as np
+
+WARMUP = 5
+ITERATIONS = 50
+
+BREAKS = 501
+breaks = [i * 2 for i in range(BREAKS)]
+idx = pd.IntervalIndex.from_breaks(breaks)
+
+queries = [i * 0.999 for i in range(1_000)]
+query_interval = pd.Interval(200, 400)
+
+for _ in range(WARMUP):
+    idx.get_indexer(queries[:50])
+    idx.overlaps(query_interval)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    idx.get_indexer(queries)
+    idx.overlaps(query_interval)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total = sum(times)
+print(json.dumps({
+    "function": "interval_index_query",
+    "mean_ms": round(total / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total, 3),
+}))

benchmarks/pandas/bench_timedelta_arithmetic_fn.py

@@ -0,0 +1,43 @@
+"""
+Benchmark: pandas Timedelta add/sub/abs — basic Timedelta arithmetic.
+Mirrors tsb bench_timedelta_arithmetic_fn.ts.
+Outputs JSON: {"function": "timedelta_arithmetic_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+WARMUP = 5
+ITERATIONS = 100
+
+SIZE = 1_000
+td1 = pd.Timedelta(days=1, hours=6)
+td2 = pd.Timedelta(hours=2, minutes=30)
+ms_value = 7_200_000  # 2 hours in ms
+
+deltas = [pd.Timedelta(milliseconds=(i - SIZE // 2) * 60_000) for i in range(SIZE)]
+
+for _ in range(WARMUP):
+    pd.Timedelta(milliseconds=ms_value)
+    for td in deltas[:50]:
+        td + td1
+        td - td2
+        abs(td)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    pd.Timedelta(milliseconds=ms_value)
+    for td in deltas:
+        td + td1
+        td - td2
+        abs(td)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "timedelta_arithmetic_fn",
+    "mean_ms": round(total_ms / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total_ms, 3),
+}))

benchmarks/pandas/bench_timedelta_props.py

@@ -0,0 +1,44 @@
+"""
+Benchmark: Timedelta property getters — days, hours, minutes, seconds, microseconds, nanoseconds.
+Mirrors tsb Timedelta property accessors.
+Outputs JSON: {"function": "timedelta_props", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+import numpy as np
+
+WARMUP = 5
+ITERATIONS = 100
+SIZE = 2_000
+
+deltas = [pd.Timedelta(milliseconds=(i - SIZE // 2) * 3_661) for i in range(SIZE)]
+
+for _ in range(WARMUP):
+    for td in deltas[:100]:
+        _ = td.days
+        _ = td.seconds
+        _ = td.microseconds
+        _ = td.nanoseconds
+        _ = td.total_seconds()
+        _ = td.components
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    for td in deltas:
+        _ = td.days
+        _ = td.seconds
+        _ = td.microseconds
+        _ = td.nanoseconds
+        _ = td.total_seconds()
+        _ = td.components
+    times.append((time.perf_counter() - t0) * 1000)
+
+total = sum(times)
+print(json.dumps({
+    "function": "timedelta_props",
+    "mean_ms": round(total / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total, 3),
+}))

benchmarks/pandas/bench_timedelta_tostring.py

@@ -0,0 +1,33 @@
+"""
+Benchmark: Timedelta.__str__() — formatting durations as strings.
+Mirrors tsb Timedelta.toString() / formatTimedelta().
+Outputs JSON: {"function": "timedelta_tostring", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+WARMUP = 5
+ITERATIONS = 100
+SIZE = 1_000
+
+deltas = [pd.Timedelta(milliseconds=(i - SIZE // 2) * 7_778) for i in range(SIZE)]
+
+for _ in range(WARMUP):
+    for td in deltas[:50]:
+        str(td)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    for td in deltas:
+        str(td)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total = sum(times)
+print(json.dumps({
+    "function": "timedelta_tostring",
+    "mean_ms": round(total / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total, 3),
+}))

benchmarks/pandas/bench_to_date_input.py

@@ -0,0 +1,74 @@
+"""
+Benchmark: pandas pd.Timestamp() — convert ISO strings, timestamps, and datetime objects to Timestamp.
+Mirrors tsb bench_to_date_input.ts (toDateInput).
+Outputs JSON: {"function": "to_date_input", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+from datetime import datetime
+import pandas as pd
+
+WARMUP = 5
+ITERATIONS = 50
+
+iso_strings = [
+    "2020-01-01",
+    "2024-03-15T10:30:00Z",
+    "2023-12-31T23:59:59.999Z",
+    "2022-07-04",
+    "2021-01-01T00:00:00",
+]
+
+# millisecond timestamps
+timestamps = [
+    0,
+    1_577_836_800_000,
+    1_704_067_200_000,
+    1_609_459_200_000,
+    1_672_531_200_000,
+]
+
+date_objects = [
+    datetime(2020, 1, 1),
+    datetime(2024, 6, 15),
+    datetime(2001, 9, 9, 1, 46, 40),
+]
+
+SIZE = 10_000
+str_batch = [
+    f"{2000 + (i % 25)}-{((i % 12) + 1):02d}-{((i % 28) + 1):02d}"
+    for i in range(SIZE)
+]
+num_batch = [i * 86_400_000 for i in range(SIZE)]
+
+for _ in range(WARMUP):
+    for s in iso_strings:
+        pd.Timestamp(s)
+    for t in timestamps:
+        pd.Timestamp(t, unit="ms")
+    for d in date_objects:
+        pd.Timestamp(d)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    for _ in range(1000):
+        for s in iso_strings:
+            pd.Timestamp(s)
+        for t in timestamps:
+            pd.Timestamp(t, unit="ms")
+        for d in date_objects:
+            pd.Timestamp(d)
+    for s in str_batch:
+        pd.Timestamp(s)
+    for t in num_batch:
+        pd.Timestamp(t, unit="ms")
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "to_date_input",
+    "mean_ms": round(total_ms / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total_ms, 3),
+}))

benchmarks/pandas/bench_to_timedelta_convert.py

@@ -0,0 +1,56 @@
+"""
+Benchmark: pandas pd.to_timedelta() — convert strings, numbers, and arrays to timedelta.
+Mirrors tsb bench_to_timedelta_convert.ts.
+Outputs JSON: {"function": "to_timedelta_convert", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+WARMUP = 5
+ITERATIONS = 50
+
+strings = [
+    "1 days 02:03:04",
+    "0 days 00:30:00",
+    "5 days 12:00:00.500",
+    "PT1H30M",
+    "P7D",
+    "-PT2H45M30S",
+    "2h 30m 15s",
+    "1 day 00:00:00",
+]
+
+numbers = [86400, 3600, 1800, 7200, 0, -3600]
+
+SIZE = 1_000
+str_array = [f"{i % 100} days {(i % 24):02d}:00:00" for i in range(SIZE)]
+num_array = [i * 3600 for i in range(SIZE)]
+
+for _ in range(WARMUP):
+    for s in strings:
+        pd.to_timedelta(s)
+    for n in numbers:
+        pd.to_timedelta(n, unit="s")
+    pd.to_timedelta(str_array)
+    pd.to_timedelta(num_array, unit="s")
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    for _ in range(100):
+        for s in strings:
+            pd.to_timedelta(s)
+        for n in numbers:
+            pd.to_timedelta(n, unit="s")
+    pd.to_timedelta(str_array)
+    pd.to_timedelta(num_array, unit="s")
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "to_timedelta_convert",
+    "mean_ms": round(total_ms / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total_ms, 3),
+}))

benchmarks/tsb/bench_interval_closed_types.ts

@@ -0,0 +1,59 @@
+/**
+ * Benchmark: Interval closed types — both, neither, left, right endpoint variants.
+ * Tests closedLeft, closedRight, isOpen, isClosed, equals, and contains with all 4 closed types.
+ * Outputs JSON: {"function": "interval_closed_types", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Interval } from "../../src/index.ts";
+
+const WARMUP = 5;
+const ITERATIONS = 100;
+
+const SIZE = 1_000;
+const closedTypes = ["both", "neither", "left", "right"] as const;
+
+const intervalSets = closedTypes.map((closed) =>
+  Array.from({ length: SIZE / 4 }, (_, i) => new Interval(i, i + 1, closed)),
+);
+const all = intervalSets.flat();
+const ref = new Interval(0, 1, "right");
+
+for (let w = 0; w < WARMUP; w++) {
+  for (const iv of all.slice(0, 50)) {
+    void iv.closedLeft;
+    void iv.closedRight;
+    void iv.isOpen;
+    void iv.isClosed;
+    void iv.mid;
+    iv.contains(iv.mid);
+    iv.equals(ref);
+  }
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  for (const iv of all) {
+    void iv.closedLeft;
+    void iv.closedRight;
+    void iv.isOpen;
+    void iv.isClosed;
+    void iv.mid;
+    iv.contains(iv.mid);
+    iv.equals(ref);
+  }
+  times.push(performance.now() - t0);
+}
+
+const total = times.reduce((a, b) => a + b, 0);
+console.log(
+  JSON.stringify({
+    function: "interval_closed_types",
+    mean_ms: round3(total / ITERATIONS),
+    iterations: ITERATIONS,
+    total_ms: round3(total),
+  }),
+);
+
+function round3(v: number): number {
+  return Math.round(v * 1000) / 1000;
+}