Iteration 144: Add 8 benchmark pairs (445 total, +8 vs best 437)

Added pairs: period_arithmetic (Period.add/diff/compareTo/contains),
period_index_methods (PeriodIndex.shift/sort/unique/toDatetimeStart/toDatetimeEnd),
dt_total_seconds (DatetimeAccessor.total_seconds), timedelta_index_ops
(TimedeltaIndex.sort/unique/shift/filter/min/max), interval_overlaps
(Interval.overlaps/IntervalIndex.overlaps), describe_opts (describe with
percentiles/include options), merge_index_join (merge with left_index/right_index),
to_json_orient (toJson with records/split/columns/values orient options).

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_describe_opts.py

@@ -0,0 +1,31 @@
+"""Benchmark: DataFrame.describe() with percentiles / include options on 100k-row DataFrame."""
+import json, time
+import pandas as pd
+import numpy as np
+
+SIZE = 100_000
+WARMUP = 3
+ITERATIONS = 20
+
+df = pd.DataFrame({
+    "a": np.arange(SIZE) * 1.5,
+    "b": (np.arange(SIZE) % 1000) * 0.7,
+    "label": [f"cat_{i % 10}" for i in range(SIZE)],
+    "flag": np.arange(SIZE) % 2 == 0,
+})
+
+for _ in range(WARMUP):
+    df.describe(percentiles=[0.1, 0.25, 0.5, 0.75, 0.9])
+    df.describe(include="all")
+    df.describe(include=[object])
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.describe(percentiles=[0.1, 0.25, 0.5, 0.75, 0.9])
+    df.describe(include="all")
+    df.describe(include=[object])
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function": "describe_opts", "mean_ms": round(total_ms / ITERATIONS, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_dt_total_seconds.py

@@ -0,0 +1,24 @@
+"""Benchmark: Series.dt.total_seconds() — epoch-second conversion on 100k datetime Series."""
+import json, time
+import pandas as pd
+import numpy as np
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+base = pd.Timestamp("2020-01-01T00:00:00Z")
+dates = pd.date_range(start=base, periods=SIZE, freq="min")
+s = pd.Series(dates)
+
+for _ in range(WARMUP):
+    (s - pd.Timestamp("1970-01-01", tz="UTC")).dt.total_seconds()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    (s - pd.Timestamp("1970-01-01", tz="UTC")).dt.total_seconds()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function": "dt_total_seconds", "mean_ms": round(total_ms / ITERATIONS, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_interval_overlaps.py

@@ -0,0 +1,28 @@
+"""Benchmark: Interval.overlaps / IntervalIndex.overlaps — overlap checks on 1k intervals."""
+import json, time
+import pandas as pd
+
+SIZE = 1_000
+WARMUP = 5
+ITERATIONS = 50
+
+intervals = [pd.Interval(i, i + 2) for i in range(SIZE)]
+breaks = list(range(SIZE + 1))
+idx = pd.IntervalIndex.from_breaks(breaks)
+query = pd.Interval(250, 750)
+
+for _ in range(WARMUP):
+    for iv in intervals[:50]:
+        iv.overlaps(query)
+    idx.overlaps(query)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    for iv in intervals:
+        iv.overlaps(query)
+    idx.overlaps(query)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function": "interval_overlaps", "mean_ms": round(total_ms / ITERATIONS, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_merge_index_join.py

@@ -0,0 +1,27 @@
+"""Benchmark: merge with left_index / right_index options on 10k-row DataFrames."""
+import json, time
+import pandas as pd
+import numpy as np
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 30
+
+left = pd.DataFrame({"val_a": np.arange(SIZE) * 1.5})
+right = pd.DataFrame({"val_b": np.arange(SIZE) * 2.0})
+
+for _ in range(WARMUP):
+    pd.merge(left, right, left_index=True, right_index=True, how="inner")
+    pd.merge(left, right, left_index=True, right_index=True, how="outer")
+    pd.merge(left, right, left_index=True, right_index=True, how="left")
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    pd.merge(left, right, left_index=True, right_index=True, how="inner")
+    pd.merge(left, right, left_index=True, right_index=True, how="outer")
+    pd.merge(left, right, left_index=True, right_index=True, how="left")
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function": "merge_index_join", "mean_ms": round(total_ms / ITERATIONS, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_period_arithmetic.py

@@ -0,0 +1,31 @@
+"""Benchmark: Period.add / diff / compareTo / contains — Period arithmetic on 1k periods."""
+import json, time
+import pandas as pd
+
+SIZE = 1_000
+WARMUP = 5
+ITERATIONS = 50
+
+base = pd.Period("2020-01-01", freq="D")
+periods = [base + i for i in range(SIZE)]
+other = base + 500
+
+for _ in range(WARMUP):
+    for p in periods[:50]:
+        p + 10
+        p - other
+        p < other
+        p.start_time
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    for p in periods:
+        p + 10
+        p - other
+        p < other
+        p.start_time
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function": "period_arithmetic", "mean_ms": round(total_ms / ITERATIONS, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_period_index_methods.py

