Iteration 165: 5 new benchmark pairs (513 total, +5 vs branch 508)

Added benchmark pairs for:
- series_set_reset_index: Series.setIndex() and Series.resetIndex()
- melt_id_vars: melt() with id_vars, var_name, value_name options
- concat_series_axis0: concat of 5 Series along axis=0
- stack_options: stack() with dropna=true/false options
- sample_frac: sampleSeries/sampleDataFrame with frac option

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_concat_series_axis0.py

@@ -0,0 +1,30 @@
+"""Benchmark: pd.concat of multiple Series along axis=0 — vertical stacking
+of 5 Series of 20k elements each."""
+import json, time
+import numpy as np
+import pandas as pd
+
+CHUNK = 20_000
+WARMUP = 5
+ITERATIONS = 30
+
+s1 = pd.Series(np.arange(CHUNK, dtype=float) * 1.0)
+s2 = pd.Series(np.arange(CHUNK, dtype=float) * 2.0)
+s3 = pd.Series(np.arange(CHUNK, dtype=float) * 3.0)
+s4 = pd.Series(np.arange(CHUNK, dtype=float) * 4.0)
+s5 = pd.Series(np.arange(CHUNK, dtype=float) * 5.0)
+
+for _ in range(WARMUP):
+    pd.concat([s1, s2, s3, s4, s5])
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    pd.concat([s1, s2, s3, s4, s5])
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "concat_series_axis0",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_melt_id_vars.py

@@ -0,0 +1,34 @@
+"""Benchmark: pd.melt with id_vars — unpivot keeping identifier columns fixed,
+with custom var_name and value_name on a 10k-row DataFrame."""
+import json, time
+import numpy as np
+import pandas as pd
+
+ROWS = 10_000
+WARMUP = 5
+ITERATIONS = 30
+
+ids = [f"id_{i}" for i in range(ROWS)]
+category = ["A", "B", "C"][ : ROWS]
+category = [["A", "B", "C"][i % 3] for i in range(ROWS)]
+q1 = np.arange(ROWS, dtype=float)
+q2 = np.arange(ROWS, dtype=float) * 1.1
+q3 = np.arange(ROWS, dtype=float) * 1.2
+q4 = np.arange(ROWS, dtype=float) * 1.3
+
+df = pd.DataFrame({"id": ids, "category": category, "Q1": q1, "Q2": q2, "Q3": q3, "Q4": q4})
+
+for _ in range(WARMUP):
+    pd.melt(df, id_vars=["id", "category"], var_name="quarter", value_name="revenue")
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    pd.melt(df, id_vars=["id", "category"], var_name="quarter", value_name="revenue")
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "melt_id_vars",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_sample_frac.py

@@ -0,0 +1,36 @@
+"""Benchmark: Series.sample(frac=...) and DataFrame.sample(frac=...) —
+fractional sampling (10% of 100k elements) with and without replacement."""
+import json, time
+import numpy as np
+import pandas as pd
+
+ROWS = 100_000
+WARMUP = 3
+ITERATIONS = 20
+
+data = np.arange(ROWS, dtype=float) * 1.5
+s = pd.Series(data)
+df = pd.DataFrame({
+    "a": np.arange(ROWS, dtype=float),
+    "b": np.arange(ROWS, dtype=float) * 2.0,
+    "c": np.arange(ROWS, dtype=float) * 3.0,
+})
+
+for _ in range(WARMUP):
+    s.sample(frac=0.1)
+    s.sample(frac=0.05, replace=True)
+    df.sample(frac=0.1)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    s.sample(frac=0.1)
+    s.sample(frac=0.05, replace=True)
+    df.sample(frac=0.1)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "sample_frac",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_series_set_reset_index.py

@@ -0,0 +1,30 @@
+"""Benchmark: Series.set_axis() and Series.reset_index() — reassign or reset the
+row-index of a 100k-element Series."""
+import json, time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+data = np.arange(SIZE, dtype=float) * 1.5
+s = pd.Series(data)
+new_index = pd.Index(np.arange(SIZE) * 2)
+
+for _ in range(WARMUP):
+    s.set_axis(new_index)
+    s.reset_index(drop=True)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    s.set_axis(new_index)
+    s.reset_index(drop=True)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "series_set_reset_index",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_stack_options.py

@@ -0,0 +1,37 @@
+"""Benchmark: DataFrame.stack with dropna=True/False options — includes null values
+in the output on a 2k-row x 5-column DataFrame."""
+import json, time
+import numpy as np
+import pandas as pd
+
+ROWS = 2_000
+WARMUP = 5
+ITERATIONS = 30
+
+def make_col(mul: float) -> list:
+    return [None if i % 10 == 0 else float(i) * mul for i in range(ROWS)]
+
+df = pd.DataFrame({
+    "a": make_col(1.0),
+    "b": make_col(1.1),
+    "c": make_col(1.2),
+    "d": make_col(1.3),
+    "e": make_col(1.4),
+})
+
+for _ in range(WARMUP):
+    df.stack(dropna=True)
+    df.stack(dropna=False)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    df.stack(dropna=True)
+    df.stack(dropna=False)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "stack_options",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/tsb/bench_concat_series_axis0.ts

