Iteration 179: 5 new benchmark pairs (534→539, +5)

Added benchmarks for previously un-benchmarked functions:
- numeric_stats_ext: percentileOfScore, minMaxNormalize, coefficientOfVariation
- cat_ops_from_codes: catFromCodes, catSortByFreq, catToOrdinal
- cat_ops_setops: catUnionCategories, catIntersectCategories, catDiffCategories
- cat_freq_crosstab: catFreqTable, catCrossTab (with normalize)
- natsort_ops: natCompare, natSorted, natArgSort

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_cat_freq_crosstab.py

@@ -0,0 +1,39 @@
+"""
+Benchmark: pd.Series.value_counts (freq table) and pd.crosstab for categorical data on 100k elements.
+Outputs JSON: {"function": "cat_freq_crosstab", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 20
+
+cats_a = ["alpha", "beta", "gamma", "delta", "epsilon"]
+cats_b = ["north", "south", "east", "west"]
+data_a = pd.Categorical([cats_a[i % len(cats_a)] for i in range(SIZE)], categories=cats_a)
+data_b = pd.Categorical([cats_b[i % len(cats_b)] for i in range(SIZE)], categories=cats_b)
+s_a = pd.Series(data_a)
+s_b = pd.Series(data_b)
+
+for _ in range(WARMUP):
+    s_a.value_counts(sort=False)
+    pd.crosstab(s_a, s_b)
+    pd.crosstab(s_a, s_b, normalize=True)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s_a.value_counts(sort=False)
+    pd.crosstab(s_a, s_b)
+    pd.crosstab(s_a, s_b, normalize=True)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "cat_freq_crosstab",
+    "mean_ms": total_ms / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total_ms,
+}))

benchmarks/pandas/bench_cat_ops_from_codes.py

@@ -0,0 +1,49 @@
+"""
+Benchmark: pd.Categorical.from_codes, reorder_categories by freq, ordered categorical on 100k elements.
+Outputs JSON: {"function": "cat_ops_from_codes", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+import numpy as np
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 20
+
+categories = ["alpha", "beta", "gamma", "delta", "epsilon"]
+codes = [i % len(categories) for i in range(SIZE)]
+order = ["epsilon", "delta", "gamma", "beta", "alpha"]
+
+def cat_from_codes():
+    return pd.Categorical.from_codes(codes, categories=categories)
+
+def cat_sort_by_freq(c):
+    s = pd.Series(c)
+    freq_order = s.value_counts().index.tolist()
+    return s.astype(pd.CategoricalDtype(categories=freq_order, ordered=False))
+
+def cat_to_ordinal(c):
+    s = pd.Series(c)
+    return s.astype(pd.CategoricalDtype(categories=order, ordered=True))
+
+for _ in range(WARMUP):
+    c = cat_from_codes()
+    cat_sort_by_freq(c)
+    cat_to_ordinal(c)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    c = cat_from_codes()
+    cat_sort_by_freq(c)
+    cat_to_ordinal(c)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "cat_ops_from_codes",
+    "mean_ms": total_ms / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total_ms,
+}))

benchmarks/pandas/bench_cat_ops_setops.py

@@ -0,0 +1,51 @@
+"""
+Benchmark: categorical union/intersect/diff categories on 100k element Series.
+Outputs JSON: {"function": "cat_ops_setops", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 20
+
+cats_a = ["alpha", "beta", "gamma", "delta"]
+cats_b = ["gamma", "delta", "epsilon", "zeta"]
+data_a = [cats_a[i % len(cats_a)] for i in range(SIZE)]
+data_b = [cats_b[i % len(cats_b)] for i in range(SIZE)]
+s_a = pd.Series(data_a, dtype="category")
+s_b = pd.Series(data_b, dtype="category")
+
+def cat_union(a, b):
+    cats = list(dict.fromkeys(list(a.cat.categories) + [c for c in b.cat.categories if c not in a.cat.categories]))
+    return a.astype(pd.CategoricalDtype(categories=cats))
+
+def cat_intersect(a, b):
+    cats = [c for c in a.cat.categories if c in set(b.cat.categories)]
+    return a.astype(pd.CategoricalDtype(categories=cats))
+
+def cat_diff(a, b):
+    cats = [c for c in a.cat.categories if c not in set(b.cat.categories)]
+    return a.astype(pd.CategoricalDtype(categories=cats))
+
+for _ in range(WARMUP):
+    cat_union(s_a, s_b)
+    cat_intersect(s_a, s_b)
+    cat_diff(s_a, s_b)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    cat_union(s_a, s_b)
+    cat_intersect(s_a, s_b)
+    cat_diff(s_a, s_b)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "cat_ops_setops",
+    "mean_ms": total_ms / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total_ms,
+}))

benchmarks/pandas/bench_natsort_ops.py

@@ -0,0 +1,56 @@
+"""
+Benchmark: natsort.natsorted and natsort.index_natsorted on filename-like strings.
+Outputs JSON: {"function": "natsort_ops", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 20
+
+filenames = [f"file{i % 100}_chunk{i // 100}.txt" for i in range(SIZE)]
+
+def nat_compare(a, b):
+    """Natural comparison: return -1/0/1 by tokenizing digit runs."""
+    import re
+    def tokenize(s):
+        parts = re.split(r'(\d+)', s)
+        return [int(p) if p.isdigit() else p for p in parts]
+    ta, tb = tokenize(a), tokenize(b)
+    return (ta > tb) - (ta < tb)
+
+def nat_sorted(arr):
+    import re
+    def key(s):
+        parts = re.split(r'(\d+)', s)
+        return [int(p) if p.isdigit() else p for p in parts]
+    return sorted(arr, key=key)
+
+def nat_argsort(arr):
+    import re
+    def key(s):
+        parts = re.split(r'(\d+)', s)
+        return [int(p) if p.isdigit() else p for p in parts]
+    return [i for i, _ in sorted(enumerate(arr), key=lambda x: key(x[1]))]
+
+for _ in range(WARMUP):
+    nat_compare("file10.txt", "file9.txt")
+    nat_sorted(filenames)
+    nat_argsort(filenames)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    nat_compare("file10.txt", "file9.txt")
+    nat_sorted(filenames)
+    nat_argsort(filenames)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "natsort_ops",
+    "mean_ms": total_ms / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total_ms,
+}))