@@ -0,0 +1,32 @@
+"""Benchmark: PeriodIndex.shift / sort_values / unique / to_timestamp — PeriodIndex operations on 1k periods."""
+import json, time
+import pandas as pd
+import numpy as np
+
+SIZE = 1_000
+WARMUP = 5
+ITERATIONS = 50
+
+base = pd.Period("2020-01-01", freq="D")
+shuffled = [base + ((i * 7) % SIZE) for i in range(SIZE)]
+idx = pd.PeriodIndex(shuffled)
+
+for _ in range(WARMUP):
+    idx.shift(30)
+    idx.sort_values()
+    idx.unique()
+    idx.to_timestamp(how="start")
+    idx.to_timestamp(how="end")
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    idx.shift(30)
+    idx.sort_values()
+    idx.unique()
+    idx.to_timestamp(how="start")
+    idx.to_timestamp(how="end")
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function": "period_index_methods", "mean_ms": round(total_ms / ITERATIONS, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_timedelta_index_ops.py

@@ -0,0 +1,35 @@
+"""Benchmark: TimedeltaIndex sort / unique / shift / min / max on 1k-element index."""
+import json, time
+import pandas as pd
+import numpy as np
+
+SIZE = 1_000
+WARMUP = 5
+ITERATIONS = 100
+
+deltas = [pd.Timedelta(days=(i * 13) % 365, hours=i % 24) for i in range(SIZE)]
+idx = pd.TimedeltaIndex(deltas)
+shift_by = pd.Timedelta(days=1)
+threshold = pd.Timedelta(days=100)
+
+for _ in range(WARMUP):
+    idx.sort_values()
+    idx.unique()
+    idx + shift_by
+    idx[idx < threshold]
+    idx.min()
+    idx.max()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    idx.sort_values()
+    idx.unique()
+    idx + shift_by
+    idx[idx < threshold]
+    idx.min()
+    idx.max()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function": "timedelta_index_ops", "mean_ms": round(total_ms / ITERATIONS, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_to_json_orient.py

@@ -0,0 +1,32 @@
+"""Benchmark: DataFrame.to_json() with different orient options on 10k-row DataFrame."""
+import json, time
+import pandas as pd
+import numpy as np
+
+SIZE = 10_000
+WARMUP = 3
+ITERATIONS = 20
+
+df = pd.DataFrame({
+    "id": np.arange(SIZE),
+    "value": np.arange(SIZE) * 1.1,
+    "label": [f"cat_{i % 10}" for i in range(SIZE)],
+})
+
+for _ in range(WARMUP):
+    df.to_json(orient="records")
+    df.to_json(orient="split")
+    df.to_json(orient="columns")
+    df.to_json(orient="values")
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.to_json(orient="records")
+    df.to_json(orient="split")
+    df.to_json(orient="columns")
+    df.to_json(orient="values")
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function": "to_json_orient", "mean_ms": round(total_ms / ITERATIONS, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/tsb/bench_describe_opts.ts

@@ -0,0 +1,39 @@
+/**
+ * Benchmark: describe() with percentiles / include options on 100k-row DataFrame.
+ * Outputs JSON: {"function": "describe_opts", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, describe } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 3;
+const ITERATIONS = 20;
+
+const df = DataFrame.fromColumns({
+  a: Array.from({ length: SIZE }, (_, i) => i * 1.5),
+  b: Array.from({ length: SIZE }, (_, i) => (i % 1000) * 0.7),
+  label: Array.from({ length: SIZE }, (_, i) => `cat_${i % 10}`),
+  flag: Array.from({ length: SIZE }, (_, i) => i % 2 === 0),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  describe(df, { percentiles: [0.1, 0.25, 0.5, 0.75, 0.9] });
+  describe(df, { include: "all" });
+  describe(df, { include: "object" });
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  describe(df, { percentiles: [0.1, 0.25, 0.5, 0.75, 0.9] });
+  describe(df, { include: "all" });
+  describe(df, { include: "object" });
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "describe_opts",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_dt_total_seconds.ts

@@ -0,0 +1,32 @@
+/**
+ * Benchmark: DatetimeAccessor.total_seconds — epoch-second conversion on 100k datetime Series.
+ * Outputs JSON: {"function": "dt_total_seconds", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const base = new Date("2020-01-01T00:00:00Z").getTime();
+const dates = Array.from({ length: SIZE }, (_, i) => new Date(base + i * 60_000));
+const s = new Series({ data: dates });
+
+for (let i = 0; i < WARMUP; i++) {
+  s.dt.total_seconds();
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  s.dt.total_seconds();
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "dt_total_seconds",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);