Iteration 148: Add 6 benchmark pairs (468 total, +6 vs best 462)

Add benchmarks for standalone comparison, floordiv/mod/pow, drop-duplicates,
nsmallest, and duplicated functions not yet covered as standalone imports:
- series_standalone_compare: seriesEq/Ne/Lt/Gt/Le/Ge
- dataframe_compare_lege: dataFrameLe/dataFrameGe
- series_floordiv_standalone: seriesFloorDiv/seriesMod/seriesPow
- drop_duplicates_fn: dropDuplicatesSeries/dropDuplicatesDataFrame
- nsmallest_series_fn: nsmallestSeries
- duplicated_fn: duplicatedSeries/duplicatedDataFrame

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_dataframe_compare_lege.py

@@ -0,0 +1,36 @@
+"""
+Benchmark: DataFrame <= and >= element-wise comparisons on 100k-row DataFrame.
+Mirrors dataFrameLe / dataFrameGe standalone functions.
+Outputs JSON: {"function": "dataframe_compare_lege", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+df = pd.DataFrame({
+    "a": np.arange(SIZE),
+    "b": np.arange(SIZE) * 2,
+    "c": np.arange(SIZE) % 100,
+})
+
+for _ in range(WARMUP):
+    df.le(50)
+    df.ge(50)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    df.le(50)
+    df.ge(50)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "dataframe_compare_lege",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_drop_duplicates_fn.py

@@ -0,0 +1,36 @@
+"""
+Benchmark: Series.drop_duplicates / DataFrame.drop_duplicates on 100k elements.
+Mirrors dropDuplicatesSeries / dropDuplicatesDataFrame standalone functions.
+Outputs JSON: {"function": "drop_duplicates_fn", "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)
+df = pd.DataFrame({
+    "a": np.arange(SIZE) % 1000,
+    "b": np.arange(SIZE) % 500,
+})
+
+for _ in range(WARMUP):
+    s.drop_duplicates()
+    df.drop_duplicates()
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    s.drop_duplicates()
+    df.drop_duplicates()
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "drop_duplicates_fn",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_duplicated_fn.py

@@ -0,0 +1,36 @@
+"""
+Benchmark: Series.duplicated / DataFrame.duplicated on 100k elements.
+Mirrors duplicatedSeries / duplicatedDataFrame standalone functions.
+Outputs JSON: {"function": "duplicated_fn", "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)
+df = pd.DataFrame({
+    "a": np.arange(SIZE) % 1000,
+    "b": np.arange(SIZE) % 500,
+})
+
+for _ in range(WARMUP):
+    s.duplicated()
+    df.duplicated()
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    s.duplicated()
+    df.duplicated()
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "duplicated_fn",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_nsmallest_series_fn.py

@@ -0,0 +1,31 @@
+"""
+Benchmark: Series.nsmallest on 100k-element Series.
+Mirrors nsmallestSeries standalone function.
+Outputs JSON: {"function": "nsmallest_series_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+data = np.sin(np.arange(SIZE) * 0.01) * 1000
+s = pd.Series(data)
+
+for _ in range(WARMUP):
+    s.nsmallest(100)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    s.nsmallest(100)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "nsmallest_series_fn",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_series_floordiv_standalone.py

@@ -0,0 +1,35 @@
+"""
+Benchmark: Series floordiv / mod / pow standalone functions on 100k Series.
+Mirrors seriesFloorDiv / seriesMod / seriesPow.
+Outputs JSON: {"function": "series_floordiv_standalone", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+data = (np.arange(SIZE) % 1000) + 1
+s = pd.Series(data.astype(float))
+
+for _ in range(WARMUP):
+    s.floordiv(3)
+    s.mod(7)
+    s.pow(2)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    s.floordiv(3)
+    s.mod(7)
+    s.pow(2)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "series_floordiv_standalone",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_series_standalone_compare.py

@@ -0,0 +1,42 @@
+"""
+Benchmark: standalone Series comparison operators (eq, ne, lt, gt, le, ge) on 100k Series.
+Mirrors seriesEq/Ne/Lt/Gt/Le/Ge standalone functions.
+Outputs JSON: {"function": "series_standalone_compare", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+data = np.arange(SIZE) * 0.1
+s = pd.Series(data)
+threshold = SIZE * 0.05
+
+for _ in range(WARMUP):
+    s.eq(threshold)
+    s.ne(threshold)
+    s.lt(threshold)
+    s.gt(threshold)
+    s.le(threshold)
+    s.ge(threshold)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    s.eq(threshold)
+    s.ne(threshold)
+    s.lt(threshold)
+    s.gt(threshold)
+    s.le(threshold)
+    s.ge(threshold)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "series_standalone_compare",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/tsb/bench_dataframe_compare_lege.ts

@@ -0,0 +1,36 @@
+/**
+ * Benchmark: dataFrameLe / dataFrameGe — less-than-or-equal and greater-than-or-equal standalone functions on 100k-row DataFrame.
+ * Outputs JSON: {"function": "dataframe_compare_lege", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame, dataFrameLe, dataFrameGe } 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),
+  b: Array.from({ length: SIZE }, (_, i) => i * 2),
+  c: Array.from({ length: SIZE }, (_, i) => i % 100),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  dataFrameLe(df, 50);
+  dataFrameGe(df, 50);
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  dataFrameLe(df, 50);
+  dataFrameGe(df, 50);
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "dataframe_compare_lege",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_drop_duplicates_fn.ts

@@ -0,0 +1,36 @@
+/**
+ * Benchmark: dropDuplicatesSeries / dropDuplicatesDataFrame — standalone drop-duplicates on 100k elements.
+ * Outputs JSON: {"function": "drop_duplicates_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, DataFrame, dropDuplicatesSeries, dropDuplicatesDataFrame } 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 % 1000) });
+const df = new DataFrame({
+  a: Array.from({ length: SIZE }, (_, i) => i % 1000),
+  b: Array.from({ length: SIZE }, (_, i) => i % 500),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  dropDuplicatesSeries(s);
+  dropDuplicatesDataFrame(df);
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  dropDuplicatesSeries(s);
+  dropDuplicatesDataFrame(df);
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "drop_duplicates_fn",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_duplicated_fn.ts

@@ -0,0 +1,36 @@
+/**
+ * Benchmark: duplicatedSeries / duplicatedDataFrame — standalone duplicated detection on 100k elements.
+ * Outputs JSON: {"function": "duplicated_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, DataFrame, duplicatedSeries, duplicatedDataFrame } 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 % 1000) });
+const df = new DataFrame({
+  a: Array.from({ length: SIZE }, (_, i) => i % 1000),
+  b: Array.from({ length: SIZE }, (_, i) => i % 500),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  duplicatedSeries(s);
+  duplicatedDataFrame(df);
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  duplicatedSeries(s);
+  duplicatedDataFrame(df);
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "duplicated_fn",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_nsmallest_series_fn.ts

@@ -0,0 +1,30 @@
+/**
+ * Benchmark: nsmallestSeries — standalone nsmallest on 100k-element Series.
+ * Outputs JSON: {"function": "nsmallest_series_fn", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, nsmallestSeries } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const s = new Series({ data: Array.from({ length: SIZE }, (_, i) => Math.sin(i * 0.01) * 1000) });
+
+for (let i = 0; i < WARMUP; i++) {
+  nsmallestSeries(s, 100);
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  nsmallestSeries(s, 100);
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "nsmallest_series_fn",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);