Iteration 150: Add 5 benchmark pairs (473 total, +5 vs best 468)

Added benchmarks for: replaceSeries, isnull/notnull aliases, toNumericScalar,
dataFrameAssign (functional API), dataFrameIsin (functional API).

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_dataframe_assign_fn.py

@@ -0,0 +1,30 @@
+"""Benchmark: DataFrame.assign — add new columns using the pandas assign API."""
+import json, time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+df = pd.DataFrame({
+    "a": [i * 1.0 for i in range(SIZE)],
+    "b": [i * 2.0 for i in range(SIZE)],
+})
+
+for _ in range(WARMUP):
+    df.assign(
+        c=[i * 3.0 for i in range(SIZE)],
+        d=lambda working: working["a"] + working["c"],
+    )
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.assign(
+        c=[i * 3.0 for i in range(SIZE)],
+        d=lambda working: working["a"] + working["c"],
+    )
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function": "dataframe_assign_fn", "mean_ms": round(total_ms / ITERATIONS, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_dataframe_isin_fn.py

@@ -0,0 +1,30 @@
+"""Benchmark: DataFrame.isin — test membership of each element against value sets."""
+import json, time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+df = pd.DataFrame({
+    "a": [i % 20 for i in range(SIZE)],
+    "b": [["x", "y", "z", "w"][i % 4] for i in range(SIZE)],
+    "c": [i % 10 for i in range(SIZE)],
+})
+
+global_values = [0, 1, 2, "x", "y"]
+col_values = {"a": [0, 1, 2, 3, 4], "b": ["x", "y"], "c": [0, 5]}
+
+for _ in range(WARMUP):
+    df.isin(global_values)
+    df.isin(col_values)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.isin(global_values)
+    df.isin(col_values)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function": "dataframe_isin_fn", "mean_ms": round(total_ms / ITERATIONS, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_isnull_notnull.py

@@ -0,0 +1,32 @@
+"""Benchmark: isnull / notnull — aliases for isna / notna on Series and DataFrame."""
+import json, time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+s = pd.Series([np.nan if i % 7 == 0 else i * 0.1 for i in range(SIZE)])
+df = pd.DataFrame({
+    "a": [np.nan if i % 5 == 0 else float(i) for i in range(SIZE)],
+    "b": [np.nan if i % 3 == 0 else i * 2.5 for i in range(SIZE)],
+})
+
+for _ in range(WARMUP):
+    pd.isnull(s)
+    pd.notnull(s)
+    pd.isnull(df)
+    pd.notnull(df)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    pd.isnull(s)
+    pd.notnull(s)
+    pd.isnull(df)
+    pd.notnull(df)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function": "isnull_notnull", "mean_ms": round(total_ms / ITERATIONS, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_replace_series.py

@@ -0,0 +1,22 @@
+"""Benchmark: Series.replace — replace values in a Series."""
+import json, time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+s = pd.Series([i % 10 for i in range(SIZE)])
+mapping = {0: 100, 1: 200, 2: 300, 3: 400, 4: 500}
+
+for _ in range(WARMUP):
+    s.replace(mapping)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.replace(mapping)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function": "replace_series", "mean_ms": round(total_ms / ITERATIONS, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/pandas/bench_to_numeric_scalar.py

@@ -0,0 +1,37 @@
+"""Benchmark: pd.to_numeric scalar coercion — convert individual scalar values to numeric."""
+import json, time
+import pandas as pd
+
+WARMUP = 5
+ITERATIONS = 100
+BATCH = 10_000
+
+inputs = []
+for i in range(BATCH):
+    r = i % 6
+    if r == 0:
+        inputs.append(str(i * 1.5))
+    elif r == 1:
+        inputs.append(i)
+    elif r == 2:
+        inputs.append(f"  {i}  ")
+    elif r == 3:
+        inputs.append(True)
+    elif r == 4:
+        inputs.append(None)
+    else:
+        inputs.append(str(i))
+
+for _ in range(WARMUP):
+    for v in inputs:
+        pd.to_numeric(v, errors="coerce")
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    for v in inputs:
+        pd.to_numeric(v, errors="coerce")
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function": "to_numeric_scalar", "mean_ms": round(total_ms / ITERATIONS, 3), "iterations": ITERATIONS, "total_ms": round(total_ms, 3)}))

benchmarks/tsb/bench_dataframe_assign_fn.ts

