Iteration 147: Add 8 benchmark pairs (462 total, +2 vs best 460)

Added 8 new benchmark pairs covering:
- timestamp_arith: Timestamp.add/sub/eq/lt/gt/le/ge/ne operations
- timestamp_str_format: strftime/isoformat/day_name/month_name
- timestamp_round_normalize: ceil/floor/round/normalize
- value_counts_opts: valueCounts with normalize/ascending/dropna options
- series_sortvalues_opts: Series.sortValues with ascending=false/naPosition='first'
- dataframe_sortvalues_mixed: DataFrame.sortValues with mixed ascending array
- series_groupby_size: SeriesGroupBy.size() and getGroup()
- series_log_natural: seriesLog (natural logarithm)

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

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

Author: github-actions[bot]

benchmarks/pandas/bench_dataframe_sortvalues_mixed.py

@@ -0,0 +1,32 @@
+"""Benchmark: DataFrame.sort_values with mixed ascending list [True, False, True]."""
+import json
+import time
+import pandas as pd
+import numpy as np
+
+ROWS = 100_000
+WARMUP = 3
+ITERATIONS = 20
+
+df = pd.DataFrame({
+    "category": [f"group_{i % 10}" for i in range(ROWS)],
+    "priority": [i % 5 for i in range(ROWS)],
+    "value": np.random.random(ROWS) * 1000,
+})
+
+for _ in range(WARMUP):
+    df.sort_values(["category", "priority", "value"], ascending=[True, False, True])
+    df.sort_values(["category", "value"], ascending=[False, True])
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    df.sort_values(["category", "priority", "value"], ascending=[True, False, True])
+    df.sort_values(["category", "value"], ascending=[False, True])
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "dataframe_sortvalues_mixed",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_series_groupby_size.py

@@ -0,0 +1,31 @@
+"""Benchmark: SeriesGroupBy.size() and get_group() operations."""
+import json
+import time
+import pandas as pd
+import numpy as np
+
+ROWS = 100_000
+WARMUP = 3
+ITERATIONS = 20
+
+values = pd.Series(np.random.random(ROWS) * 1000)
+groups = pd.Series([f"g{i % 20}" for i in range(ROWS)])
+
+for _ in range(WARMUP):
+    values.groupby(groups).size()
+    values.groupby(groups).get_group("g0")
+    values.groupby(groups).get_group("g10")
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    values.groupby(groups).size()
+    values.groupby(groups).get_group("g0")
+    values.groupby(groups).get_group("g10")
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "series_groupby_size",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_series_log_natural.py

@@ -0,0 +1,26 @@
+"""Benchmark: Series natural logarithm — np.log / Series.apply(np.log) on 100k-element Series."""
+import json
+import time
+import pandas as pd
+import numpy as np
+
+ROWS = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+s = pd.Series(np.arange(1, ROWS + 1, dtype=float))
+
+for _ in range(WARMUP):
+    np.log(s)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    np.log(s)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "series_log_natural",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_series_sortvalues_opts.py

@@ -0,0 +1,31 @@
+"""Benchmark: Series.sort_values with options — ascending=False, na_position='first'."""
+import json
+import time
+import pandas as pd
+import numpy as np
+
+ROWS = 100_000
+WARMUP = 3
+ITERATIONS = 20
+
+data = [None if i % 1000 == 0 else (np.random.random() * 10000 - 5000) for i in range(ROWS)]
+s = pd.Series(data)
+
+for _ in range(WARMUP):
+    s.sort_values(ascending=False)
+    s.sort_values(ascending=True, na_position="first")
+    s.sort_values(ascending=False, na_position="first")
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    s.sort_values(ascending=False)
+    s.sort_values(ascending=True, na_position="first")
+    s.sort_values(ascending=False, na_position="first")
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "series_sortvalues_opts",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_timestamp_arith.py

@@ -0,0 +1,45 @@
+"""Benchmark: Timestamp arithmetic — add timedelta, subtract, comparison operators."""
+import json
+import time
+import pandas as pd
+from datetime import timedelta
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 50
+
+base = pd.Timestamp("2024-01-01")
+timestamps = [pd.Timestamp("2020-01-01") + timedelta(days=i) for i in range(SIZE)]
+delta = pd.Timedelta(days=30)
+delta2 = pd.Timedelta(hours=12)
+
+for _ in range(WARMUP):
+    for ts in timestamps:
+        ts + delta
+        ts - delta2
+        ts == base
+        ts < base
+        ts > base
+        ts <= base
+        ts >= base
+        ts != base
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    for ts in timestamps:
+        ts + delta
+        ts - delta2
+        ts == base
+        ts < base
+        ts > base
+        ts <= base
+        ts >= base
+        ts != base
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "timestamp_arith",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_timestamp_round_normalize.py

