Iteration 131: Add 8 benchmark pairs (372 total, +8 vs best 364)

Add benchmarks for: factorize, get_dummies, nat_sort, to_datetime, to_numeric,
select_dtypes, replace_dataframe, pctchange_df.

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

Author: github-actions[bot]

benchmarks/pandas/bench_factorize.py

@@ -0,0 +1,26 @@
+"""Benchmark: factorize / pd.Categorical.from_codes — encode values as integer codes."""
+import json, time
+import pandas as pd
+import numpy as np
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+categories = ["cat", "dog", "bird", "fish", "hamster"]
+data = [categories[i % len(categories)] for i in range(SIZE)]
+s = pd.Series(data)
+
+for _ in range(WARMUP):
+    pd.factorize(data)
+    s.factorize()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    pd.factorize(data)
+    s.factorize()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function": "factorize", "mean_ms": round(total_ms / ITERATIONS, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_get_dummies.py

@@ -0,0 +1,28 @@
+"""Benchmark: pd.get_dummies — one-hot encoding of categorical data."""
+import json, time
+import pandas as pd
+
+SIZE = 10_000
+WARMUP = 3
+ITERATIONS = 30
+
+categories = ["A", "B", "C", "D", "E"]
+s = pd.Series([categories[i % len(categories)] for i in range(SIZE)])
+df = pd.DataFrame({
+    "cat1": [categories[i % len(categories)] for i in range(SIZE)],
+    "cat2": [["x", "y", "z"][i % 3] for i in range(SIZE)],
+})
+
+for _ in range(WARMUP):
+    pd.get_dummies(s)
+    pd.get_dummies(df, columns=["cat1", "cat2"])
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    pd.get_dummies(s)
+    pd.get_dummies(df, columns=["cat1", "cat2"])
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function": "get_dummies", "mean_ms": round(total_ms / ITERATIONS, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_nat_sort.py

@@ -0,0 +1,33 @@
+"""Benchmark: natural sort using natsort library (equivalent to natSorted/natArgSort)."""
+import json, time
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 50
+
+data = [f"item{i % 1000}_v{i % 10}" for i in range(SIZE)]
+
+try:
+    from natsort import natsorted, index_natsorted
+    def run():
+        natsorted(data)
+        index_natsorted(data)
+except ImportError:
+    import re
+    def nat_key(s):
+        return [int(c) if c.isdigit() else c.lower() for c in re.split(r'(\d+)', s)]
+    def run():
+        sorted(data, key=nat_key)
+        sorted(range(len(data)), key=lambda i: nat_key(data[i]))
+
+for _ in range(WARMUP):
+    run()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    run()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function": "nat_sort", "mean_ms": round(total_ms / ITERATIONS, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_pctchange_df.py

@@ -0,0 +1,27 @@
+"""Benchmark: DataFrame.pct_change — percentage change across DataFrame columns."""
+import json, time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+df = pd.DataFrame({
+    "a": [i * 1.1 + 1 for i in range(SIZE)],
+    "b": [i * 0.5 + 2 for i in range(SIZE)],
+    "c": [i * 2.3 + 3 for i in range(SIZE)],
+})
+
+for _ in range(WARMUP):
+    df.pct_change()
+    df.pct_change(periods=3)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.pct_change()
+    df.pct_change(periods=3)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function": "pctchange_df", "mean_ms": round(total_ms / ITERATIONS, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_replace_dataframe.py

@@ -0,0 +1,26 @@
+"""Benchmark: DataFrame.replace — replace values in a DataFrame."""
+import json, time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+df = pd.DataFrame({
+    "a": [i % 10 for i in range(SIZE)],
+    "b": [i % 5 for i in range(SIZE)],
+    "c": [["x", "y", "z"][i % 3] for i in range(SIZE)],
+})
+mapping = {0: 100, 1: 200, 2: 300}
+
+for _ in range(WARMUP):
+    df.replace(mapping)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.replace(mapping)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function": "replace_dataframe", "mean_ms": round(total_ms / ITERATIONS, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_select_dtypes.py

