Iteration 261: 7 more benchmark pairs (621 total)

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_format_ops_fn.py

@@ -0,0 +1,47 @@
+"""Benchmark: number formatting operations (float, percent, scientific, etc.).
+Mirrors tsb bench_format_ops_fn.ts using Python format functions.
+"""
+import json, time
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 50
+
+values = [i * 1234.567 + 0.001 for i in range(SIZE)]
+
+def fmt_float(v, decimals=6): return f"{v:.{decimals}f}"
+def fmt_percent(v, decimals=2): return f"{v:.{decimals}%}"
+def fmt_scientific(v, decimals=6): return f"{v:.{decimals}e}"
+def fmt_engineering(v): return f"{v:.6g}"
+def fmt_thousands(v): return f"{v:,.2f}"
+def fmt_currency(v): return f"${v:,.2f}"
+def fmt_compact(v):
+    if abs(v) >= 1e9: return f"{v/1e9:.1f}B"
+    if abs(v) >= 1e6: return f"{v/1e6:.1f}M"
+    if abs(v) >= 1e3: return f"{v/1e3:.1f}K"
+    return f"{v:.1f}"
+
+for _ in range(WARMUP):
+    for v in values[:100]:
+        fmt_float(v, 2)
+        fmt_percent(v / 100_000, 1)
+        fmt_scientific(v, 3)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    for v in values:
+        fmt_float(v, 2)
+        fmt_percent(v / 100_000, 1)
+        fmt_scientific(v, 3)
+        fmt_engineering(v)
+        fmt_thousands(v)
+        fmt_currency(v)
+        fmt_compact(v)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "format_ops_fn",
+    "mean_ms": round(total / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total, 3),
+}))

benchmarks/pandas/bench_formatter_factories_fn.py

@@ -0,0 +1,46 @@
+"""Benchmark: formatter factory functions — make formatters and apply to series/dataframe.
+Mirrors tsb bench_formatter_factories_fn.ts using pandas styling/format.
+"""
+import json, time
+import pandas as pd
+import numpy as np
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 50
+
+ser = pd.Series(np.arange(SIZE) * 1.23456)
+df = pd.DataFrame({
+    "price": np.arange(SIZE) * 9.99,
+    "pct": (np.arange(SIZE) % 100) / 100,
+})
+
+def fmt_float(decimals): return lambda v: f"{v:.{decimals}f}"
+def fmt_pct(decimals): return lambda v: f"{v:.{decimals}%}"
+def fmt_cur(symbol, decimals): return lambda v: f"{symbol}{v:,.{decimals}f}"
+
+for _ in range(WARMUP):
+    ff = fmt_float(2)
+    ser.map(ff)
+    fc = fmt_cur("$", 2)
+    fp = fmt_pct(1)
+    df.apply(lambda col: col.map(fc if col.name == "price" else fp))
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    fmt_float(3)
+    fmt_pct(2)
+    fmt_cur("€", 2)
+    ff = fmt_float(2)
+    fc = fmt_cur("$", 2)
+    fp = fmt_pct(1)
+    ser.map(ff)
+    df.apply(lambda col: col.map(fc if col.name == "price" else fp))
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "formatter_factories_fn",
+    "mean_ms": round(total / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total, 3),
+}))

benchmarks/pandas/bench_nunique_standalone_fn.py

@@ -0,0 +1,35 @@
+"""Benchmark: nunique standalone — count unique values in DataFrame with DataFrame.nunique().
+Mirrors tsb bench_nunique_standalone_fn.ts.
+"""
+import json, time
+import pandas as pd
+import numpy as np
+
+ROWS = 50_000
+WARMUP = 5
+ITERATIONS = 30
+
+df = pd.DataFrame({
+    "a": np.arange(ROWS) % 1_000,
+    "b": [f"cat_{i % 200}" for i in range(ROWS)],
+    "c": np.arange(ROWS) % 50,
+    "d": [float(i % 100) if i % 5 != 0 else np.nan for i in range(ROWS)],
+})
+
+for _ in range(WARMUP):
+    df.nunique()
+    df.nunique(axis=1)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    df.nunique()
+    df.nunique(dropna=False)
+    df.nunique(axis=1)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "nunique_standalone_fn",
+    "mean_ms": round(total / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total, 3),
+}))

