flopscope 0.2.0__py3-none-any.whl

benchmarks/_random.py

@@ -0,0 +1,209 @@
+"""Benchmark random number generation operations."""
+
+from __future__ import annotations
+
+import statistics
+
+from benchmarks._perf import measure_flops
+
+RANDOM_OPS: list[str] = [
+    "random.standard_normal",
+    "random.uniform",
+    "random.standard_exponential",
+    "random.standard_cauchy",
+    "random.standard_gamma",
+    "random.standard_t",
+    "random.poisson",
+    "random.binomial",
+    "random.permutation",
+    "random.shuffle",
+    # --- added in Step 2.5 ---
+    "random.beta",
+    "random.chisquare",
+    "random.choice",
+    "random.dirichlet",
+    "random.exponential",
+    "random.f",
+    "random.gamma",
+    "random.geometric",
+    "random.gumbel",
+    "random.hypergeometric",
+    "random.laplace",
+    "random.logistic",
+    "random.lognormal",
+    "random.logseries",
+    "random.multinomial",
+    "random.multivariate_normal",
+    "random.negative_binomial",
+    "random.noncentral_chisquare",
+    "random.noncentral_f",
+    "random.normal",
+    "random.pareto",
+    "random.power",
+    "random.rand",
+    "random.randint",
+    "random.randn",
+    "random.random",
+    "random.random_sample",
+    "random.rayleigh",
+    "random.triangular",
+    "random.vonmises",
+    "random.wald",
+    "random.weibull",
+    "random.zipf",
+]
+
+# Ops that need extra arguments beyond size.
+_EXTRA_ARGS: dict[str, str] = {
+    "random.uniform": "0.0, 1.0, ",
+    "random.standard_gamma": "1.0, ",
+    "random.standard_t": "3, ",
+    "random.poisson": "5.0, ",
+    "random.binomial": "10, 0.5, ",
+    # --- added in Step 2.5 ---
+    "random.beta": "2.0, 5.0, ",
+    "random.chisquare": "2, ",
+    "random.exponential": "1.0, ",
+    "random.f": "5, 10, ",
+    "random.gamma": "2.0, 1.0, ",
+    "random.geometric": "0.5, ",
+    "random.gumbel": "0.0, 1.0, ",
+    "random.hypergeometric": "100, 50, 20, ",
+    "random.laplace": "0.0, 1.0, ",
+    "random.logistic": "0.0, 1.0, ",
+    "random.lognormal": "0.0, 1.0, ",
+    "random.logseries": "0.5, ",
+    "random.negative_binomial": "10, 0.5, ",
+    "random.noncentral_chisquare": "2, 1.0, ",
+    "random.noncentral_f": "5, 10, 1.0, ",
+    "random.normal": "0.0, 1.0, ",
+    "random.pareto": "3.0, ",
+    "random.power": "5.0, ",
+    "random.rayleigh": "1.0, ",
+    "random.triangular": "-1.0, 0.0, 1.0, ",
+    "random.vonmises": "0.0, 1.0, ",
+    "random.wald": "1.0, 1.0, ",
+    "random.weibull": "2.0, ",
+    "random.zipf": "2.0, ",
+    "random.randint": "0, 1000, ",
+}
+
+# Ops that need completely custom setup/bench code.
+_CUSTOM_OPS = frozenset(
+    {
+        "random.choice",
+        "random.dirichlet",
+        "random.multinomial",
+        "random.multivariate_normal",
+    }
+)
+
+
+def _custom_bench(op: str, n: int, dtype: str, seed: int) -> tuple[str, str]:
+    """Return (setup, bench) for ops with non-standard patterns."""
+    base_setup = f"import numpy as np; np.random.seed({seed})"
+
+    if op == "random.choice":
+        setup = base_setup + "; _pool = np.arange(1000)"
+        bench = f"np.random.choice(_pool, {n})"
+    elif op == "random.dirichlet":
+        setup = base_setup
+        bench = f"np.random.dirichlet([1.0, 2.0, 3.0], {n})"
+    elif op == "random.multinomial":
+        setup = base_setup
+        bench = f"np.random.multinomial(10, [0.2, 0.3, 0.5], {n})"
+    elif op == "random.multivariate_normal":
+        setup = base_setup + "; _mean = np.zeros(10); _cov = np.eye(10)"
+        bench = f"np.random.multivariate_normal(_mean, _cov, {n})"
+    else:
+        raise ValueError(f"Unknown custom op: {op}")
+
+    return setup, bench
+
+
+def benchmark_random(
+    n: int = 10_000_000,
+    dtype: str = "float64",
+    repeats: int = 10,
+) -> tuple[dict[str, float], dict[str, dict]]:
+    """Benchmark random ops, returning FP ops per element.
+
+    Parameters
+    ----------
+    n : int
+        Array size.
+    dtype : str
+        NumPy dtype string.
+    repeats : int
+        Number of repetitions per measurement.
+
+    Returns
+    -------
+    tuple[dict[str, float], dict[str, dict]]
+        A pair of (alphas, details). ``alphas`` maps op name to median
+        measurement per element. ``details`` maps op name to a dict of
+        raw benchmark metadata.
+    """
+    results: dict[str, float] = {}
+    details: dict[str, dict] = {}
+    seeds = [42, 123, 999]
+
+    for op in RANDOM_OPS:
+        dist_values: list[float] = []
+        dist_raw_totals: list[int] = []
+        extra = _EXTRA_ARGS.get(op, "")
+        bench = ""
+
+        for seed in seeds:
+            if op in _CUSTOM_OPS:
+                setup, bench = _custom_bench(op, n, dtype, seed)
+            elif op == "random.shuffle":
+                setup = (
+                    f"import numpy as np; np.random.seed({seed})"
+                    f"; x = np.arange({n}, dtype=np.{dtype})"
+                )
+                bench = "np.random.shuffle(x)"
+            elif op == "random.permutation":
+                setup = f"import numpy as np; np.random.seed({seed})"
+                bench = f"np.random.permutation({n})"
+            else:
+                setup = f"import numpy as np; np.random.seed({seed})"
+                bench = f"np.{op}({extra}{n})"
+
+            try:
+                result = measure_flops(setup, bench, repeats=repeats)
+            except RuntimeError:
+                continue
+            dist_values.append(result.total_flops / (n * repeats))
+            dist_raw_totals.append(result.total_flops)
+
+        if dist_values:
+            results[op] = statistics.median(dist_values)
+            # Build explicit benchmark_size per op
+            if op == "random.shuffle":
+                bm_size = f"x: ({n},)"
+            elif op == "random.permutation":
+                bm_size = f"n={n}"
+            elif op == "random.choice":
+                bm_size = f"pool: (1000,), size={n}"
+            elif op == "random.multinomial":
+                bm_size = f"n_trials=10, pvals: (3,), size={n}"
+            elif op == "random.multivariate_normal":
+                bm_size = f"mean: (10,), cov: (10,10), size={n}"
+            elif op == "random.dirichlet":
+                bm_size = f"alpha: (3,), size={n}"
+            else:
+                bm_size = f"output: ({n},)"
+            details[op] = {
+                "category": "counted_custom",
+                "measurement_mode": "custom",
+                "analytical_formula": "numel(output)",
+                "analytical_flops": n,
+                "benchmark_size": bm_size,
+                "bench_code": bench,
+                "repeats": repeats,
+                "perf_instructions_total": dist_raw_totals,
+                "distribution_alphas": dist_values,
+            }
+
+    return results, details