@@ -0,0 +1,35 @@
+/**
+ * Benchmark: concat of multiple Series objects along axis=0 — vertical stacking
+ * of 5 Series of 20k elements each.
+ * Outputs JSON: {"function": "concat_series_axis0", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, concat } from "../../src/index.ts";
+
+const CHUNK = 20_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+const s1 = new Series({ data: Array.from({ length: CHUNK }, (_, i) => i * 1.0) });
+const s2 = new Series({ data: Array.from({ length: CHUNK }, (_, i) => i * 2.0) });
+const s3 = new Series({ data: Array.from({ length: CHUNK }, (_, i) => i * 3.0) });
+const s4 = new Series({ data: Array.from({ length: CHUNK }, (_, i) => i * 4.0) });
+const s5 = new Series({ data: Array.from({ length: CHUNK }, (_, i) => i * 5.0) });
+
+for (let i = 0; i < WARMUP; i++) {
+  concat([s1, s2, s3, s4, s5]);
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  concat([s1, s2, s3, s4, s5]);
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "concat_series_axis0",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_melt_id_vars.ts

@@ -0,0 +1,46 @@
+/**
+ * Benchmark: melt with id_vars — unpivot a wide DataFrame keeping identifier
+ * columns fixed, with custom var_name and value_name on a 10k-row DataFrame.
+ * Outputs JSON: {"function": "melt_id_vars", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, melt } from "../../src/index.ts";
+
+const ROWS = 10_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+const ids = Array.from({ length: ROWS }, (_, i) => `id_${i}`);
+const category = Array.from({ length: ROWS }, (_, i) => ["A", "B", "C"][i % 3]);
+const q1 = Array.from({ length: ROWS }, (_, i) => i * 1.0);
+const q2 = Array.from({ length: ROWS }, (_, i) => i * 1.1);
+const q3 = Array.from({ length: ROWS }, (_, i) => i * 1.2);
+const q4 = Array.from({ length: ROWS }, (_, i) => i * 1.3);
+
+const df = DataFrame.fromColumns({ id: ids, category, Q1: q1, Q2: q2, Q3: q3, Q4: q4 });
+
+for (let i = 0; i < WARMUP; i++) {
+  melt(df, {
+    id_vars: ["id", "category"],
+    var_name: "quarter",
+    value_name: "revenue",
+  });
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  melt(df, {
+    id_vars: ["id", "category"],
+    var_name: "quarter",
+    value_name: "revenue",
+  });
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "melt_id_vars",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_sample_frac.ts

@@ -0,0 +1,42 @@
+/**
+ * Benchmark: sampleSeries with frac option and sampleDataFrame with frac option.
+ * Fractional sampling (10% of 100k elements) with and without replacement.
+ * Outputs JSON: {"function": "sample_frac", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, DataFrame, sampleSeries, sampleDataFrame } from "../../src/index.ts";
+
+const ROWS = 100_000;
+const WARMUP = 3;
+const ITERATIONS = 20;
+
+const data = Array.from({ length: ROWS }, (_, i) => i * 1.5);
+const s = new Series({ data });
+
+const df = DataFrame.fromColumns({
+  a: Array.from({ length: ROWS }, (_, i) => i * 1.0),
+  b: Array.from({ length: ROWS }, (_, i) => i * 2.0),
+  c: Array.from({ length: ROWS }, (_, i) => i * 3.0),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  sampleSeries(s, { frac: 0.1 });
+  sampleSeries(s, { frac: 0.05, replace: true });
+  sampleDataFrame(df, { frac: 0.1 });
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  sampleSeries(s, { frac: 0.1 });
+  sampleSeries(s, { frac: 0.05, replace: true });
+  sampleDataFrame(df, { frac: 0.1 });
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "sample_frac",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_series_set_reset_index.ts

@@ -0,0 +1,35 @@
+/**
+ * Benchmark: Series.setIndex() and Series.resetIndex() — reassign or reset the
+ * row-index of a 100k-element Series.
+ * Outputs JSON: {"function": "series_set_reset_index", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Index, Series } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const data = Array.from({ length: SIZE }, (_, i) => i * 1.5);
+const s = new Series({ data });
+const newIndex = new Index<number>(Array.from({ length: SIZE }, (_, i) => i * 2));
+
+for (let i = 0; i < WARMUP; i++) {
+  s.setIndex(newIndex);
+  s.resetIndex();
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  s.setIndex(newIndex);
+  s.resetIndex();
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "series_set_reset_index",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_stack_options.ts

@@ -0,0 +1,43 @@
+/**
+ * Benchmark: stack with dropna=false option — includes null values in the output
+ * on a 2k-row x 5-column DataFrame (100k total cells including nulls).
+ * Outputs JSON: {"function": "stack_options", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, stack } from "../../src/index.ts";
+
+const ROWS = 2_000;
+const WARMUP = 5;
+const ITERATIONS = 30;
+
+// Create a DataFrame with some null values (every 10th element is null)
+const makeCol = (mul: number) =>
+  Array.from({ length: ROWS }, (_, i) => (i % 10 === 0 ? null : i * mul));
+
+const df = DataFrame.fromColumns({
+  a: makeCol(1.0),
+  b: makeCol(1.1),
+  c: makeCol(1.2),
+  d: makeCol(1.3),
+  e: makeCol(1.4),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  stack(df, { dropna: true });
+  stack(df, { dropna: false });
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  stack(df, { dropna: true });
+  stack(df, { dropna: false });
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "stack_options",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);