benchmarks/pandas/bench_series_dataframe_to_string.py

@@ -0,0 +1,37 @@
+"""Benchmark: Series + DataFrame string representations using pandas .to_string().
+Mirrors tsb bench_series_dataframe_to_string.ts.
+"""
+import json, time
+import pandas as pd
+import numpy as np
+
+ROWS = 1_000
+WARMUP = 5
+ITERATIONS = 100
+
+ser = pd.Series(np.arange(ROWS) * 3.14159, name="values")
+df = pd.DataFrame({
+    "a": np.arange(ROWS) * 1.5,
+    "b": [f"cat_{i % 20}" for i in range(ROWS)],
+    "c": np.arange(ROWS) % 100,
+})
+
+for _ in range(WARMUP):
+    ser.to_string()
+    ser.head(10).to_string()
+    df.to_string(max_rows=20)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    ser.to_string()
+    ser.head(10).to_string()
+    df.to_string()
+    df.to_string(max_rows=20)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "series_dataframe_to_string",
+    "mean_ms": round(total / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total, 3),
+}))

benchmarks/pandas/bench_series_groupby_getgroup_fn.py

@@ -0,0 +1,35 @@
+"""Benchmark: SeriesGroupBy get_group — retrieve specific groups by key.
+Mirrors tsb bench_series_groupby_getgroup_fn.ts using pandas SeriesGroupBy.
+"""
+import json, time
+import pandas as pd
+import numpy as np
+
+ROWS = 100_000
+N_GROUPS = 50
+WARMUP = 5
+ITERATIONS = 100
+
+keys = [f"group_{i % N_GROUPS}" for i in range(ROWS)]
+values = np.arange(ROWS) * 1.5
+ser = pd.Series(values)
+sgb = ser.groupby(keys)
+
+group_keys = [f"group_{i}" for i in range(N_GROUPS)]
+
+for _ in range(WARMUP):
+    for k in group_keys:
+        sgb.get_group(k)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    for k in group_keys:
+        sgb.get_group(k)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "series_groupby_getgroup_fn",
+    "mean_ms": round(total / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total, 3),
+}))

benchmarks/pandas/bench_timestamp_tz_ops.py

@@ -0,0 +1,34 @@
+"""Benchmark: Timestamp tz_localize + tz_convert — timezone ops on individual Timestamps.
+Mirrors tsb bench_timestamp_tz_ops.ts using pandas Timestamp.
+"""
+import json, time
+import pandas as pd
+
+SIZE = 5_000
+WARMUP = 5
+ITERATIONS = 50
+
+timestamps = [
+    pd.Timestamp(year=2020, month=1 + (i % 12), day=1 + (i % 28), hour=i % 24, minute=i % 60, second=0)
+    for i in range(SIZE)
+]
+
+for _ in range(WARMUP):
+    for ts in timestamps[:100]:
+        ts_utc = ts.tz_localize("UTC")
+        ts_utc.tz_convert("America/New_York")
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    for ts in timestamps:
+        ts_utc = ts.tz_localize("UTC")
+        ts_ny = ts_utc.tz_convert("America/New_York")
+        ts_ny.tz_convert("Europe/London")
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "timestamp_tz_ops",
+    "mean_ms": round(total / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total, 3),
+}))

benchmarks/pandas/bench_to_date_input_fn.py