benchmarks/_reductions.py

@@ -0,0 +1,136 @@
+"""Benchmark reduction operations.
+
+Cumulative ops (cumsum, cumprod) use pre-allocated output via ``out=``
+to match the pointwise measurement methodology.
+"""
+
+from __future__ import annotations
+
+import statistics
+
+import numpy as np
+
+from benchmarks._perf import measure_flops
+
+REDUCTION_OPS: list[str] = [
+    "sum",
+    "prod",
+    "mean",
+    "std",
+    "var",
+    "max",
+    "min",
+    "argmax",
+    "argmin",
+    "any",
+    "all",
+    "cumsum",
+    "cumprod",
+    "nansum",
+    "nanmean",
+    "nanstd",
+    "nanvar",
+    "nanmax",
+    "nanmin",
+    "nanprod",
+    "median",
+    "nanmedian",
+    "percentile",
+    "nanpercentile",
+    "quantile",
+    "nanquantile",
+    "count_nonzero",
+    "average",
+    # --- added in Step 2.4 ---
+    "nanargmax",
+    "nanargmin",
+    "ptp",
+    "nancumprod",
+    "nancumsum",
+]
+
+# Add NumPy 2.x array API cumulative ops if available.
+if hasattr(np, "cumulative_sum"):
+    REDUCTION_OPS.extend(["cumulative_sum", "cumulative_prod"])
+
+# Ops that require an extra argument.
+_SPECIAL_ARGS: dict[str, str] = {
+    "percentile": ", 50",
+    "nanpercentile": ", 50",
+    "quantile": ", 0.5",
+    "nanquantile": ", 0.5",
+}
+
+# Cumulative ops return same-size array — pre-allocate output.
+_CUMULATIVE_OPS = {"cumsum", "cumprod", "nancumprod", "nancumsum"}
+if hasattr(np, "cumulative_sum"):
+    _CUMULATIVE_OPS |= {"cumulative_sum", "cumulative_prod"}
+_CUMULATIVE_OPS = frozenset(_CUMULATIVE_OPS)
+
+
+def benchmark_reductions(
+    n: int = 10_000_000,
+    dtype: str = "float64",
+    repeats: int = 10,
+) -> tuple[dict[str, float], dict[str, dict]]:
+    """Benchmark all reduction ops, returning raw measurement per element.
+
+    Parameters
+    ----------
+    n : int
+        Array size.
+    dtype : str
+        NumPy dtype string.
+    repeats : int
+        Number of repetitions per measurement.
+
+    Returns
+    -------
+    tuple[dict[str, float], dict[str, dict]]
+        A pair of (alphas, details). ``alphas`` maps op name to median
+        measurement per element. ``details`` maps op name to a dict of
+        raw benchmark metadata.
+    """
+    results: dict[str, float] = {}
+    details: dict[str, dict] = {}
+
+    base_setups = [
+        f"import numpy as np; x = np.random.default_rng(42).standard_normal({n}).astype(np.{dtype})",
+        f"import numpy as np; x = np.random.default_rng(42).uniform(0.01, 100, size={n}).astype(np.{dtype})",
+        f"import numpy as np; x = np.random.default_rng(42).uniform(-1000, 1000, size={n}).astype(np.{dtype})",
+    ]
+
+    for op in REDUCTION_OPS:
+        dist_values: list[float] = []
+        dist_raw_totals: list[int] = []
+        extra = _SPECIAL_ARGS.get(op, "")
+        bench = ""
+
+        for base_setup in base_setups:
+            if op in _CUMULATIVE_OPS:
+                setup = base_setup + f"; _out = np.empty({n}, dtype=np.{dtype})"
+                bench = f"np.{op}(x, out=_out)"
+            else:
+                setup = base_setup
+                bench = f"np.{op}(x{extra})"
+            try:
+                result = measure_flops(setup, bench, repeats=repeats)
+            except RuntimeError:
+                continue
+            dist_values.append(result.total_flops / (n * repeats))
+            dist_raw_totals.append(result.total_flops)
+        if dist_values:
+            results[op] = statistics.median(dist_values)
+            details[op] = {
+                "category": "counted_reduction",
+                "measurement_mode": "ufunc_reduction",
+                "analytical_formula": "numel(input)",
+                "analytical_flops": n,
+                "benchmark_size": f"x: ({n},)",
+                "bench_code": bench,
+                "repeats": repeats,
+                "perf_instructions_total": dist_raw_totals,
+                "distribution_alphas": dist_values,
+            }
+
+    return results, details

