Complete benchmark results for aggregate. A short summary is in the README.

• 500,000 indices, uniformly drawn from [0, 1000).
• The values of a are uniform on [0, 1), and everything above 0.8 is then set to 0, so that there are falsy values for the boolean functions.
• For the nan… functions, of the remaining values those below 0.2 are set to nan (about 20%), leaving the rest on the interval [0.2, 0.8].
• Times in milliseconds, the fastest of five timed executions after one untimed warm-up call, over three complete passes of the table (--repeat=5 --runs=3 of numpy_groupies.benchmarks). Lower is better.
• Software: Python 3.14.7, NumPy 2.5.4, Numba 0.68.0, pandas 3.0.6, numbagg 0.9.6 (Linux, x86_64).

Absolute numbers depend heavily on the machine, Python and library versions, so rely on the ratios between columns rather than on the values. On shared machines single runs wobble, so --runs=3 measures everything three times and reports the fastest measurement of each cell. Re-run on your own hardware, from the repository root:

python -m numpy_groupies.benchmarks --ufunc --numbagg --pandas --runs=3

Which columns are measured by default, what the optional ones are and how the output arrives is what --help explains. ---- in the table below means the function is not available in that implementation, the row arbitrary is a custom Python callable passed as func.

• numba vs numpy: Numba is faster for every function both provide - by 1.5-6.1× across the plain reductions (sum 2.1×, first 6.1×), by 2.9-14× on the nan ones (nanmean 2.9×, nanfirst 14×), by 4.2-8.8× on the argreductions (argmin 8.8×), by 5.2× on sort (26 ms against 136 ms), and by far the most on cumsum (about 79×).
• numba vs numbagg: par on the light scans (sum 0.44 against 0.47 ms, first 0.29 against 0.31 ms, while prod and nanfirst go to numbagg by a few per cent); numba leads wherever the nan handling branches per value (anynan 4.3×, nansum 4.0×, nanlen 3.8×, nanlast 3.6×, nanargmax 2.5×), and is the only one of the two with median, the cumulatives, trapezoid and sort.
• numpy vs pandas: the NumPy implementation is 5.4× (var) to 17.9× (len) faster on the plain reductions, up to 8.1× on the nan ones (nanlen) and 2.6-6.0× on the argreductions. The exceptions are median and nanmedian, where pandas (28.6 ms and 30.3 ms) beats NumPy (48.8 ms and 42.6 ms) but not Numba (11.5 ms and 10.6 ms), and the cumulatives, where pandas is six times faster than NumPy (cumsum 7.6 against 45.9 ms) and still thirteen times slower than Numba (0.58 ms).
• ufunc: ufunc.at was historically slow; NumPy 1.25 brought major speed improvements and on the arithmetic scans the column now stands level with NumPy (sum 0.90 against 0.95 ms, prod, min, max and len within a few per cent). It is six times behind on anynan and twelve to nineteen times on all and any, and the implementation remains incomplete.
• Expensive everywhere: median, sort and custom callables.

sort emits one value per input item and orders every group on its own, so its cost turns on the group size - a few large blocks to order against many small ones. --sort measures that function alone over a hundredth, one, ten and a hundred times the group count of the table above, on the same 500,000 values:

python -m numpy_groupies.benchmarks --sort --runs=3

NumPy slows down monotonically as the groups multiply, from 126 to 168 ms. The Numba column falls the whole way down, to 12 ms: with few large groups the comparison sort of a whole block is what costs, while many tiny groups are ordered by insertion sort in the flat array, without the per-group view that a library sort has to build - which is almost three times the speed of the five-thousand-value groups. The other implementations have no column here because none of them provides sort.