@@ -0,0 +1,37 @@
+"""Benchmark: Timestamp rounding — floor, ceil, round, normalize."""
+import json
+import time
+import pandas as pd
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 50
+
+timestamps = [
+    pd.Timestamp(year=2020, month=(i % 12) + 1, day=(i % 28) + 1,
+                 hour=i % 24, minute=(i * 7) % 60, second=(i * 13) % 60)
+    for i in range(SIZE)
+]
+
+for _ in range(WARMUP):
+    for ts in timestamps:
+        ts.floor("h")
+        ts.ceil("h")
+        ts.round("min")
+        ts.normalize()
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    for ts in timestamps:
+        ts.floor("h")
+        ts.ceil("h")
+        ts.round("min")
+        ts.normalize()
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "timestamp_round_normalize",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_timestamp_str_format.py

@@ -0,0 +1,37 @@
+"""Benchmark: Timestamp string formatting — strftime, isoformat, day_name, month_name."""
+import json
+import time
+import pandas as pd
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 50
+
+timestamps = [
+    pd.Timestamp(year=2020, month=(i % 12) + 1, day=(i % 28) + 1,
+                 hour=i % 24, minute=i % 60, second=i % 60)
+    for i in range(SIZE)
+]
+
+for _ in range(WARMUP):
+    for ts in timestamps:
+        ts.strftime("%Y-%m-%d %H:%M:%S")
+        ts.isoformat()
+        ts.day_name()
+        ts.month_name()
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    for ts in timestamps:
+        ts.strftime("%Y-%m-%d %H:%M:%S")
+        ts.isoformat()
+        ts.day_name()
+        ts.month_name()
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "timestamp_str_format",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_value_counts_opts.py

@@ -0,0 +1,33 @@
+"""Benchmark: value_counts with options — normalize=True, ascending=True, dropna=False."""
+import json
+import time
+import pandas as pd
+import numpy as np
+
+ROWS = 100_000
+WARMUP = 3
+ITERATIONS = 20
+
+data = [None if i % 500 == 0 else f"cat_{i % 50}" for i in range(ROWS)]
+s = pd.Series(data)
+
+for _ in range(WARMUP):
+    s.value_counts(normalize=True)
+    s.value_counts(ascending=True)
+    s.value_counts(dropna=False)
+    s.value_counts(normalize=True, ascending=True, dropna=False)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    s.value_counts(normalize=True)
+    s.value_counts(ascending=True)
+    s.value_counts(dropna=False)
+    s.value_counts(normalize=True, ascending=True, dropna=False)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "value_counts_opts",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/tsb/bench_dataframe_sortvalues_mixed.ts

@@ -0,0 +1,36 @@
+/**
+ * Benchmark: DataFrame.sortValues with mixed ascending array [true, false, true].
+ * Outputs JSON: {"function": "dataframe_sortvalues_mixed", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame } from "../../src/index.ts";
+
+const ROWS = 100_000;
+const WARMUP = 3;
+const ITERATIONS = 20;
+
+const df = DataFrame.fromColumns({
+  category: Array.from({ length: ROWS }, (_, i) => `group_${i % 10}`),
+  priority: Array.from({ length: ROWS }, (_, i) => i % 5),
+  value: Array.from({ length: ROWS }, () => Math.random() * 1000),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  df.sortValues(["category", "priority", "value"], [true, false, true]);
+  df.sortValues(["category", "value"], [false, true]);
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  df.sortValues(["category", "priority", "value"], [true, false, true]);
+  df.sortValues(["category", "value"], [false, true]);
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "dataframe_sortvalues_mixed",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);

benchmarks/tsb/bench_series_groupby_size.ts

@@ -0,0 +1,39 @@
+/**
+ * Benchmark: SeriesGroupBy.size() and SeriesGroupBy.getGroup() operations.
+ * Outputs JSON: {"function": "series_groupby_size", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series } from "../../src/index.ts";
+
+const ROWS = 100_000;
+const WARMUP = 3;
+const ITERATIONS = 20;
+
+const values = new Series({
+  data: Array.from({ length: ROWS }, (_, i) => Math.random() * 1000),
+});
+const groups = new Series({
+  data: Array.from({ length: ROWS }, (_, i) => `g${i % 20}`),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  values.groupby(groups).size();
+  values.groupby(groups).getGroup("g0");
+  values.groupby(groups).getGroup("g10");
+}
+
+const start = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  values.groupby(groups).size();
+  values.groupby(groups).getGroup("g0");
+  values.groupby(groups).getGroup("g10");
+}
+const total = performance.now() - start;
+
+console.log(
+  JSON.stringify({
+    function: "series_groupby_size",
+    mean_ms: total / ITERATIONS,
+    iterations: ITERATIONS,
+    total_ms: total,
+  }),
+);