Iteration 142: Add 9 benchmark pairs (429 total, +9 vs 420)

Added 9 new benchmark pairs:
- groupby_multi_key: DataFrameGroupBy with multi-column keys ["dept","region"] vs pandas multi-key groupby
- timestamp_static: Timestamp.fromComponents/fromisoformat/fromtimestamp vs pd.Timestamp static ctors
- tz_datetime_index_ops: TZDatetimeIndex.toLocalStrings/sort/unique/filter/contains vs tz-aware DatetimeIndex ops
- rolling_center_min_periods: Rolling with center=true and minPeriods options vs pandas rolling center/min_periods
- cast_scalar: castScalar type coercion vs Python int()/float()/str() conversions
- concat_options: concat with join="inner" and ignoreIndex=true vs pd.concat join/ignore_index
- ewm_com_halflife: EWM with com and halflife params vs pandas ewm(com/halflife)
- nat_sort_key: natSortKey tokenizer vs Python regex-based natural sort key
- dataframe_iter: DataFrame.items()/iterrows() vs pandas df.items()/iterrows()

Note: State file claimed best was 428 (from iters 140/141 that were not pushed to branch);
actual branch had 420 pairs. This iteration rebuilds to 429 (new actual best).

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_cast_scalar.py

@@ -0,0 +1,36 @@
+"""
+Benchmark: Python type coercion equivalents — int(), float(), str(), bool() conversions.
+Outputs JSON: {"function": "cast_scalar", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+int_values = [i % 1000 for i in range(SIZE)]
+float_values = [i * 0.5 for i in range(SIZE)]
+str_values = [str(i % 1000) for i in range(SIZE)]
+bool_values = [i % 2 == 0 for i in range(SIZE)]
+
+for _ in range(WARMUP):
+    for j in range(SIZE):
+        int(float_values[j])
+        float(int_values[j])
+        int(str_values[j])
+        int(bool_values[j])
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    for j in range(SIZE):
+        int(float_values[j])
+        float(int_values[j])
+        int(str_values[j])
+        int(bool_values[j])
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({"function": "cast_scalar", "mean_ms": round(mean_ms, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_concat_options.py

@@ -0,0 +1,37 @@
+"""
+Benchmark: pandas concat with join="inner" and ignore_index=True options.
+Outputs JSON: {"function": "concat_options", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+ROWS = 50_000
+WARMUP = 5
+ITERATIONS = 20
+
+df1 = pd.DataFrame({
+    "a": [i * 1.0 for i in range(ROWS)],
+    "b": [i * 2.0 for i in range(ROWS)],
+    "c": [i * 3.0 for i in range(ROWS)],
+})
+df2 = pd.DataFrame({
+    "a": [i * 1.5 for i in range(ROWS)],
+    "b": [i * 2.5 for i in range(ROWS)],
+    "d": [i * 4.0 for i in range(ROWS)],
+})
+
+for _ in range(WARMUP):
+    pd.concat([df1, df2], join="inner", ignore_index=True)
+    pd.concat([df1, df2], join="outer", ignore_index=True)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    pd.concat([df1, df2], join="inner", ignore_index=True)
+    pd.concat([df1, df2], join="outer", ignore_index=True)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({"function": "concat_options", "mean_ms": round(mean_ms, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_dataframe_iter.py

@@ -0,0 +1,44 @@
+"""
+Benchmark: pandas DataFrame.items() / DataFrame.iterrows() — column and row iteration.
+Outputs JSON: {"function": "dataframe_iter", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+ROWS = 10_000
+WARMUP = 5
+ITERATIONS = 50
+
+df = pd.DataFrame({
+    "a": [i * 1.0 for i in range(ROWS)],
+    "b": [i * 2.0 for i in range(ROWS)],
+    "c": [i * 3.0 for i in range(ROWS)],
+})
+
+
+def consume_items(df: pd.DataFrame) -> None:
+    for _, s in df.items():
+        _ = s.sum()
+
+
+def consume_iterrows(df: pd.DataFrame) -> None:
+    count = 0
+    for _ in df.iterrows():
+        count += 1
+
+
+for _ in range(WARMUP):
+    consume_items(df)
+    consume_iterrows(df)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    consume_items(df)
+    consume_iterrows(df)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({"function": "dataframe_iter", "mean_ms": round(mean_ms, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_ewm_com_halflife.py

@@ -0,0 +1,34 @@
+"""
+Benchmark: pandas EWM with com and halflife decay parameters.
+Outputs JSON: {"function": "ewm_com_halflife", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+import numpy as np
+
+ROWS = 100_000
+WARMUP = 3
+ITERATIONS = 10
+
+data = [float(np.sin(i * 0.05)) for i in range(ROWS)]
+s = pd.Series(data)
+
+for _ in range(WARMUP):
+    s.ewm(com=9).mean()
+    s.ewm(halflife=10).mean()
+    s.ewm(com=5).std()
+    s.ewm(halflife=7).var()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.ewm(com=9).mean()
+    s.ewm(halflife=10).mean()
+    s.ewm(com=5).std()
+    s.ewm(halflife=7).var()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({"function": "ewm_com_halflife", "mean_ms": round(mean_ms, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_groupby_multi_key.py

@@ -0,0 +1,35 @@
+"""
+Benchmark: pandas DataFrame groupby with multiple key columns.
+Outputs JSON: {"function": "groupby_multi_key", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+ROWS = 100_000
+WARMUP = 3
+ITERATIONS = 10
+
+depts = ["eng", "sales", "hr", "ops"]
+regions = ["north", "south", "east", "west"]
+dept = [depts[i % len(depts)] for i in range(ROWS)]
+region = [regions[i % len(regions)] for i in range(ROWS)]
+value = [i * 0.5 for i in range(ROWS)]
+bonus = [i * 0.1 for i in range(ROWS)]
+
+df = pd.DataFrame({"dept": dept, "region": region, "value": value, "bonus": bonus})
+
+for _ in range(WARMUP):
+    df.groupby(["dept", "region"]).sum()
+    df.groupby(["dept", "region"]).mean()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.groupby(["dept", "region"]).sum()
+    df.groupby(["dept", "region"]).mean()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({"function": "groupby_multi_key", "mean_ms": round(mean_ms, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_nat_sort_key.py

@@ -0,0 +1,41 @@
+"""
+Benchmark: Python natural sort key equivalent — natsort library or manual tokenization.
+Uses natsort if available, else falls back to a simple tokenizer.
+Outputs JSON: {"function": "nat_sort_key", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import re
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 50
+
+data = [f"file{i % 1000}_v{(i % 10) + 1}.{i % 100}" for i in range(SIZE)]
+mixed_case = [f"Item{i % 500}_Part{(i % 20) + 1}" for i in range(SIZE)]
+
+
+def nat_sort_key(s: str, ignore_case: bool = False) -> list:
+    """Simple natural sort key tokenizer (matches tsb natSortKey logic)."""
+    if ignore_case:
+        s = s.lower()
+    parts = re.split(r"(\d+)", s)
+    return [int(p) if p.isdigit() else p for p in parts]
+
+
+for _ in range(WARMUP):
+    for j in range(SIZE):
+        nat_sort_key(data[j])
+        nat_sort_key(mixed_case[j], ignore_case=True)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    for j in range(SIZE):
+        nat_sort_key(data[j])
+        nat_sort_key(mixed_case[j], ignore_case=True)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({"function": "nat_sort_key", "mean_ms": round(mean_ms, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_rolling_center_min_periods.py

@@ -0,0 +1,32 @@
+"""
+Benchmark: pandas Rolling with center=True and min_periods options.
+Outputs JSON: {"function": "rolling_center_min_periods", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+import numpy as np
+
+ROWS = 100_000
+WARMUP = 3
+ITERATIONS = 10
+
+data = [float('nan') if i % 10 == 0 else float(np.sin(i * 0.01)) for i in range(ROWS)]
+s = pd.Series(data)
+
+for _ in range(WARMUP):
+    s.rolling(50, center=True).mean()
+    s.rolling(100, min_periods=10).sum()
+    s.rolling(30, center=True, min_periods=5).std()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.rolling(50, center=True).mean()
+    s.rolling(100, min_periods=10).sum()
+    s.rolling(30, center=True, min_periods=5).std()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({"function": "rolling_center_min_periods", "mean_ms": round(mean_ms, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_timestamp_static.py

@@ -0,0 +1,41 @@
+"""
+Benchmark: pandas Timestamp static constructors — fromtimestamp, fromisoformat, components.
+Outputs JSON: {"function": "timestamp_static", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 50
+
+import datetime
+
+iso_strings = [
+    (datetime.datetime(2020, 1, 1) + datetime.timedelta(days=i)).isoformat()
+    for i in range(SIZE)
+]
+timestamps_s = [
+    (datetime.datetime(2020, 1, 1) + datetime.timedelta(hours=i)).timestamp()
+    for i in range(SIZE)
+]
+
+for _ in range(WARMUP):
+    for j in range(SIZE):
+        pd.Timestamp(year=2020, month=(j % 12) + 1, day=(j % 28) + 1)
+        pd.Timestamp(iso_strings[j % len(iso_strings)])
+        pd.Timestamp.fromtimestamp(timestamps_s[j % len(timestamps_s)])
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    for j in range(SIZE):
+        pd.Timestamp(year=2020, month=(j % 12) + 1, day=(j % 28) + 1)
+        pd.Timestamp(iso_strings[j % len(iso_strings)])
+        pd.Timestamp.fromtimestamp(timestamps_s[j % len(timestamps_s)])
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({"function": "timestamp_static", "mean_ms": round(mean_ms, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_tz_datetime_index_ops.py

@@ -0,0 +1,36 @@
+"""
+Benchmark: pandas DatetimeTZDtype index methods — tz_localize, sort_values, unique, filter, isin.
+Outputs JSON: {"function": "tz_datetime_index_ops", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 50
+
+naive = pd.date_range(start="2024-01-01", periods=SIZE, freq="h")
+tz_idx = naive.tz_localize("America/New_York")
+ref_date = pd.Timestamp("2024-06-01", tz="America/New_York")
+
+for _ in range(WARMUP):
+    tz_idx.strftime("%Y-%m-%d %H:%M:%S %Z")
+    tz_idx.sort_values()
+    tz_idx.unique()
+    tz_idx[tz_idx >= ref_date]
+    ref_date in tz_idx
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    tz_idx.strftime("%Y-%m-%d %H:%M:%S %Z")
+    tz_idx.sort_values()
+    tz_idx.unique()
+    tz_idx[tz_idx >= ref_date]
+    ref_date in tz_idx
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+mean_ms = total_ms / ITERATIONS
+print(json.dumps({"function": "tz_datetime_index_ops", "mean_ms": round(mean_ms, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/tsb/bench_cast_scalar.ts

@@ -0,0 +1,51 @@
+/**
+ * Benchmark: castScalar — type coercion of scalar values to various Dtype kinds.
+ * Outputs JSON: {"function": "cast_scalar", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { castScalar, Dtype } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const intDtype = Dtype.from("int64");
+const floatDtype = Dtype.from("float64");
+const strDtype = Dtype.from("str");
+const boolDtype = Dtype.from("bool");
+
+const intValues = Array.from({ length: SIZE }, (_, i) => i % 1000);
+const floatValues = Array.from({ length: SIZE }, (_, i) => i * 0.5);
+const strValues = Array.from({ length: SIZE }, (_, i) => String(i % 1000));
+const boolValues = Array.from({ length: SIZE }, (_, i) => i % 2 === 0);
+
+for (let i = 0; i < WARMUP; i++) {
+  for (let j = 0; j < SIZE; j++) {
+    castScalar(floatValues[j], intDtype);
+    castScalar(intValues[j], floatDtype);
+    castScalar(strValues[j], intDtype);
+    castScalar(boolValues[j], intDtype);
+  }
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  for (let j = 0; j < SIZE; j++) {
+    castScalar(floatValues[j], intDtype);
+    castScalar(intValues[j], floatDtype);
+    castScalar(strValues[j], intDtype);
+    castScalar(boolValues[j], intDtype);
+  }
+  times.push(performance.now() - t0);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "cast_scalar",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);