[Autoloop: perf-comparison]

benchmarks/pandas/bench_wasm_agg_ops.py

@@ -0,0 +1,51 @@
+"""
+Benchmark: numpy aggregate operations — np.sum, np.mean, np.min, np.max, np.var, np.std, np.median
+plus pandas rolling and expanding window ops on a 100k-element float64 array.
+
+Mirrors tsb bench_wasm_agg_ops.ts.
+
+Outputs JSON: {"function": "wasm_agg_ops", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WINDOW = 50
+MIN_PERIODS = 1
+WARMUP = 3
+ITERATIONS = 20
+
+data = np.sin(np.arange(SIZE) * 0.001) * 1000
+series = pd.Series(data)
+
+
+def run():
+    np.sum(data)
+    np.mean(data)
+    np.min(data)
+    np.max(data)
+    np.var(data, ddof=1)
+    np.std(data, ddof=1)
+    np.median(data)
+    series.rolling(window=WINDOW, min_periods=MIN_PERIODS).sum()
+    series.rolling(window=WINDOW, min_periods=MIN_PERIODS).mean()
+    series.expanding(min_periods=MIN_PERIODS).sum()
+    series.expanding(min_periods=MIN_PERIODS).mean()
+
+
+for _ in range(WARMUP):
+    run()
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    run()
+total = (time.perf_counter() - start) * 1000  # ms
+
+print(json.dumps({
+    "function": "wasm_agg_ops",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_wasm_rolling_stats.py

@@ -0,0 +1,64 @@
+"""
+Benchmark: WASM rolling/expanding stats equivalents using pandas/numpy —
+Series.rolling(50).min/max/var/std/median and Series.expanding().min/max/var/std/median
+on a 100k-element float64 array.
+
+Mirrors bench_wasm_rolling_stats.ts
+
+Outputs JSON: {"function": "wasm_rolling_stats", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+
+import json
+import math
+import time
+
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WINDOW = 50
+MIN_PERIODS = 1
+WARMUP = 3
+ITERATIONS = 20
+
+# Deterministic float64 data (same as TS counterpart)
+data = np.array(
+    [math.sin(i * 0.001) * 100 + math.cos(i * 0.003) * 50 for i in range(SIZE)],
+    dtype=np.float64,
+)
+s = pd.Series(data)
+
+
+def run_once() -> None:
+    s.rolling(WINDOW, min_periods=MIN_PERIODS).min()
+    s.rolling(WINDOW, min_periods=MIN_PERIODS).max()
+    s.rolling(WINDOW, min_periods=MIN_PERIODS).var()
+    s.rolling(WINDOW, min_periods=MIN_PERIODS).std()
+    s.rolling(WINDOW, min_periods=MIN_PERIODS).median()
+    s.expanding(min_periods=MIN_PERIODS).min()
+    s.expanding(min_periods=MIN_PERIODS).max()
+    s.expanding(min_periods=MIN_PERIODS).var()
+    s.expanding(min_periods=MIN_PERIODS).std()
+    s.expanding(min_periods=MIN_PERIODS).median()
+
+
+# Warm-up
+for _ in range(WARMUP):
+    run_once()
+
+# Measured iterations
+t0 = time.perf_counter()
+for _ in range(ITERATIONS):
+    run_once()
+total_ms = (time.perf_counter() - t0) * 1000
+
+print(
+    json.dumps(
+        {
+            "function": "wasm_rolling_stats",
+            "mean_ms": total_ms / ITERATIONS,
+            "iterations": ITERATIONS,
+            "total_ms": total_ms,
+        }
+    )
+)

benchmarks/tsb/bench_wasm_agg_ops.ts

@@ -0,0 +1,60 @@
+/**
+ * Benchmark: WASM-accelerated aggregate operations — sumF64Accelerated, meanF64Accelerated,
+ * minF64Accelerated, maxF64Accelerated, varF64Accelerated, stdF64Accelerated, medianF64Accelerated
+ * plus rolling and expanding variants on a 100k-element float64 array.
+ *
+ * Mirrors numpy aggregate functions (np.sum, np.mean, np.min, np.max, np.var, np.std, np.median)
+ * and pandas rolling/expanding window ops.
+ *
+ * Outputs JSON: {"function": "wasm_agg_ops", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import {
+  sumF64Accelerated,
+  meanF64Accelerated,
+  minF64Accelerated,
+  maxF64Accelerated,
+  varF64Accelerated,
+  stdF64Accelerated,
+  medianF64Accelerated,
+  rollingSumF64Accelerated,
+  rollingMeanF64Accelerated,
+  expandingSumF64Accelerated,
+  expandingMeanF64Accelerated,
+} from "../../src/wasm/index.ts";
+
+const SIZE = 100_000;
+const WINDOW = 50;
+const MIN_PERIODS = 1;
+const WARMUP = 3;
+const ITERATIONS = 20;
+
+const data: number[] = Array.from({ length: SIZE }, (_, i) => Math.sin(i * 0.001) * 1000);
+
+function run(): void {
+  sumF64Accelerated(data);
+  meanF64Accelerated(data);
+  minF64Accelerated(data);
+  maxF64Accelerated(data);
+  varF64Accelerated(data);
+  stdF64Accelerated(data);
+  medianF64Accelerated(data);
+  rollingSumF64Accelerated(data, WINDOW, MIN_PERIODS);
+  rollingMeanF64Accelerated(data, WINDOW, MIN_PERIODS);
+  expandingSumF64Accelerated(data, MIN_PERIODS);
+  expandingMeanF64Accelerated(data, MIN_PERIODS);
+}
+
+for (let i = 0; i < WARMUP; i++) run();
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) run();
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "wasm_agg_ops",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_wasm_rolling_stats.ts

@@ -0,0 +1,66 @@
+/**
+ * Benchmark: WASM-accelerated rolling and expanding statistics —
+ * rollingMinF64Accelerated, rollingMaxF64Accelerated, rollingVarF64Accelerated,
+ * rollingStdF64Accelerated, rollingMedianF64Accelerated,
+ * expandingMinF64Accelerated, expandingMaxF64Accelerated,
+ * expandingVarF64Accelerated, expandingStdF64Accelerated,
+ * expandingMedianF64Accelerated on a 100k-element float64 array.
+ *
+ * Mirrors pandas Series.rolling() and Series.expanding() with min/max/var/std/median.
+ *
+ * Outputs JSON: {"function": "wasm_rolling_stats", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import {
+  rollingMinF64Accelerated,
+  rollingMaxF64Accelerated,
+  rollingVarF64Accelerated,
+  rollingStdF64Accelerated,
+  rollingMedianF64Accelerated,
+  expandingMinF64Accelerated,
+  expandingMaxF64Accelerated,
+  expandingVarF64Accelerated,
+  expandingStdF64Accelerated,
+  expandingMedianF64Accelerated,
+} from "../../src/wasm/index.ts";
+
+const SIZE = 100_000;
+const WINDOW = 50;
+const MIN_PERIODS = 1;
+const WARMUP = 3;
+const ITERATIONS = 20;
+
+// Deterministic float64 data
+const data = new Float64Array(SIZE);
+for (let i = 0; i < SIZE; i++) {
+  data[i] = Math.sin(i * 0.001) * 100 + Math.cos(i * 0.003) * 50;
+}
+
+function runOnce(): void {
+  rollingMinF64Accelerated(data, WINDOW, MIN_PERIODS);
+  rollingMaxF64Accelerated(data, WINDOW, MIN_PERIODS);
+  rollingVarF64Accelerated(data, WINDOW, MIN_PERIODS);
+  rollingStdF64Accelerated(data, WINDOW, MIN_PERIODS);
+  rollingMedianF64Accelerated(data, WINDOW, MIN_PERIODS);
+  expandingMinF64Accelerated(data, MIN_PERIODS);
+  expandingMaxF64Accelerated(data, MIN_PERIODS);
+  expandingVarF64Accelerated(data, MIN_PERIODS);
+  expandingStdF64Accelerated(data, MIN_PERIODS);
+  expandingMedianF64Accelerated(data, MIN_PERIODS);
+}
+
+// Warm-up
+for (let i = 0; i < WARMUP; i++) runOnce();
+
+// Measured iterations
+const t0 = performance.now();
+for (let i = 0; i < ITERATIONS; i++) runOnce();
+const total_ms = performance.now() - t0;
+
+console.log(
+  JSON.stringify({
+    function: "wasm_rolling_stats",
+    mean_ms: total_ms / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms,
+  }),
+);