@@ -0,0 +1,32 @@
+"""Benchmark: DataFrame.select_dtypes — filter columns by dtype."""
+import json, time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+df = pd.DataFrame({
+    "a": list(range(SIZE)),
+    "b": [i * 1.5 for i in range(SIZE)],
+    "c": [f"str{i % 1000}" for i in range(SIZE)],
+    "d": [i % 2 == 0 for i in range(SIZE)],
+    "e": list(range(0, SIZE * 2, 2)),
+    "f": [f"label{i % 100}" for i in range(SIZE)],
+})
+
+for _ in range(WARMUP):
+    df.select_dtypes(include=["number"])
+    df.select_dtypes(include=["object"])
+    df.select_dtypes(exclude=["bool"])
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.select_dtypes(include=["number"])
+    df.select_dtypes(include=["object"])
+    df.select_dtypes(exclude=["bool"])
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function": "select_dtypes", "mean_ms": round(total_ms / ITERATIONS, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_to_datetime.py

@@ -0,0 +1,26 @@
+"""Benchmark: pd.to_datetime — parse string/numeric values to datetime."""
+import json, time
+import pandas as pd
+from datetime import datetime, timedelta
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 50
+
+base = datetime(2020, 1, 1)
+date_strings = [(base + timedelta(days=i)).strftime("%Y-%m-%d") for i in range(SIZE)]
+timestamps = [int((base + timedelta(days=i)).timestamp() * 1000) for i in range(SIZE)]
+
+for _ in range(WARMUP):
+    pd.to_datetime(date_strings)
+    pd.to_datetime(timestamps, unit="ms")
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    pd.to_datetime(date_strings)
+    pd.to_datetime(timestamps, unit="ms")
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function": "to_datetime", "mean_ms": round(total_ms / ITERATIONS, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_to_numeric.py

@@ -0,0 +1,24 @@
+"""Benchmark: pd.to_numeric — coerce string arrays to numeric."""
+import json, time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+str_nums = [str(i * 1.5) for i in range(SIZE)]
+s = pd.Series(str_nums)
+
+for _ in range(WARMUP):
+    pd.to_numeric(str_nums, errors="coerce")
+    pd.to_numeric(s, errors="coerce")
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    pd.to_numeric(str_nums, errors="coerce")
+    pd.to_numeric(s, errors="coerce")
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function": "to_numeric", "mean_ms": round(total_ms / ITERATIONS, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/tsb/bench_factorize.ts

@@ -0,0 +1,37 @@
+/**
+ * Benchmark: factorize / seriesFactorize — encode values as integer codes.
+ * Outputs JSON: {"function": "factorize", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { factorize, seriesFactorize, Series } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const categories = ["cat", "dog", "bird", "fish", "hamster"];
+const data = Array.from({ length: SIZE }, (_, i) => categories[i % categories.length]);
+const s = new Series({ data });
+
+for (let i = 0; i < WARMUP; i++) {
+  factorize(data);
+  seriesFactorize(s);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  factorize(data);
+  seriesFactorize(s);
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "factorize",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);

benchmarks/tsb/bench_get_dummies.ts

@@ -0,0 +1,40 @@
+/**
+ * Benchmark: getDummies / dataFrameGetDummies — one-hot encoding.
+ * Outputs JSON: {"function": "get_dummies", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { getDummies, dataFrameGetDummies, Series, DataFrame } from "../../src/index.ts";
+
+const SIZE = 10_000;
+const WARMUP = 3;
+const ITERATIONS = 30;
+
+const categories = ["A", "B", "C", "D", "E"];
+const s = new Series({ data: Array.from({ length: SIZE }, (_, i) => categories[i % categories.length]) });
+const df = new DataFrame({
+  cat1: Array.from({ length: SIZE }, (_, i) => categories[i % categories.length]),
+  cat2: Array.from({ length: SIZE }, (_, i) => ["x", "y", "z"][i % 3]),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  getDummies(s);
+  dataFrameGetDummies(df, { columns: ["cat1", "cat2"] });
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  getDummies(s);
+  dataFrameGetDummies(df, { columns: ["cat1", "cat2"] });
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "get_dummies",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);