[Autoloop: perf-comparison] Iteration 378: add 3 benchmark pairs (merge_ordered_ffill, merge_ordered_by, grouper_class)

Run: https://github.com/githubnext/tsb/actions/runs/28315875254

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

Author: github-actions[bot]

benchmarks/pandas/bench_grouper_class.py

@@ -0,0 +1,44 @@
+"""Benchmark: pd.Grouper construction and isinstance checks — 50k iterations."""
+import json
+import time
+
+import pandas as pd
+
+WARMUP = 5
+ITERATIONS = 50_000
+
+
+def run_groupers() -> None:
+    g1 = pd.Grouper(key="col_a")
+    g2 = pd.Grouper(key="date", sort=True)
+    g3 = pd.Grouper(key="category", dropna=False)
+
+    isinstance(g1, pd.Grouper)
+    isinstance(g2, pd.Grouper)
+    isinstance(g3, pd.Grouper)
+    isinstance("not_a_grouper", pd.Grouper)
+    isinstance(42, pd.Grouper)
+
+    str(g1)
+    str(g2)
+    str(g3)
+
+
+for _ in range(WARMUP):
+    run_groupers()
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    run_groupers()
+total = (time.perf_counter() - start) * 1000
+
+print(
+    json.dumps(
+        {
+            "function": "grouper_class",
+            "mean_ms": total / ITERATIONS,
+            "iterations": ITERATIONS,
+            "total_ms": total,
+        }
+    )
+)

benchmarks/pandas/bench_merge_ordered_by.py

@@ -0,0 +1,41 @@
+"""Benchmark: pd.merge_ordered with left_by grouping — two 3k-row DataFrames, 10 groups."""
+import json
+import time
+
+import pandas as pd
+
+N = 3_000
+GROUPS = 10
+PER_GROUP = N // GROUPS
+WARMUP = 2
+ITERATIONS = 8
+
+grp_left = [f"g{g}" for g in range(GROUPS) for _ in range(PER_GROUP)]
+t_left = [j * 2 for _ in range(GROUPS) for j in range(PER_GROUP)]
+v1 = [g * PER_GROUP + j for g in range(GROUPS) for j in range(PER_GROUP)]
+
+grp_right = [f"g{g}" for g in range(GROUPS) for _ in range(PER_GROUP)]
+t_right = [j * 3 for _ in range(GROUPS) for j in range(PER_GROUP)]
+v2 = [g * PER_GROUP + j for g in range(GROUPS) for j in range(PER_GROUP)]
+
+df1 = pd.DataFrame({"grp": grp_left, "t": t_left, "val1": v1})
+df2 = pd.DataFrame({"grp": grp_right, "t": t_right, "val2": v2})
+
+for _ in range(WARMUP):
+    pd.merge_ordered(df1, df2, on="t", left_by="grp", right_by="grp")
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    pd.merge_ordered(df1, df2, on="t", left_by="grp", right_by="grp")
+total = (time.perf_counter() - start) * 1000
+
+print(
+    json.dumps(
+        {
+            "function": "merge_ordered_by",
+            "mean_ms": total / ITERATIONS,
+            "iterations": ITERATIONS,
+            "total_ms": total,
+        }
+    )
+)

benchmarks/pandas/bench_merge_ordered_ffill.py

@@ -0,0 +1,36 @@
+"""Benchmark: pd.merge_ordered with fill_method='ffill' — two 5k-row DataFrames."""
+import json
+import time
+
+import pandas as pd
+
+N = 5_000
+WARMUP = 2
+ITERATIONS = 8
+
+keys1 = list(range(0, N * 2, 2))
+vals1 = [i * 1.0 for i in range(N)]
+keys2 = list(range(0, N * 3, 3))
+vals2 = [i * 2.0 for i in range(N)]
+
+df1 = pd.DataFrame({"key": keys1, "val1": vals1})
+df2 = pd.DataFrame({"key": keys2, "val2": vals2})
+
+for _ in range(WARMUP):
+    pd.merge_ordered(df1, df2, on="key", fill_method="ffill")
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    pd.merge_ordered(df1, df2, on="key", fill_method="ffill")
+total = (time.perf_counter() - start) * 1000
+
+print(
+    json.dumps(
+        {
+            "function": "merge_ordered_ffill",
+            "mean_ms": total / ITERATIONS,
+            "iterations": ITERATIONS,
+            "total_ms": total,
+        }
+    )
+)

