[Autoloop: perf-comparison] Iteration 377: add 6 benchmark pairs (iterrows, items, fromRecords, groupby many groups, concat many frames, str replace regex)

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_concat_many_frames.py

@@ -0,0 +1,35 @@
+"""Benchmark: pd.concat() with 20 DataFrames — many-frame concatenation on 100k total rows."""
+import json
+import time
+import pandas as pd
+
+N_FRAMES = 20
+ROWS_EACH = 5_000
+WARMUP = 5
+ITERATIONS = 20
+
+frames = [
+    pd.DataFrame({
+        "a": [float(f * ROWS_EACH + i) for i in range(ROWS_EACH)],
+        "b": [(f * ROWS_EACH + i) % 100 for i in range(ROWS_EACH)],
+        "c": [f"cat_{i % 20}" for i in range(ROWS_EACH)],
+    })
+    for f in range(N_FRAMES)
+]
+
+for _ in range(WARMUP):
+    pd.concat(frames)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    pd.concat(frames)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total = sum(times)
+print(json.dumps({
+    "function": "concat_many_frames",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_dataframe_from_records.py

@@ -0,0 +1,30 @@
+"""Benchmark: DataFrame.from_records() — construct a DataFrame from a list of dicts."""
+import json
+import time
+import pandas as pd
+
+ROWS = 20_000
+WARMUP = 5
+ITERATIONS = 20
+
+records = [
+    {"id": i, "value": i * 1.5, "category": f"cat_{i % 50}", "score": None if i % 2 == 0 else i * 0.1, "rank": i % 100}
+    for i in range(ROWS)
+]
+
+for _ in range(WARMUP):
+    pd.DataFrame.from_records(records)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    pd.DataFrame.from_records(records)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total = sum(times)
+print(json.dumps({
+    "function": "dataframe_from_records",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_dataframe_items.py

@@ -0,0 +1,42 @@
+"""Benchmark: DataFrame.items() / iteritems() — iterate over (columnName, Series) pairs."""
+import json
+import time
+import pandas as pd
+
+ROWS = 50_000
+WARMUP = 5
+ITERATIONS = 50
+
+df = pd.DataFrame({
+    "a": [float(i) for i in range(ROWS)],
+    "b": [i % 500 for i in range(ROWS)],
+    "c": [f"cat_{i % 50}" for i in range(ROWS)],
+    "d": [i * 0.25 for i in range(ROWS)],
+    "e": [None if i % 2 == 0 else i * 1.5 for i in range(ROWS)],
+    "f": [i * 3 for i in range(ROWS)],
+})
+
+for _ in range(WARMUP):
+    n = 0
+    for _name, _col in df.items():
+        n += 1
+    for _name, _col in df.iteritems() if hasattr(df, "iteritems") else df.items():
+        n += 1
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    n = 0
+    for _name, _col in df.items():
+        n += 1
+    for _name, _col in df.iteritems() if hasattr(df, "iteritems") else df.items():
+        n += 1
+    times.append((time.perf_counter() - t0) * 1000)
+
+total = sum(times)
+print(json.dumps({
+    "function": "dataframe_items",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_dataframe_iterrows.py

@@ -0,0 +1,37 @@
+"""Benchmark: DataFrame.iterrows() — iterate over (label, Series) pairs on a 3k-row DataFrame."""
+import json
+import time
+import pandas as pd
+
+ROWS = 3_000
+WARMUP = 5
+ITERATIONS = 30
+
+df = pd.DataFrame({
+    "a": [float(i) for i in range(ROWS)],
+    "b": [i % 100 for i in range(ROWS)],
+    "c": [f"cat_{i % 20}" for i in range(ROWS)],
+    "d": [None if i % 2 == 0 else i * 0.5 for i in range(ROWS)],
+    "e": [i * 2 for i in range(ROWS)],
+})
+
+for _ in range(WARMUP):
+    n = 0
+    for _label, _row in df.iterrows():
+        n += 1
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    n = 0
+    for _label, _row in df.iterrows():
+        n += 1
+    times.append((time.perf_counter() - t0) * 1000)
+
+total = sum(times)
+print(json.dumps({
+    "function": "dataframe_iterrows",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_groupby_sum_many_groups.py

@@ -0,0 +1,32 @@
+"""Benchmark: DataFrame.groupby().sum() with 1000 groups on a 100k-row DataFrame."""
+import json
+import time
+import pandas as pd
+
+ROWS = 100_000
+N_GROUPS = 1_000
+WARMUP = 3
+ITERATIONS = 10
+
+df = pd.DataFrame({
+    "key": [f"g{i % N_GROUPS}" for i in range(ROWS)],
+    "val1": [i * 0.5 for i in range(ROWS)],
+    "val2": [i % 200 for i in range(ROWS)],
+})
+
+for _ in range(WARMUP):
+    df.groupby("key").sum()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.groupby("key").sum()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total = sum(times)
+print(json.dumps({
+    "function": "groupby_sum_many_groups",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_series_str_replace_regex.py

@@ -0,0 +1,28 @@
+"""Benchmark: Series.str.replace() with a regex pattern on 50k strings."""
+import json
+import time
+import pandas as pd
+
+ROWS = 50_000
+WARMUP = 5
+ITERATIONS = 30
+
+data = [f"item_{i % 1000}_val{i % 50}" for i in range(ROWS)]
+s = pd.Series(data)
+
+for _ in range(WARMUP):
+    s.str.replace(r"[0-9]+", "#", regex=True)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.str.replace(r"[0-9]+", "#", regex=True)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total = sum(times)
+print(json.dumps({
+    "function": "series_str_replace_regex",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/tsb/bench_concat_many_frames.ts

@@ -0,0 +1,39 @@
+/**
+ * Benchmark: concat() with 20 DataFrames — many-frame concatenation on 100k total rows.
+ * Outputs JSON: {"function": "concat_many_frames", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, concat } from "../../src/index.ts";
+
+const N_FRAMES = 20;
+const ROWS_EACH = 5_000;
+const WARMUP = 5;
+const ITERATIONS = 20;
+
+const frames = Array.from({ length: N_FRAMES }, (_, f) =>
+  DataFrame.fromColumns({
+    a: Array.from({ length: ROWS_EACH }, (_, i) => (f * ROWS_EACH + i) * 1.0),
+    b: Array.from({ length: ROWS_EACH }, (_, i) => (f * ROWS_EACH + i) % 100),
+    c: Array.from({ length: ROWS_EACH }, (_, i) => `cat_${i % 20}`),
+  }),
+);
+
+for (let i = 0; i < WARMUP; i++) {
+  concat(frames);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  concat(frames);
+  times.push(performance.now() - t0);
+}
+const total = times.reduce((a, b) => a + b, 0);
+
+console.log(
+  JSON.stringify({
+    function: "concat_many_frames",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_dataframe_from_records.ts

@@ -0,0 +1,38 @@
+/**
+ * Benchmark: DataFrame.fromRecords() — construct a DataFrame from an array of record objects.
+ * Outputs JSON: {"function": "dataframe_from_records", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame } from "../../src/index.ts";
+
+const ROWS = 20_000;
+const WARMUP = 5;
+const ITERATIONS = 20;
+
+const records = Array.from({ length: ROWS }, (_, i) => ({
+  id: i,
+  value: i * 1.5,
+  category: `cat_${i % 50}`,
+  score: i % 2 === 0 ? null : i * 0.1,
+  rank: i % 100,
+}));
+
+for (let i = 0; i < WARMUP; i++) {
+  DataFrame.fromRecords(records);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  DataFrame.fromRecords(records);
+  times.push(performance.now() - t0);
+}
+const total = times.reduce((a, b) => a + b, 0);
+
+console.log(
+  JSON.stringify({
+    function: "dataframe_from_records",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_dataframe_items.ts

@@ -0,0 +1,51 @@
+/**
+ * Benchmark: DataFrame.items() / iteritems() — iterate over (columnName, Series) pairs.
+ * Outputs JSON: {"function": "dataframe_items", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame } from "../../src/index.ts";
+
+const ROWS = 50_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const df = DataFrame.fromColumns({
+  a: Array.from({ length: ROWS }, (_, i) => i * 1.0),
+  b: Array.from({ length: ROWS }, (_, i) => i % 500),
+  c: Array.from({ length: ROWS }, (_, i) => `cat_${i % 50}`),
+  d: Array.from({ length: ROWS }, (_, i) => i * 0.25),
+  e: Array.from({ length: ROWS }, (_, i) => i % 2 === 0 ? null : i * 1.5),
+  f: Array.from({ length: ROWS }, (_, i) => i * 3),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  let n = 0;
+  for (const [_name, _col] of df.items()) {
+    n++;
+  }
+  for (const [_name, _col] of df.iteritems()) {
+    n++;
+  }
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  let n = 0;
+  for (const [_name, _col] of df.items()) {
+    n++;
+  }
+  for (const [_name, _col] of df.iteritems()) {
+    n++;
+  }
+  times.push(performance.now() - t0);
+}
+const total = times.reduce((a, b) => a + b, 0);
+
+console.log(
+  JSON.stringify({
+    function: "dataframe_items",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_dataframe_iterrows.ts

@@ -0,0 +1,44 @@
+/**
+ * Benchmark: DataFrame.iterrows() — iterate over (label, rowSeries) pairs on a 3k-row DataFrame.
+ * Outputs JSON: {"function": "dataframe_iterrows", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame } from "../../src/index.ts";
+
+const ROWS = 3_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+const df = DataFrame.fromColumns({
+  a: Array.from({ length: ROWS }, (_, i) => i * 1.0),
+  b: Array.from({ length: ROWS }, (_, i) => i % 100),
+  c: Array.from({ length: ROWS }, (_, i) => `cat_${i % 20}`),
+  d: Array.from({ length: ROWS }, (_, i) => (i % 2 === 0 ? null : i * 0.5)),
+  e: Array.from({ length: ROWS }, (_, i) => i * 2),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  let n = 0;
+  for (const [_label, _row] of df.iterrows()) {
+    n++;
+  }
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const t0 = performance.now();
+  let n = 0;
+  for (const [_label, _row] of df.iterrows()) {
+    n++;
+  }
+  times.push(performance.now() - t0);
+}
+const total = times.reduce((a, b) => a + b, 0);
+
+console.log(
+  JSON.stringify({
+    function: "dataframe_iterrows",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);