[Autoloop: perf-comparison] Iteration 342: Add 2 benchmark pairs (to_json_denormalize, cut_bins_to_frame)

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_cut_bins_to_frame.py

@@ -0,0 +1,56 @@
+"""Benchmark: cut_bins_to_frame — pd.cut with value_counts and bin summary on 100k rows."""
+import json, time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+NUM_BINS = 20
+WARMUP = 5
+ITERATIONS = 50
+
+data = np.array([(i % 1000) * 0.1 for i in range(SIZE)])
+
+for _ in range(WARMUP):
+    # pandas equivalent of cutBinsToFrame: cut + value_counts on the categorical result
+    cut_result = pd.cut(data, NUM_BINS)
+    # Summary DataFrame equivalent to cutBinsToFrame
+    counts = cut_result.value_counts(sort=False)
+    summary = pd.DataFrame({
+        "bin": counts.index.astype(str),
+        "left": [iv.left for iv in counts.index],
+        "right": [iv.right for iv in counts.index],
+        "count": counts.values,
+        "frequency": counts.values / len(data),
+    })
+    # cutBinCounts equivalent: counts dict
+    count_dict = dict(zip(counts.index.astype(str), counts.values))
+    # binEdges equivalent: DataFrame of interval edges
+    edges = pd.DataFrame({
+        "left": [iv.left for iv in counts.index],
+        "right": [iv.right for iv in counts.index],
+    })
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    cut_result = pd.cut(data, NUM_BINS)
+    counts = cut_result.value_counts(sort=False)
+    summary = pd.DataFrame({
+        "bin": counts.index.astype(str),
+        "left": [iv.left for iv in counts.index],
+        "right": [iv.right for iv in counts.index],
+        "count": counts.values,
+        "frequency": counts.values / len(data),
+    })
+    count_dict = dict(zip(counts.index.astype(str), counts.values))
+    edges = pd.DataFrame({
+        "left": [iv.left for iv in counts.index],
+        "right": [iv.right for iv in counts.index],
+    })
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "cut_bins_to_frame",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_to_json_denormalize.py

@@ -0,0 +1,41 @@
+"""Benchmark: to_json_denormalize — json orient variants on 10k-row DataFrame."""
+import json, time
+import numpy as np
+import pandas as pd
+
+ROWS = 10_000
+WARMUP = 5
+ITERATIONS = 30
+
+# DataFrame matching the tsb benchmark (nested-structure-like columns)
+df = pd.DataFrame({
+    "name": [f"user_{i}" for i in range(ROWS)],
+    "address.city": [f"city_{i % 100}" for i in range(ROWS)],
+    "address.zip": [str(10000 + (i % 9000)) for i in range(ROWS)],
+    "score": np.arange(ROWS) * 0.01,
+})
+
+for _ in range(WARMUP):
+    # pandas equivalent of toJsonDenormalize: to_dict("records") then reconstruct nesting
+    recs = df.to_dict("records")
+    # pandas equivalent of toJsonRecords: orient="records"
+    df.to_json(orient="records")
+    # pandas equivalent of toJsonSplit: orient="split"
+    df.to_json(orient="split")
+    # pandas equivalent of toJsonIndex: orient="index"
+    df.to_json(orient="index")
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    recs = df.to_dict("records")
+    df.to_json(orient="records")
+    df.to_json(orient="split")
+    df.to_json(orient="index")
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "to_json_denormalize",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/tsb/bench_cut_bins_to_frame.ts

@@ -0,0 +1,36 @@
+/**
+ * Benchmark: cut_bins_to_frame — cutBinsToFrame / cutBinCounts / binEdges on 100k data points.
+ * Outputs JSON: {"function": "cut_bins_to_frame", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { cut, cutBinsToFrame, cutBinCounts, binEdges } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const NUM_BINS = 20;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const data = Array.from({ length: SIZE }, (_, i) => (i % 1000) * 0.1);
+const binResult = cut(data, NUM_BINS);
+
+for (let i = 0; i < WARMUP; i++) {
+  cutBinsToFrame(binResult, { data });
+  cutBinCounts(binResult);
+  binEdges(binResult);
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  cutBinsToFrame(binResult, { data });
+  cutBinCounts(binResult);
+  binEdges(binResult);
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "cut_bins_to_frame",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_to_json_denormalize.ts

@@ -0,0 +1,42 @@
+/**
+ * Benchmark: to_json_denormalize — toJsonDenormalize / toJsonRecords / toJsonSplit / toJsonIndex
+ * Outputs JSON: {"function": "to_json_denormalize", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, toJsonDenormalize, toJsonRecords, toJsonSplit, toJsonIndex } from "../../src/index.ts";
+
+const ROWS = 10_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+// Create a nested-structure-like DataFrame (address.city, address.zip pattern)
+const df = DataFrame.fromColumns({
+  "name": Array.from({ length: ROWS }, (_, i) => `user_${i}`),
+  "address.city": Array.from({ length: ROWS }, (_, i) => `city_${i % 100}`),
+  "address.zip": Array.from({ length: ROWS }, (_, i) => `${10000 + (i % 9000)}`),
+  "score": Float64Array.from({ length: ROWS }, (_, i) => i * 0.01),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  toJsonDenormalize(df);
+  toJsonRecords(df);
+  toJsonSplit(df);
+  toJsonIndex(df);
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  toJsonDenormalize(df);
+  toJsonRecords(df);
+  toJsonSplit(df);
+  toJsonIndex(df);
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "to_json_denormalize",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);