@@ -0,0 +1,51 @@
+/**
+ * Benchmark: dataFrameAssign — add new columns to a DataFrame using the functional API.
+ * Outputs JSON: {"function": "dataframe_assign_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { dataFrameAssign, DataFrame, Series } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const df = new DataFrame({
+  a: Array.from({ length: SIZE }, (_, i) => i * 1.0),
+  b: Array.from({ length: SIZE }, (_, i) => i * 2.0),
+});
+const colC = new Series({ data: Array.from({ length: SIZE }, (_, i) => i * 3.0), name: "c" });
+
+for (let i = 0; i < WARMUP; i++) {
+  dataFrameAssign(df, {
+    c: colC,
+    d: (working) => {
+      const aVals = working.col("a").values;
+      const cVals = working.col("c").values;
+      return new Series({ data: aVals.map((v, idx) => (v as number) + (cVals[idx] as number)) });
+    },
+  });
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  dataFrameAssign(df, {
+    c: colC,
+    d: (working) => {
+      const aVals = working.col("a").values;
+      const cVals = working.col("c").values;
+      return new Series({ data: aVals.map((v, idx) => (v as number) + (cVals[idx] as number)) });
+    },
+  });
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "dataframe_assign_fn",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);

benchmarks/tsb/bench_dataframe_isin_fn.ts

@@ -0,0 +1,44 @@
+/**
+ * Benchmark: dataFrameIsin — test membership of each element in a DataFrame against value sets.
+ * Outputs JSON: {"function": "dataframe_isin_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { dataFrameIsin, DataFrame } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const df = new DataFrame({
+  a: Array.from({ length: SIZE }, (_, i) => i % 20),
+  b: Array.from({ length: SIZE }, (_, i) => ["x", "y", "z", "w"][i % 4]),
+  c: Array.from({ length: SIZE }, (_, i) => i % 10),
+});
+
+// Global isin — check all columns
+const globalValues = [0, 1, 2, "x", "y"];
+// Per-column isin dict
+const colValues = { a: [0, 1, 2, 3, 4], b: ["x", "y"], c: [0, 5] };
+
+for (let i = 0; i < WARMUP; i++) {
+  dataFrameIsin(df, globalValues);
+  dataFrameIsin(df, colValues);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  dataFrameIsin(df, globalValues);
+  dataFrameIsin(df, colValues);
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "dataframe_isin_fn",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);

benchmarks/tsb/bench_isnull_notnull.ts

@@ -0,0 +1,45 @@
+/**
+ * Benchmark: isnull / notnull — aliases for isna / notna on Series and DataFrame.
+ * Outputs JSON: {"function": "isnull_notnull", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { isnull, notnull, Series, DataFrame } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const s = new Series({
+  data: Array.from({ length: SIZE }, (_, i) => (i % 7 === 0 ? null : i * 0.1)),
+});
+const df = new DataFrame({
+  a: Array.from({ length: SIZE }, (_, i) => (i % 5 === 0 ? null : i)),
+  b: Array.from({ length: SIZE }, (_, i) => (i % 3 === 0 ? null : i * 2.5)),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  isnull(s);
+  notnull(s);
+  isnull(df);
+  notnull(df);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  isnull(s);
+  notnull(s);
+  isnull(df);
+  notnull(df);
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "isnull_notnull",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);

benchmarks/tsb/bench_replace_series.ts

@@ -0,0 +1,40 @@
+/**
+ * Benchmark: replaceSeries — replace values in a Series.
+ * Outputs JSON: {"function": "replace_series", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { replaceSeries, Series } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const s = new Series({ data: Array.from({ length: SIZE }, (_, i) => i % 10) });
+const mapping = new Map<number, number>([
+  [0, 100],
+  [1, 200],
+  [2, 300],
+  [3, 400],
+  [4, 500],
+]);
+
+for (let i = 0; i < WARMUP; i++) {
+  replaceSeries(s, mapping);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  replaceSeries(s, mapping);
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "replace_series",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);

benchmarks/tsb/bench_to_numeric_scalar.ts

@@ -0,0 +1,41 @@
+/**
+ * Benchmark: toNumericScalar — coerce individual scalars to numeric values.
+ * Outputs JSON: {"function": "to_numeric_scalar", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { toNumericScalar } from "../../src/index.ts";
+
+const WARMUP = 5;
+const ITERATIONS = 100;
+const BATCH = 10_000;
+
+const inputs: unknown[] = Array.from({ length: BATCH }, (_, i) => {
+  const r = i % 6;
+  if (r === 0) return String(i * 1.5);
+  if (r === 1) return i;
+  if (r === 2) return `  ${i}  `;
+  if (r === 3) return true;
+  if (r === 4) return null;
+  return String(i);
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  for (const v of inputs) toNumericScalar(v, { errors: "coerce" });
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  for (const v of inputs) toNumericScalar(v, { errors: "coerce" });
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "to_numeric_scalar",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);