@@ -0,0 +1,38 @@
+"""Benchmark: toDateInput — normalize various date inputs using pandas Timestamp.
+Mirrors tsb bench_to_date_input_fn.ts.
+"""
+import json, time
+import pandas as pd
+
+SIZE = 50_000
+WARMUP = 5
+ITERATIONS = 50
+
+strings = [f"2020-{1 + (i % 12):02d}-01" for i in range(SIZE)]
+timestamps = [int((pd.Timestamp("2020-01-01").timestamp() + i * 86400) * 1000) for i in range(SIZE)]
+dates = [pd.Timestamp(2020, 1 + (i % 12), 1 + (i % 28)) for i in range(SIZE)]
+
+for _ in range(WARMUP):
+    for s in strings[:100]:
+        pd.Timestamp(s)
+    for t in timestamps[:100]:
+        pd.Timestamp(t, unit="ms")
+    for d in dates[:100]:
+        pd.Timestamp(d)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    for s in strings:
+        pd.Timestamp(s)
+    for t in timestamps:
+        pd.Timestamp(t, unit="ms")
+    for d in dates:
+        pd.Timestamp(d)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "to_date_input_fn",
+    "mean_ms": round(total / ITERATIONS, 3),
+    "iterations": ITERATIONS,
+    "total_ms": round(total, 3),
+}))

benchmarks/tsb/bench_format_ops_fn.ts

@@ -0,0 +1,51 @@
+/**
+ * Benchmark: dataFrameToString + seriesToString with float formatting options.
+ * Outputs JSON: {"function": "format_ops_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import {
+  Series,
+  formatFloat,
+  formatPercent,
+  formatScientific,
+  formatEngineering,
+  formatThousands,
+  formatCurrency,
+  formatCompact,
+} from "../../src/index.ts";
+
+const SIZE = 10_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const values = Array.from({ length: SIZE }, (_, i) => i * 1234.567 + 0.001);
+
+for (let i = 0; i < WARMUP; i++) {
+  for (const v of values.slice(0, 100)) {
+    formatFloat(v);
+    formatPercent(v / 100_000);
+    formatScientific(v);
+  }
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  for (const v of values) {
+    formatFloat(v, 2);
+    formatPercent(v / 100_000, 1);
+    formatScientific(v, 3);
+    formatEngineering(v);
+    formatThousands(v);
+    formatCurrency(v);
+    formatCompact(v);
+  }
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "format_ops_fn",
+    mean_ms: Math.round((total / ITERATIONS) * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(total * 1000) / 1000,
+  }),
+);

benchmarks/tsb/bench_formatter_factories_fn.ts

@@ -0,0 +1,51 @@
+/**
+ * Benchmark: makeFloatFormatter + makePercentFormatter + makeCurrencyFormatter — formatter factories.
+ * Outputs JSON: {"function": "formatter_factories_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import {
+  Series,
+  makeFloatFormatter,
+  makePercentFormatter,
+  makeCurrencyFormatter,
+  applySeriesFormatter,
+  applyDataFrameFormatter,
+  DataFrame,
+} from "../../src/index.ts";
+
+const SIZE = 10_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const ser = new Series(Array.from({ length: SIZE }, (_, i) => i * 1.23456));
+const df = DataFrame.fromColumns({
+  price: Array.from({ length: SIZE }, (_, i) => i * 9.99),
+  pct: Array.from({ length: SIZE }, (_, i) => (i % 100) / 100),
+});
+
+const fmtFloat = makeFloatFormatter(2);
+const fmtPct = makePercentFormatter(1);
+const fmtCur = makeCurrencyFormatter("$", 2);
+
+for (let i = 0; i < WARMUP; i++) {
+  applySeriesFormatter(ser, fmtFloat);
+  applyDataFrameFormatter(df, { price: fmtCur, pct: fmtPct });
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  makeFloatFormatter(3);
+  makePercentFormatter(2);
+  makeCurrencyFormatter("€", 2);
+  applySeriesFormatter(ser, fmtFloat);
+  applyDataFrameFormatter(df, { price: fmtCur, pct: fmtPct });
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "formatter_factories_fn",
+    mean_ms: Math.round((total / ITERATIONS) * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(total * 1000) / 1000,
+  }),
+);