Iteration 138: Add 8 benchmark pairs (412 total, +8 vs 404)

Added benchmarks for:
- series_ceil_floor_trunc_sqrt: seriesCeil/seriesFloor/seriesTrunc/seriesSqrt vs numpy
- dataframe_ceil_floor_trunc: dataFrameCeil/Floor/Trunc/Sqrt vs numpy on DataFrame
- dataframe_exp_log: dataFrameExp/Log/Log2/Log10 vs numpy on DataFrame
- pivot_table_full: pivotTableFull (with margins) vs pd.pivot_table
- read_excel: readExcel/xlsxSheetNames with 10k-row XLSX vs pd.read_excel/openpyxl
- pipe_chain_ops: pipeChain/pipeTo/dataFramePipeChain/dataFramePipeTo vs .pipe()
- nan_extended_agg: nancount/nanmedian/nanprod vs Series.count/median/prod
- series_pipe_apply: pipeSeries/dataFramePipe vs Series.pipe/DataFrame.pipe

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_dataframe_ceil_floor_trunc.py

@@ -0,0 +1,38 @@
+"""
+Benchmark: DataFrame ceil / floor / trunc / sqrt — math rounding on 100k-row DataFrame.
+Outputs JSON: {"function": "dataframe_ceil_floor_trunc", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+ROWS = 100_000
+WARMUP = 5
+ITERATIONS = 30
+
+df = pd.DataFrame({
+    "a": (np.arange(ROWS) % 1000) * 0.7 + 0.3,
+    "b": (np.arange(ROWS) % 500) * 1.3 + 0.1,
+})
+
+for _ in range(WARMUP):
+    np.ceil(df)
+    np.floor(df)
+    np.trunc(df)
+    np.sqrt(df)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    np.ceil(df)
+    np.floor(df)
+    np.trunc(df)
+    np.sqrt(df)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "dataframe_ceil_floor_trunc",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_dataframe_exp_log.py

@@ -0,0 +1,38 @@
+"""
+Benchmark: DataFrame exp / log / log2 / log10 — exponentiation/log on 100k-row DataFrame.
+Outputs JSON: {"function": "dataframe_exp_log", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+ROWS = 100_000
+WARMUP = 5
+ITERATIONS = 30
+
+df = pd.DataFrame({
+    "a": (np.arange(ROWS) % 1000) + 1,
+    "b": (np.arange(ROWS) % 500) + 1,
+})
+
+for _ in range(WARMUP):
+    np.exp(df)
+    np.log(df)
+    np.log2(df)
+    np.log10(df)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    np.exp(df)
+    np.log(df)
+    np.log2(df)
+    np.log10(df)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "dataframe_exp_log",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_nan_extended_agg.py

@@ -0,0 +1,39 @@
+"""
+Benchmark: count/median/prod nan-ignoring aggregates on 100k-element array.
+Outputs JSON: {"function": "nan_extended_agg", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+# Array with ~10% NaN values; small values to avoid prod overflow
+data = np.where(
+    np.arange(SIZE) % 10 == 0,
+    np.nan,
+    (np.arange(SIZE) % 100) * 0.01 + 1,
+)
+s = pd.Series(data)
+
+for _ in range(WARMUP):
+    s.count()
+    s.median(skipna=True)
+    s.prod(skipna=True)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    s.count()
+    s.median(skipna=True)
+    s.prod(skipna=True)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "nan_extended_agg",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_pipe_chain_ops.py

@@ -0,0 +1,46 @@
+"""
+Benchmark: pipe chaining utilities — pipeChain / pipeTo / dataFramePipeChain / dataFramePipeTo.
+Outputs JSON: {"function": "pipe_chain_ops", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+s = pd.Series(np.arange(SIZE) * 0.5 - SIZE * 0.25)
+df = pd.DataFrame({
+    "a": np.arange(SIZE) * 0.5,
+    "b": np.arange(SIZE) * 0.3 + 1,
+})
+
+def double(x): return x * 2
+def add_one(x): return x + 1
+def abs_val(x): return x.abs()
+
+# pandas equivalent of pipeChain: .pipe(fn1).pipe(fn2).pipe(fn3)
+# pandas equivalent of pipeTo: .pipe(fn, *args) with positional arg
+
+for _ in range(WARMUP):
+    s.pipe(double).pipe(add_one).pipe(abs_val)
+    s.pipe(abs_val)
+    df.pipe(double).pipe(abs_val)
+    df.pipe(abs_val)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    s.pipe(double).pipe(add_one).pipe(abs_val)
+    s.pipe(abs_val)
+    df.pipe(double).pipe(abs_val)
+    df.pipe(abs_val)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "pipe_chain_ops",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_pivot_table_full.py

@@ -0,0 +1,36 @@
+"""
+Benchmark: pivot_table with margins on 50k-row DataFrame.
+Outputs JSON: {"function": "pivot_table_full", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+ROWS = 50_000
+WARMUP = 3
+ITERATIONS = 20
+
+regions = ["North", "South", "East", "West"]
+products = ["A", "B", "C", "D", "E"]
+
+df = pd.DataFrame({
+    "region": [regions[i % len(regions)] for i in range(ROWS)],
+    "product": [products[i % len(products)] for i in range(ROWS)],
+    "sales": (np.arange(ROWS) % 1000) * 1.5 + 10,
+})
+
+for _ in range(WARMUP):
+    pd.pivot_table(df, values="sales", index="region", columns="product", aggfunc="mean", margins=True)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    pd.pivot_table(df, values="sales", index="region", columns="product", aggfunc="mean", margins=True)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "pivot_table_full",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_read_excel.py

@@ -0,0 +1,49 @@
+"""
+Benchmark: pd.read_excel / ExcelFile.sheet_names — parse a 10k-row XLSX file.
+Outputs JSON: {"function": "read_excel", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import io
+import numpy as np
+import pandas as pd
+
+try:
+    import openpyxl
+except ImportError:
+    import subprocess, sys
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "openpyxl", "--quiet"])
+    import openpyxl
+
+ROWS = 10_000
+WARMUP = 3
+ITERATIONS = 10
+
+# Build an XLSX file in memory using openpyxl
+wb = openpyxl.Workbook()
+ws = wb.active
+ws.title = "Sheet1"
+ws.append(["id", "name", "value", "score"])
+for i in range(ROWS):
+    ws.append([i, f"item_{i % 100}", i * 1.5, float(np.sin(i * 0.01))])
+
+buf = io.BytesIO()
+wb.save(buf)
+xlsx_bytes = buf.getvalue()
+
+for _ in range(WARMUP):
+    pd.read_excel(io.BytesIO(xlsx_bytes), engine="openpyxl")
+    pd.ExcelFile(io.BytesIO(xlsx_bytes), engine="openpyxl").sheet_names
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    pd.read_excel(io.BytesIO(xlsx_bytes), engine="openpyxl")
+    pd.ExcelFile(io.BytesIO(xlsx_bytes), engine="openpyxl").sheet_names
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "read_excel",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_series_ceil_floor_trunc_sqrt.py

@@ -0,0 +1,35 @@
+"""
+Benchmark: Series ceil / floor / trunc / sqrt — math rounding on 100k-element Series.
+Outputs JSON: {"function": "series_ceil_floor_trunc_sqrt", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+s = pd.Series((np.arange(SIZE) % 1000) * 0.7 + 0.3)
+
+for _ in range(WARMUP):
+    np.ceil(s)
+    np.floor(s)
+    np.trunc(s)
+    np.sqrt(s)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    np.ceil(s)
+    np.floor(s)
+    np.trunc(s)
+    np.sqrt(s)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "series_ceil_floor_trunc_sqrt",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_series_pipe_apply.py

@@ -0,0 +1,38 @@
+"""
+Benchmark: Series.pipe / DataFrame.pipe — pipe function application utilities.
+Outputs JSON: {"function": "series_pipe_apply", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+s = pd.Series(np.arange(SIZE) * 0.5 - SIZE * 0.25)
+df = pd.DataFrame({
+    "a": np.arange(SIZE) * 0.5,
+    "b": np.arange(SIZE) * 0.3 + 1,
+})
+
+def abs_and_double(x):
+    return x.abs() * 2
+
+for _ in range(WARMUP):
+    s.pipe(abs_and_double)
+    df.pipe(abs_and_double)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    s.pipe(abs_and_double)
+    df.pipe(abs_and_double)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "series_pipe_apply",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/tsb/bench_dataframe_ceil_floor_trunc.ts

@@ -0,0 +1,38 @@
+/**
+ * Benchmark: dataFrameCeil / dataFrameFloor / dataFrameTrunc / dataFrameSqrt — math rounding on 100k-row DataFrame.
+ * Outputs JSON: {"function": "dataframe_ceil_floor_trunc", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, dataFrameCeil, dataFrameFloor, dataFrameTrunc, dataFrameSqrt } from "../../src/index.ts";
+
+const ROWS = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+const a = Array.from({ length: ROWS }, (_, i) => (i % 1000) * 0.7 + 0.3);
+const b = Array.from({ length: ROWS }, (_, i) => (i % 500) * 1.3 + 0.1);
+const df = DataFrame.fromColumns({ a, b });
+
+for (let i = 0; i < WARMUP; i++) {
+  dataFrameCeil(df);
+  dataFrameFloor(df);
+  dataFrameTrunc(df);
+  dataFrameSqrt(df);
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  dataFrameCeil(df);
+  dataFrameFloor(df);
+  dataFrameTrunc(df);
+  dataFrameSqrt(df);
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "dataframe_ceil_floor_trunc",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);