benchmarks/pandas/bench_numeric_stats_ext.py

@@ -0,0 +1,51 @@
+"""
+Benchmark: scipy percentileofscore, min-max normalization, coefficient of variation on 100k elements.
+Outputs JSON: {"function": "numeric_stats_ext", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import math
+import pandas as pd
+import numpy as np
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 20
+
+data = [math.sin(i * 0.001) * 100 + 50 for i in range(SIZE)]
+s = pd.Series(data)
+
+def percentile_of_score(arr, score):
+    """Compute percentile rank of score (rank method)."""
+    n = len(arr)
+    below = sum(1 for v in arr if v < score)
+    equal = sum(1 for v in arr if v == score)
+    return (below + 0.5 * equal) / n * 100
+
+def min_max_normalize(series):
+    mn, mx = series.min(), series.max()
+    return (series - mn) / (mx - mn)
+
+def coeff_of_variation(series):
+    return series.std(ddof=1) / series.mean()
+
+for _ in range(WARMUP):
+    percentile_of_score(data, 50)
+    min_max_normalize(s)
+    coeff_of_variation(s)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    percentile_of_score(data, 50)
+    min_max_normalize(s)
+    coeff_of_variation(s)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({
+    "function": "numeric_stats_ext",
+    "mean_ms": total_ms / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total_ms,
+}))

benchmarks/tsb/bench_cat_freq_crosstab.ts

@@ -0,0 +1,41 @@
+/**
+ * Benchmark: catFreqTable and catCrossTab on 100k elements.
+ * Outputs JSON: {"function": "cat_freq_crosstab", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { catFromCodes, catFreqTable, catCrossTab } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 20;
+
+const catsA = ["alpha", "beta", "gamma", "delta", "epsilon"];
+const catsB = ["north", "south", "east", "west"];
+const codesA = Array.from({ length: SIZE }, (_, i) => i % catsA.length);
+const codesB = Array.from({ length: SIZE }, (_, i) => i % catsB.length);
+const csA = catFromCodes(codesA, catsA);
+const csB = catFromCodes(codesB, catsB);
+
+for (let i = 0; i < WARMUP; i++) {
+  catFreqTable(csA);
+  catCrossTab(csA, csB);
+  catCrossTab(csA, csB, { normalize: true });
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  catFreqTable(csA);
+  catCrossTab(csA, csB);
+  catCrossTab(csA, csB, { normalize: true });
+  times.push(performance.now() - t0);
+}
+
+const total = times.reduce((a, b) => a + b, 0);
+console.log(
+  JSON.stringify({
+    function: "cat_freq_crosstab",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_cat_ops_from_codes.ts

@@ -0,0 +1,38 @@
+/**
+ * Benchmark: catFromCodes, catSortByFreq, catToOrdinal on 100k elements.
+ * Outputs JSON: {"function": "cat_ops_from_codes", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { catFromCodes, catSortByFreq, catToOrdinal } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 20;
+
+const categories = ["alpha", "beta", "gamma", "delta", "epsilon"];
+const codes = Array.from({ length: SIZE }, (_, i) => i % categories.length);
+const order = ["epsilon", "delta", "gamma", "beta", "alpha"];
+
+for (let i = 0; i < WARMUP; i++) {
+  const cs = catFromCodes(codes, categories);
+  catSortByFreq(cs);
+  catToOrdinal(cs, order);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  const cs = catFromCodes(codes, categories);
+  catSortByFreq(cs);
+  catToOrdinal(cs, order);
+  times.push(performance.now() - t0);
+}
+
+const total = times.reduce((a, b) => a + b, 0);
+console.log(
+  JSON.stringify({
+    function: "cat_ops_from_codes",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_cat_ops_setops.ts

@@ -0,0 +1,41 @@
+/**
+ * Benchmark: catUnionCategories, catIntersectCategories, catDiffCategories on 100k elements.
+ * Outputs JSON: {"function": "cat_ops_setops", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { catFromCodes, catUnionCategories, catIntersectCategories, catDiffCategories } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 20;
+
+const catsA = ["alpha", "beta", "gamma", "delta"];
+const catsB = ["gamma", "delta", "epsilon", "zeta"];
+const codesA = Array.from({ length: SIZE }, (_, i) => i % catsA.length);
+const codesB = Array.from({ length: SIZE }, (_, i) => i % catsB.length);
+const csA = catFromCodes(codesA, catsA);
+const csB = catFromCodes(codesB, catsB);
+
+for (let i = 0; i < WARMUP; i++) {
+  catUnionCategories(csA, csB);
+  catIntersectCategories(csA, csB);
+  catDiffCategories(csA, csB);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  catUnionCategories(csA, csB);
+  catIntersectCategories(csA, csB);
+  catDiffCategories(csA, csB);
+  times.push(performance.now() - t0);
+}
+
+const total = times.reduce((a, b) => a + b, 0);
+console.log(
+  JSON.stringify({
+    function: "cat_ops_setops",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);