Iteration 137: Add 8 benchmark pairs (404 total, +8 vs 396)

Added pairs: infer_dtype, value_counts_binned, categorical_index,
tz_localize_convert, align_series, align_dataframe, memory_usage, named_agg.
Covers dtype inference, binned value counts, CategoricalIndex ops,
timezone operations, Series/DataFrame alignment, memory estimation,
and named aggregation (lost in iter 133's missing branch).

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_align_dataframe.py

@@ -0,0 +1,43 @@
+"""
+Benchmark: DataFrame.align — align two 10k-row DataFrames on inner/outer/left join.
+Outputs JSON: {"function": "align_dataframe", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 30
+
+idx_a = [i * 2 for i in range(SIZE)]
+idx_b = [i * 3 for i in range(SIZE)]
+
+df_a = pd.DataFrame(
+    {"x": [i * 1.0 for i in range(SIZE)], "y": [i * 2.0 for i in range(SIZE)], "z": [i * 3.0 for i in range(SIZE)]},
+    index=idx_a,
+)
+df_b = pd.DataFrame(
+    {"y": [i * 10.0 for i in range(SIZE)], "z": [i * 20.0 for i in range(SIZE)], "w": [i * 30.0 for i in range(SIZE)]},
+    index=idx_b,
+)
+
+for _ in range(WARMUP):
+    df_a.align(df_b, join="inner")
+    df_a.align(df_b, join="outer")
+    df_a.align(df_b, join="left")
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    df_a.align(df_b, join="inner")
+    df_a.align(df_b, join="outer")
+    df_a.align(df_b, join="left")
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "align_dataframe",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_align_series.py

@@ -0,0 +1,36 @@
+"""
+Benchmark: Series.align — align two 50k-element Series on inner/outer/left join.
+Outputs JSON: {"function": "align_series", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 50_000
+WARMUP = 5
+ITERATIONS = 30
+
+idx_a = [i * 2 for i in range(SIZE)]
+idx_b = [i * 3 for i in range(SIZE)]
+s_a = pd.Series([i * 1.0 for i in range(SIZE)], index=idx_a)
+s_b = pd.Series([i * 2.0 for i in range(SIZE)], index=idx_b)
+
+for _ in range(WARMUP):
+    s_a.align(s_b, join="inner")
+    s_a.align(s_b, join="outer")
+    s_a.align(s_b, join="left")
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    s_a.align(s_b, join="inner")
+    s_a.align(s_b, join="outer")
+    s_a.align(s_b, join="left")
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "align_series",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_categorical_index.py

@@ -0,0 +1,41 @@
+"""
+Benchmark: pandas.CategoricalIndex — creation, get_loc, add_categories, set operations on 100k elements.
+Outputs JSON: {"function": "categorical_index", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 30
+
+CATS = ["alpha", "beta", "gamma", "delta", "epsilon"]
+labels = [CATS[i % len(CATS)] for i in range(SIZE)]
+ci = pd.CategoricalIndex(labels)
+labels2 = [CATS[(i + 2) % len(CATS)] for i in range(SIZE // 2)]
+ci2 = pd.CategoricalIndex(labels2)
+
+for _ in range(WARMUP):
+    pd.CategoricalIndex(labels)
+    ci.get_loc("beta")
+    ci.add_categories(["zeta"])
+    ci.union(ci2)
+    ci.intersection(ci2)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    pd.CategoricalIndex(labels)
+    ci.get_loc("beta")
+    ci.add_categories(["zeta"])
+    ci.union(ci2)
+    ci.intersection(ci2)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "categorical_index",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_infer_dtype.py

@@ -0,0 +1,39 @@
+"""
+Benchmark: infer_dtype — pandas.api.types.infer_dtype on 100k-element arrays.
+Outputs JSON: {"function": "infer_dtype", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+from pandas.api.types import infer_dtype
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+int_arr = list(range(SIZE))
+float_arr = [i * 0.5 for i in range(SIZE)]
+str_arr = [f"val_{i}" for i in range(SIZE)]
+mixed_arr = [f"s{i}" if i % 3 == 0 else i for i in range(SIZE)]
+
+for _ in range(WARMUP):
+    infer_dtype(int_arr, skipna=True)
+    infer_dtype(float_arr, skipna=True)
+    infer_dtype(str_arr, skipna=True)
+    infer_dtype(mixed_arr, skipna=True)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    infer_dtype(int_arr, skipna=True)
+    infer_dtype(float_arr, skipna=True)
+    infer_dtype(str_arr, skipna=True)
+    infer_dtype(mixed_arr, skipna=True)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "infer_dtype",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_memory_usage.py

@@ -0,0 +1,42 @@
+"""
+Benchmark: Series.memory_usage / DataFrame.memory_usage — memory estimation.
+Outputs JSON: {"function": "memory_usage", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+num_series = pd.Series([i * 1.0 for i in range(SIZE)])
+str_series = pd.Series([f"label_{i % 100}" for i in range(SIZE)])
+df = pd.DataFrame({
+    "a": [i * 1.0 for i in range(SIZE)],
+    "b": [i * 2.0 for i in range(SIZE)],
+    "c": [f"cat_{i % 50}" for i in range(SIZE)],
+    "d": [i % 2 == 0 for i in range(SIZE)],
+})
+
+for _ in range(WARMUP):
+    num_series.memory_usage()
+    str_series.memory_usage(deep=True)
+    df.memory_usage()
+    df.memory_usage(deep=True)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    num_series.memory_usage()
+    str_series.memory_usage(deep=True)
+    df.memory_usage()
+    df.memory_usage(deep=True)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "memory_usage",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_named_agg.py

@@ -0,0 +1,49 @@
+"""
+Benchmark: DataFrameGroupBy.agg with named aggregations (pandas.NamedAgg) on 100k rows.
+Outputs JSON: {"function": "named_agg", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 20
+
+depts = ["eng", "hr", "sales", "finance", "ops"]
+df = pd.DataFrame({
+    "dept": [depts[i % len(depts)] for i in range(SIZE)],
+    "salary": [50_000 + (i % 100) * 1000 for i in range(SIZE)],
+    "headcount": [1 + (i % 5) for i in range(SIZE)],
+    "score": [(i % 100) * 0.1 for i in range(SIZE)],
+})
+
+gb = df.groupby("dept")
+
+for _ in range(WARMUP):
+    gb.agg(
+        total_salary=pd.NamedAgg(column="salary", aggfunc="sum"),
+        avg_salary=pd.NamedAgg(column="salary", aggfunc="mean"),
+        max_salary=pd.NamedAgg(column="salary", aggfunc="max"),
+        employees=pd.NamedAgg(column="headcount", aggfunc="count"),
+        avg_score=pd.NamedAgg(column="score", aggfunc="mean"),
+    )
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    gb.agg(
+        total_salary=pd.NamedAgg(column="salary", aggfunc="sum"),
+        avg_salary=pd.NamedAgg(column="salary", aggfunc="mean"),
+        max_salary=pd.NamedAgg(column="salary", aggfunc="max"),
+        employees=pd.NamedAgg(column="headcount", aggfunc="count"),
+        avg_score=pd.NamedAgg(column="score", aggfunc="mean"),
+    )
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "named_agg",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_tz_localize_convert.py

@@ -0,0 +1,32 @@
+"""
+Benchmark: DatetimeIndex.tz_localize / tz_convert — timezone operations on 10k-element index.
+Outputs JSON: {"function": "tz_localize_convert", "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")
+
+for _ in range(WARMUP):
+    utc = naive.tz_localize("UTC")
+    utc.tz_convert("America/New_York")
+    naive.tz_localize("America/New_York", ambiguous="NaT", nonexistent="NaT")
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    utc = naive.tz_localize("UTC")
+    utc.tz_convert("America/New_York")
+    naive.tz_localize("America/New_York", ambiguous="NaT", nonexistent="NaT")
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "tz_localize_convert",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_value_counts_binned.py

@@ -0,0 +1,32 @@
+"""
+Benchmark: Series.value_counts(bins=N) — bin 100k values and count occurrences.
+Outputs JSON: {"function": "value_counts_binned", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+data = [(i % 1000) * 0.1 for i in range(SIZE)]
+s = pd.Series(data)
+
+for _ in range(WARMUP):
+    s.value_counts(bins=10)
+    s.value_counts(bins=50)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    s.value_counts(bins=10)
+    s.value_counts(bins=50)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "value_counts_binned",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/tsb/bench_align_dataframe.ts

@@ -0,0 +1,53 @@
+/**
+ * Benchmark: alignDataFrame — align two 10k-row DataFrames on inner/outer join.
+ * Outputs JSON: {"function": "align_dataframe", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, Index, alignDataFrame } from "../../src/index.ts";
+
+const SIZE = 10_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+const idxA = Array.from({ length: SIZE }, (_, i) => i * 2);
+const idxB = Array.from({ length: SIZE }, (_, i) => i * 3);
+
+const dfA = new DataFrame(
+  {
+    x: Array.from({ length: SIZE }, (_, i) => i * 1.0),
+    y: Array.from({ length: SIZE }, (_, i) => i * 2.0),
+    z: Array.from({ length: SIZE }, (_, i) => i * 3.0),
+  },
+  { index: new Index(idxA) },
+);
+
+const dfB = new DataFrame(
+  {
+    y: Array.from({ length: SIZE }, (_, i) => i * 10.0),
+    z: Array.from({ length: SIZE }, (_, i) => i * 20.0),
+    w: Array.from({ length: SIZE }, (_, i) => i * 30.0),
+  },
+  { index: new Index(idxB) },
+);
+
+for (let i = 0; i < WARMUP; i++) {
+  alignDataFrame(dfA, dfB, { join: "inner" });
+  alignDataFrame(dfA, dfB, { join: "outer" });
+  alignDataFrame(dfA, dfB, { join: "left" });
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  alignDataFrame(dfA, dfB, { join: "inner" });
+  alignDataFrame(dfA, dfB, { join: "outer" });
+  alignDataFrame(dfA, dfB, { join: "left" });
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "align_dataframe",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);