benchmarks/_sorting.py

@@ -0,0 +1,289 @@
+"""Benchmark sorting and related operations."""
+
+from __future__ import annotations
+
+import math
+import statistics
+
+from benchmarks._perf import measure_flops
+
+SORTING_OPS: list[str] = [
+    "sort",
+    "argsort",
+    "lexsort",
+    "partition",
+    "argpartition",
+    "searchsorted",
+    "unique",
+    # Set operations
+    "in1d",
+    "isin",
+    "intersect1d",
+    "setdiff1d",
+    "setxor1d",
+    "union1d",
+    # NumPy 2.x unique variants
+    "unique_all",
+    "unique_counts",
+    "unique_inverse",
+    "unique_values",
+]
+
+_FORMULA_STRINGS: dict[str, str] = {
+    "sort": "n * ceil(log2(n))",
+    "argsort": "n * ceil(log2(n))",
+    "unique": "n * ceil(log2(n))",
+    "unique_all": "n * ceil(log2(n))",
+    "unique_counts": "n * ceil(log2(n))",
+    "unique_inverse": "n * ceil(log2(n))",
+    "unique_values": "n * ceil(log2(n))",
+    "lexsort": "k * n * ceil(log2(n))",
+    "searchsorted": "m * ceil(log2(n))",
+    "partition": "n",
+    "argpartition": "n",
+    "in1d": "(n+m) * ceil(log2(n+m))",
+    "isin": "(n+m) * ceil(log2(n+m))",
+    "intersect1d": "(n+m) * ceil(log2(n+m))",
+    "setdiff1d": "(n+m) * ceil(log2(n+m))",
+    "setxor1d": "(n+m) * ceil(log2(n+m))",
+    "union1d": "(n+m) * ceil(log2(n+m))",
+}
+
+
+def _analytical_cost(op: str, n: int, **kwargs: int) -> int:
+    """Return the analytical operation count for a sorting-related op.
+
+    Parameters
+    ----------
+    op : str
+        Operation name (e.g. ``"sort"``, ``"lexsort"``).
+    n : int
+        Primary array size.
+    **kwargs
+        Extra parameters: ``k`` for lexsort key count, ``m`` for second
+        array size in set operations / searchsorted queries.
+
+    Returns
+    -------
+    int
+        Analytical FP-operation count used as the normalization denominator.
+    """
+    nlogn = n * math.ceil(math.log2(n)) if n > 1 else n
+
+    if op in ("sort", "argsort", "unique"):
+        return nlogn
+
+    if op in ("unique_all", "unique_counts", "unique_inverse", "unique_values"):
+        return nlogn
+
+    if op == "lexsort":
+        k = kwargs.get("k", 2)
+        return k * nlogn
+
+    if op == "searchsorted":
+        m = kwargs.get("m", n)
+        return m * math.ceil(math.log2(n)) if n > 1 else m
+
+    if op in ("partition", "argpartition"):
+        return n
+
+    # Set operations: in1d, isin, intersect1d, setdiff1d, setxor1d, union1d
+    if op in ("in1d", "isin", "intersect1d", "setdiff1d", "setxor1d", "union1d"):
+        m = kwargs.get("m", n)
+        total = n + m
+        return total * math.ceil(math.log2(total)) if total > 1 else total
+
+    # Fallback: per-element
+    return n
+
+
+def benchmark_sorting(
+    n: int = 10_000_000,
+    dtype: str = "float64",
+    repeats: int = 10,
+) -> tuple[dict[str, float], dict[str, dict]]:
+    """Benchmark sorting ops, returning FP ops per analytical operation.
+
+    Parameters
+    ----------
+    n : int
+        Array size.
+    dtype : str
+        NumPy dtype string.
+    repeats : int
+        Number of repetitions per measurement.
+
+    Returns
+    -------
+    tuple[dict[str, float], dict[str, dict]]
+        ``(alphas, details)`` where *alphas* maps op name to median alpha
+        and *details* maps op name to a dict of per-op measurement metadata.
+    """
+    results: dict[str, float] = {}
+    details: dict[str, dict] = {}
+
+    for op in SORTING_OPS:
+        dist_values: list[float] = []
+        perf_instructions: list[int] = []
+
+        if op == "lexsort":
+            setups = [
+                (
+                    f"import numpy as np; rng = np.random.default_rng(42); "
+                    f"x = rng.standard_normal({n}).astype(np.{dtype}); "
+                    f"y = rng.standard_normal({n}).astype(np.{dtype})"
+                ),
+                (
+                    f"import numpy as np; "
+                    f"x = np.sort(np.random.default_rng(42).standard_normal({n}).astype(np.{dtype})); "
+                    f"y = np.sort(np.random.default_rng(43).standard_normal({n}).astype(np.{dtype}))"
+                ),
+                (
+                    f"import numpy as np; "
+                    f"x = np.sort(np.random.default_rng(42).standard_normal({n}).astype(np.{dtype}))[::-1].copy(); "
+                    f"y = np.sort(np.random.default_rng(43).standard_normal({n}).astype(np.{dtype}))[::-1].copy()"
+                ),
+            ]
+            bench = "np.lexsort((x, y))"
+            analytical = _analytical_cost(op, n, k=2)
+        elif op == "searchsorted":
+            setups = [
+                (
+                    f"import numpy as np; rng = np.random.default_rng(42); "
+                    f"x = np.sort(rng.standard_normal({n}).astype(np.{dtype})); "
+                    f"q = rng.standard_normal({n}).astype(np.{dtype})"
+                ),
+                (
+                    f"import numpy as np; "
+                    f"x = np.sort(np.random.default_rng(42).standard_normal({n}).astype(np.{dtype})); "
+                    f"q = np.sort(np.random.default_rng(43).standard_normal({n}).astype(np.{dtype}))"
+                ),
+                (
+                    f"import numpy as np; "
+                    f"x = np.sort(np.random.default_rng(42).standard_normal({n}).astype(np.{dtype})); "
+                    f"q = np.sort(np.random.default_rng(43).standard_normal({n}).astype(np.{dtype}))[::-1].copy()"
+                ),
+            ]
+            bench = "np.searchsorted(x, q)"
+            analytical = _analytical_cost(op, n, m=n)
+        elif op in ("partition", "argpartition"):
+            kth = n // 2
+            # Use only random input — sorted/reverse-sorted is pathological
+            # for introselect (O(n^2) worst case), which inflates the weight.
+            # The analytical formula O(n) reflects average-case performance.
+            setups = [
+                f"import numpy as np; x = np.random.default_rng(42).standard_normal({n}).astype(np.{dtype})",
+                f"import numpy as np; x = np.random.default_rng(43).standard_normal({n}).astype(np.{dtype})",
+                f"import numpy as np; x = np.random.default_rng(99).standard_normal({n}).astype(np.{dtype})",
+            ]
+            bench = f"np.{op}(x, {kth})"
+            analytical = _analytical_cost(op, n)
+        elif op in ("in1d", "isin"):
+            setups = [
+                (
+                    f"import numpy as np; rng = np.random.default_rng(42); "
+                    f"a = rng.standard_normal({n}).astype(np.{dtype}); "
+                    f"b = rng.standard_normal({n}).astype(np.{dtype})"
+                ),
+                (
+                    f"import numpy as np; rng = np.random.default_rng(42); "
+                    f"a = np.sort(rng.standard_normal({n}).astype(np.{dtype})); "
+                    f"b = np.sort(np.random.default_rng(43).standard_normal({n}).astype(np.{dtype}))"
+                ),
+                (
+                    f"import numpy as np; rng = np.random.default_rng(42); "
+                    f"a = np.sort(rng.standard_normal({n}).astype(np.{dtype}))[::-1].copy(); "
+                    f"b = np.sort(np.random.default_rng(43).standard_normal({n}).astype(np.{dtype}))[::-1].copy()"
+                ),
+            ]
+            bench = f"np.{op}(a, b)"
+            analytical = _analytical_cost(op, n, m=n)
+        elif op in ("intersect1d", "setdiff1d", "setxor1d", "union1d"):
+            setups = [
+                (
+                    f"import numpy as np; rng = np.random.default_rng(42); "
+                    f"a = rng.standard_normal({n}).astype(np.{dtype}); "
+                    f"b = rng.standard_normal({n}).astype(np.{dtype})"
+                ),
+                (
+                    f"import numpy as np; rng = np.random.default_rng(42); "
+                    f"a = np.sort(rng.standard_normal({n}).astype(np.{dtype})); "
+                    f"b = np.sort(np.random.default_rng(43).standard_normal({n}).astype(np.{dtype}))"
+                ),
+                (
+                    f"import numpy as np; rng = np.random.default_rng(42); "
+                    f"a = np.sort(rng.standard_normal({n}).astype(np.{dtype}))[::-1].copy(); "
+                    f"b = np.sort(np.random.default_rng(43).standard_normal({n}).astype(np.{dtype}))[::-1].copy()"
+                ),
+            ]
+            bench = f"np.{op}(a, b)"
+            analytical = _analytical_cost(op, n, m=n)
+        elif op in ("unique_all", "unique_counts", "unique_inverse", "unique_values"):
+            setups = [
+                f"import numpy as np; x = np.random.default_rng(42).standard_normal({n}).astype(np.{dtype})",
+                f"import numpy as np; x = np.sort(np.random.default_rng(42).standard_normal({n}).astype(np.{dtype}))",
+                f"import numpy as np; x = np.sort(np.random.default_rng(42).standard_normal({n}).astype(np.{dtype}))[::-1].copy()",
+            ]
+            bench = f"np.{op}(x)"
+            analytical = _analytical_cost(op, n)
+        else:
+            # sort, argsort, unique
+            setups = [
+                f"import numpy as np; x = np.random.default_rng(42).standard_normal({n}).astype(np.{dtype})",
+                f"import numpy as np; x = np.sort(np.random.default_rng(42).standard_normal({n}).astype(np.{dtype}))",
+                f"import numpy as np; x = np.sort(np.random.default_rng(42).standard_normal({n}).astype(np.{dtype}))[::-1].copy()",
+            ]
+            bench = f"np.{op}(x)"
+            analytical = _analytical_cost(op, n)
+
+        for setup in setups:
+            try:
+                result = measure_flops(setup, bench, repeats=repeats)
+            except RuntimeError:
+                continue
+            perf_instructions.append(result.total_flops)
+            dist_values.append(result.total_flops / (analytical * repeats))
+
+        if dist_values:
+            results[op] = statistics.median(dist_values)
+            # Build explicit benchmark_size per op
+            if op in (
+                "sort",
+                "argsort",
+                "unique",
+                "unique_all",
+                "unique_counts",
+                "unique_inverse",
+                "unique_values",
+            ):
+                bm_size = f"x: ({n},)"
+            elif op in ("partition", "argpartition"):
+                bm_size = f"x: ({n},), kth={n // 2}"
+            elif op == "searchsorted":
+                bm_size = f"x: ({n},), q: ({n},)"
+            elif op == "lexsort":
+                bm_size = f"x: ({n},), y: ({n},), k=2"
+            elif op in (
+                "in1d",
+                "isin",
+                "intersect1d",
+                "setdiff1d",
+                "setxor1d",
+                "union1d",
+            ):
+                bm_size = f"a: ({n},), b: ({n},)"
+            else:
+                bm_size = f"x: ({n},)"
+            details[op] = {
+                "category": "counted_custom",
+                "measurement_mode": "custom",
+                "analytical_formula": _FORMULA_STRINGS.get(op, "n"),
+                "analytical_flops": analytical,
+                "benchmark_size": bm_size,
+                "bench_code": bench,
+                "repeats": repeats,
+                "perf_instructions_total": perf_instructions,
+                "distribution_alphas": dist_values,
+            }
+
+    return results, details