benchmarks/tsb/bench_grouper_class.ts

@@ -0,0 +1,44 @@
+/**
+ * Benchmark: Grouper class — construction, predicates, and isGrouper on 50k iterations.
+ * Outputs JSON: {"function": "grouper_class", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Grouper, isGrouper } from "../../src/index.ts";
+
+const WARMUP = 5;
+const ITERATIONS = 50_000;
+
+function runGroupers(): void {
+  const g1 = new Grouper({ key: "col_a" });
+  const g2 = new Grouper({ key: "date", sort: true });
+  const g3 = new Grouper({ key: "category", dropna: false });
+
+  isGrouper(g1);
+  isGrouper(g2);
+  isGrouper(g3);
+  isGrouper("not_a_grouper");
+  isGrouper(42);
+
+  g1.isKeyGrouper();
+  g2.isKeyGrouper();
+  g3.isKeyGrouper();
+  g1.isLevelGrouper();
+
+  g1.toString();
+  g2.toString();
+  g3.toString();
+}
+
+for (let i = 0; i < WARMUP; i++) runGroupers();
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) runGroupers();
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "grouper_class",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_merge_ordered_by.ts

@@ -0,0 +1,56 @@
+/**
+ * Benchmark: mergeOrdered with left_by grouping — two 3k-row DataFrames, 10 groups.
+ * Outputs JSON: {"function": "merge_ordered_by", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, mergeOrdered } from "../../src/index.ts";
+
+const N = 3_000;
+const GROUPS = 10;
+const PER_GROUP = N / GROUPS;
+const WARMUP = 2;
+const ITERATIONS = 8;
+
+// Build sorted data by (grp, t)
+const grpLeft: string[] = [];
+const tLeft: number[] = [];
+const v1: number[] = [];
+for (let g = 0; g < GROUPS; g++) {
+  for (let j = 0; j < PER_GROUP; j++) {
+    grpLeft.push(`g${g}`);
+    tLeft.push(j * 2);
+    v1.push(g * PER_GROUP + j);
+  }
+}
+
+const grpRight: string[] = [];
+const tRight: number[] = [];
+const v2: number[] = [];
+for (let g = 0; g < GROUPS; g++) {
+  for (let j = 0; j < PER_GROUP; j++) {
+    grpRight.push(`g${g}`);
+    tRight.push(j * 3);
+    v2.push(g * PER_GROUP + j);
+  }
+}
+
+const df1 = DataFrame.fromColumns({ grp: grpLeft, t: tLeft, val1: v1 });
+const df2 = DataFrame.fromColumns({ grp: grpRight, t: tRight, val2: v2 });
+
+for (let i = 0; i < WARMUP; i++) {
+  mergeOrdered(df1, df2, { on: "t", left_by: "grp", right_by: "grp" });
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  mergeOrdered(df1, df2, { on: "t", left_by: "grp", right_by: "grp" });
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "merge_ordered_by",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_merge_ordered_ffill.ts

@@ -0,0 +1,37 @@
+/**
+ * Benchmark: mergeOrdered with fill_method "ffill" — two 5k-row DataFrames with interleaved keys.
+ * Outputs JSON: {"function": "merge_ordered_ffill", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, mergeOrdered } from "../../src/index.ts";
+
+const N = 5_000;
+const WARMUP = 2;
+const ITERATIONS = 8;
+
+// Even-numbered keys on left, multiples-of-3 on right → many gaps filled by ffill
+const keys1 = Array.from({ length: N }, (_, i) => i * 2);
+const vals1 = Array.from({ length: N }, (_, i) => i * 1.0);
+const keys2 = Array.from({ length: N }, (_, i) => i * 3);
+const vals2 = Array.from({ length: N }, (_, i) => i * 2.0);
+
+const df1 = DataFrame.fromColumns({ key: keys1, val1: vals1 });
+const df2 = DataFrame.fromColumns({ key: keys2, val2: vals2 });
+
+for (let i = 0; i < WARMUP; i++) {
+  mergeOrdered(df1, df2, { on: "key", fill_method: "ffill" });
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  mergeOrdered(df1, df2, { on: "key", fill_method: "ffill" });
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "merge_ordered_ffill",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);