max-div 0.0.3__py3-none-any.whl → 0.1.1__py3-none-any.whl

max_div-0.1.1.dist-info/RECORD

@@ -0,0 +1,32 @@
+max_div/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+max_div/_cli.py,sha256=WMGA-kw3hi3un6MCngjxbQ_WUMVvKxKtz02n2ydqWU0,3276
+max_div/benchmark/__init__.py,sha256=9lru2A83WlZCYeM6Ppy0XWN9K4dzb6twpCqpo8CQA3I,102
+max_div/benchmark/_formatting.py,sha256=zFUMU0Nz6HHngvDqgo7vzi6v5LtVWrXvk2P9PdAKIgM,8991
+max_div/benchmark/randint.py,sha256=-SMK59LVXCZIxDbuEFmtsxAXU-zGeVyP2KyDXxTCJ0Y,3502
+max_div/benchmark/randint_constrained.py,sha256=SF5XaCiOEnvpkqlbjWBJtJmYXzjJF7oRIgUFJt3dS4o,12477
+max_div/constraints/__init__.py,sha256=K2CnAb9llDxNu8qtGEAx4vZ8SLWVqs5zXfhbXzkGBog,72
+max_div/constraints/_numba.py,sha256=VyQqmsF8Kcfay73dRVnGmOPcWrpsXL-yqhd6mH71uAw,4485
+max_div/constraints/constraint.py,sha256=MK2kbexHCrxYkYMT_n76KVzwC9gARIyF3nMdjk01UAk,246
+max_div/constraints/constraints.py,sha256=ARn7v8tu1ESx66KcXyGpfKyqM0SNAxHk0T4V48OEboI,1675
+max_div/internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+max_div/internal/benchmarking/__init__.py,sha256=WNjrLlGI_vkI-nZkQMPICgi67rTVole_MCc4jNe_OxI,83
+max_div/internal/benchmarking/_micro_benchmark.py,sha256=cZGkx3ngZSJDRAAF5TP56bEkEvNpfAAg1-1tuiGeBPQ,5992
+max_div/internal/benchmarking/_timer.py,sha256=gpA3KgreDTtK2QUARJKI4Ir9dTDMKW7B5GQuThRbYh8,1050
+max_div/internal/formatting/__init__.py,sha256=3TzBpe_KfCY_3ETvOoRIl_qAtfgjT1b-8o3iYpVK9ZE,182
+max_div/internal/formatting/_markdown.py,sha256=Nf0fSDSmmJF2pYbnLoG23-1_d1S8RLYCWSYrNghTgO8,1441
+max_div/internal/formatting/_time_duration.py,sha256=dO88GPZeMbxVk0YF9Zr2Y0NLCXaiW_HwTa7S-PT9e9E,6740
+max_div/internal/math/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+max_div/internal/math/fast_log.py,sha256=e3rGXdEqBJN_v1DGNniE5CtPfF7zzTzr9sfeda_V73A,5609
+max_div/internal/math/random.py,sha256=XnNnCxkFitdl6nBmCi7gI_6VGNhOabqXXYIm1EU2kRY,6548
+max_div/internal/math/select_k_minmax.py,sha256=q2z6uLYAwfcAox4RzFyZwa4jJ9CoiPK50mCrEMEKEhY,10112
+max_div/internal/utils/__init__.py,sha256=Xqb7Rh9Lq6WsUK-5B9aouwWMhAh0c1a7pF0rdaP5kgo,62
+max_div/internal/utils/_clip.py,sha256=kWUCKG9uFxNvFWvThMyFdWLlzVb9cFADngpBYl5b38U,230
+max_div/internal/utils/_precision.py,sha256=3eEUdJQmXA3Q6Tg4jb3vG0RTwOBNgnc09j5ts0gcIdw,125
+max_div/sampling/__init__.py,sha256=HNmw64ps3rXURPYuXvVUcePT6aKi5PJWXu_Ex7yavRg,57
+max_div/sampling/con.py,sha256=bgkeRagZ2Epv2sSajqqvdhmIec6Dn2EI4osHwYIZRS4,13856
+max_div/sampling/uncon.py,sha256=jmrLIvqr7FcPaST5uBgXtFVj_ZDiJYuPbkY-_i1BtIU,13219
+max_div-0.1.1.dist-info/METADATA,sha256=NG3ccEDS75fPE80bfHZNCFl0dkG1bxYfZOsslwibgQM,1884
+max_div-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+max_div-0.1.1.dist-info/entry_points.txt,sha256=Q-xCOAOZ6vSRodScs7U1cF_S6IM_1GCRdD4JTeWzYKc,45
+max_div-0.1.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+max_div-0.1.1.dist-info/RECORD,,

max_div-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+max-div = max_div._cli:cli

max_div/benchmark/sample_int.py

@@ -1,85 +0,0 @@
-import math
-
-import numpy as np
-
-from max_div.internal.benchmarking import BenchmarkResult, benchmark
-from max_div.internal.compat import is_numba_installed
-from max_div.sampling.discrete import sample_int
-
-
-def benchmark_sample_int(turbo: bool = False) -> None:
-    """
-    Benchmarks the `sample_int` function from `max_div.sampling.discrete`.
-
-    Different scenarios are tested:
-
-     * with & without replacement
-     * uniform & non-uniform sampling
-     * `use_numba` True and False
-     * different sizes of (`n`, `k`):
-        * (10, 1), (100, 1), (1000, 1), (5000, 1), (10000, 1)
-        * (10000, 10), (10000, 100), (10000, 1000), (10000, 5000), (10000, 10000)
-
-    :param turbo: If `True`, a much shorter (but less reliable) benchmark is run; intended for testing purposes.
-    """
-
-    if not is_numba_installed():
-        print("====================================================================================")
-        print("   WARNING: Numba is not installed!!!")
-        print("====================================================================================")
-
-    print("Benchmarking `sample_int`...")
-    print()
-    print("".ljust(30) + "use_numba=False".rjust(25) + "use_numba=True".rjust(25))
-
-    for replace, use_p, desc in [
-        (True, False, "with replacement, uniform"),
-        (False, False, "without replacement, uniform"),
-        (True, True, "with replacement, non-uniform"),
-        (False, True, "without replacement, non-uniform"),
-    ]:
-        print(desc.upper())
-
-        for n, k in [
-            (10, 1),
-            (100, 1),
-            (1000, 1),
-            (5000, 1),
-            (10000, 1),
-            (10000, 10),
-            (10000, 100),
-            (10000, 1000),
-            (10000, 5000),
-            (10000, 10000),
-        ]:
-            size_str = f"{k:<6_} out of {n:<6_}"
-
-            results: list[BenchmarkResult] = []
-            for use_numba in [False, True]:
-                if use_p:
-                    p = np.random.rand(n)
-                    p /= p.sum()
-                else:
-                    p = None
-
-                def func_to_benchmark():
-                    sample_int(n=n, k=k, replace=replace, p=p, use_numba=use_numba)
-
-                results.append(
-                    benchmark(
-                        f=func_to_benchmark,
-                        t_per_run=0.001 if turbo else 0.1,
-                        n_warmup=3 if turbo else 10,
-                        n_benchmark=3 if turbo else 30,
-                        silent=True,
-                    )
-                )
-
-            print(
-                (" " * 4)
-                + size_str.ljust(26)
-                + results[0].t_sec_with_uncertainty_str.rjust(25)
-                + results[1].t_sec_with_uncertainty_str.rjust(25)
-            )
-
-        print()

max_div/internal/compat/__init__.py

@@ -1 +0,0 @@
-from ._numba import is_numba_installed, numba

max_div/internal/compat/_numba/__init__.py

@@ -1,14 +0,0 @@
-# =================================================================================================
-#  Transparant handling of original numba vs dummy numba
-# =================================================================================================
-try:
-    import numba
-except ImportError:
-    from ._dummy_numba import Numba as numba
-
-
-# =================================================================================================
-#  Helpers
-# =================================================================================================
-def is_numba_installed() -> bool:
-    return numba.__version__ != "0.0.0"

max_div/internal/compat/_numba/_dummy_numba.py

@@ -1,94 +0,0 @@
-"""
-Implements a dummy version of Numba for environments where Numba is not available.
-Main goal is that code that uses @numba.njit or numba.tuped.Dict, ... does not break and transparently falls back to standard Python.
-"""
-
-from ._helpers import dummy_decorator
-
-
-# =================================================================================================
-#  Dummy typed containers
-# =================================================================================================
-class NumbaTypedDict(dict):
-    @staticmethod
-    def empty(*args, **kwargs):
-        return dict()
-
-
-class NumbaTypedList(list):
-    @staticmethod
-    def empty_list(*args, **kwargs):
-        return list()
-
-
-# =================================================================================================
-#  Main dummy package tree
-# =================================================================================================
-class NumbaTyped:
-    # implements subset
-    Dict = NumbaTypedDict
-    List = NumbaTypedList
-
-
-class NumbaTypes:
-    # implements dummies for all members of numba.types.__all__
-    int8 = object()
-    int16 = object()
-    int32 = object()
-    int64 = object()
-    uint8 = object()
-    uint16 = object()
-    uint32 = object()
-    uint64 = object()
-    intp = object()
-    uintp = object()
-    intc = object()
-    uintc = object()
-    ssize_t = object()
-    size_t = object()
-    boolean = object()
-    float32 = object()
-    float64 = object()
-    complex64 = object()
-    complex128 = object()
-    bool_ = object()
-    byte = object()
-    char = object()
-    uchar = object()
-    short = object()
-    ushort = object()
-    int_ = object()
-    uint = object()
-    long_ = object()
-    ulong = object()
-    longlong = object()
-    ulonglong = object()
-    double = object()
-    void = object()
-    none = object()
-    b1 = object()
-    i1 = object()
-    i2 = object()
-    i4 = object()
-    i8 = object()
-    u1 = object()
-    u2 = object()
-    u4 = object()
-    u8 = object()
-    f4 = object()
-    f8 = object()
-    c8 = object()
-    c16 = object()
-    optional = object()
-    ffi_forced_object = object()
-    ffi = object()
-    deferred_type = object()
-    bool = object()
-
-
-class Numba:
-    __version__ = "0.0.0"
-    jit = dummy_decorator
-    njit = dummy_decorator
-    typed = NumbaTyped
-    types = NumbaTypes

max_div/internal/compat/_numba/_helpers.py

@@ -1,14 +0,0 @@
-from typing import Callable
-
-
-def dummy_decorator(*args, **kwargs):
-    # dummy decorator that does nothing and can be used with or without arguments
-    if len(args) == 1 and isinstance(args[0], Callable):
-        # decorator used without arguments
-        return args[0]
-    else:
-        # decorator used with arguments
-        def decorator(func):
-            return func
-
-        return decorator

max_div/sampling/discrete.py

@@ -1,176 +0,0 @@
-import numpy as np
-
-from max_div.internal.compat import numba
-
-
-# =================================================================================================
-#  sample_int
-# =================================================================================================
-def sample_int(
-    n: int,
-    k: int | None = None,
-    replace: bool = True,
-    p: np.ndarray[float] | None = None,
-    seed: int | None = None,
-    use_numba: bool = True,
-) -> int | np.ndarray[np.int64]:
-    """
-    Randomly sample `k` integers from range `[0, n-1]`, optionally with replacement and per-value probabilities.
-
-    Different implementation is used, depending on the case:
-
-    | `use_numba`    | `p` specified  | `replace`  | `k`  | Method Used                              | Complexity      |
-    |----------------|----------------|------------|------|------------------------------------------|-----------------|
-    |  No            | Any            | Any        | Any  | `np.random.choice`                       | depends         |
-    |  Yes           | No             | True       | Any  | `np.random.randint`, uniform sampling    | O(k)            |
-    |  Yes           | No             | False      | Any  | k-element Fisher-Yates shuffle           | O(n)            |
-    |  Yes           | Yes            | Any        | 1    | Multinomial sampling using CDF           | O(n + log(n))   |
-    |  Yes           | Yes            | True       | >1   | Multinomial sampling using CDF           | O(n + k log(n)) |
-    |  Yes           | Yes            | False      | >1   | Efraimidis-Spirakis sampling + exponential key sampling (Gumbel-Max Trick) using the Ziggurat algorithm.  | O(n) |
-
-    :param n: defines population to sample from as range [0, n-1].  `n` must be >0.
-    :param k: The number of integers to sample (>0).  `k=None` indicates a single integer sample.
-    :param replace: Whether to sample with replacement.
-    :param p: Optional 1D array of probabilities associated with each integer in the range.
-              Size must be equal to max_value + 1 and sum to 1.
-    :param seed: Optional random seed for reproducibility.
-    :param use_numba: Use the self-implemented algorithm (which is `numba`-accelerated if `numba` is installed)
-    :return: `k=None` --> single integer; `k>=1` --> (k,)-sized array with sampled integers.
-    """
-
-    # -------------------------------------------------------------------------
-    #  Don't try using numba
-    # -------------------------------------------------------------------------
-    if not use_numba:
-        # --- argument handling ---------------------------
-        if (k == 1) or (k is None):
-            replace = True  # single sample, replacement makes no difference, so we can fall back to faster methods
-
-        # --- argument validation -------------------------
-        if n < 1:
-            raise ValueError(f"n must be >=1. (here: {n})")
-        if k is not None:
-            if k < 1:
-                raise ValueError(f"k must be >=1. (here: {k})")
-            if (not replace) and (k > n):
-                raise ValueError(f"Cannot sample {k} unique values from range [0, {n}) without replacement.")
-
-        # --- sampling ------------------------------------
-        if seed is not None:
-            np.random.seed(seed)
-
-        if k is None:
-            # returns scalar
-            return np.random.choice(n, size=None, replace=replace, p=p)
-        else:
-            # returns array
-            return np.random.choice(n, size=k, replace=replace, p=p)
-
-    # -------------------------------------------------------------------------
-    #  Try using numba
-    # -------------------------------------------------------------------------
-    else:
-        # --- argument handling ---------------------------
-        k_orig = k  # remember, to know what return value we need
-        if (k == 1) or (k is None):
-            k = 1  # make sure we always have an integer for the numba function
-            replace = True  # single sample, replacement makes no difference, so we can fall back to faster methods
-        if p is None:
-            use_p = False
-            p = np.zeros(0, dtype=np.float64)  # dummy value
-        else:
-            use_p = True
-        if seed is None:
-            use_seed = False
-            seed = 42  # dummy value
-        else:
-            use_seed = True
-
-        # --- argument validation -------------------------
-        if n < 1:
-            raise ValueError(f"n must be >=1. (here: {n})")
-        if k < 1:
-            raise ValueError(f"k must be >=1. (here: {k})")
-        if (not replace) and (k > n):
-            raise ValueError(f"Cannot sample {k} unique values from range [0, {n}) without replacement.")
-        if use_p:
-            if (p.ndim != 1) or (p.size != n):
-                raise ValueError(f"p must be a 1D array of size {n}. (here: shape={p.shape})")
-
-        # --- call numba function -------------------------
-        samples = sample_int_numba(n=n, k=k, replace=replace, use_p=use_p, p=p, use_seed=use_seed, seed=seed)
-        if k_orig is None:
-            return samples[0]
-        else:
-            return samples
-
-
-@numba.njit
-def sample_int_numba(
-    n: int,
-    k: int,
-    replace: bool,
-    use_p: bool = False,
-    p: np.ndarray[float] = np.zeros(0),
-    use_seed: bool = False,
-    seed: int = 42,
-) -> np.ndarray[int]:
-    """
-    See native python version docstring.  We split the implementation into a core numba-decorated function and
-    a Python front-end, because numba-decorated functions do not allow for multiple possible return types.
-    """
-    if use_seed:
-        np.random.seed(seed)
-
-    if (k == n) and (not replace):
-        # corner case: return all elements in random order
-        population = np.arange(n, dtype=np.int64)
-        np.random.shuffle(population)
-        return population
-
-    if not use_p:
-        if replace:
-            # UNIFORM sampling with replacement
-            return np.random.choice(n, size=k)  # O(k)
-        else:
-            # UNIFORM sampling without replacement using Fisher-Yates shuffle
-            population = np.arange(n, dtype=np.int64)  # O(n)
-            for i in range(k):  # k x O(1)
-                j = np.random.randint(i, n)
-                population[i], population[j] = population[j], population[i]
-            return population[:k]  # O(k)
-    else:
-        if replace:
-            # NON-UNIFORM sampling with replacement using CDF
-            cdf = np.empty(n)  # O(n)
-            csum = 0.0
-            for i in range(n):  # n x O(1)
-                csum += p[i]
-                cdf[i] = csum
-            samples = np.empty(k, dtype=np.int64)  # O(k)
-            for i in range(k):  # k x O(log(n))
-                r = np.random.random()
-                idx = np.searchsorted(cdf, r)
-                samples[i] = idx
-            return samples
-        else:
-            # NON-UNIFORM sampling without replacement using Efraimidis-Spirakis + Exponential keys
-            # algorithm description:
-            #   Efraimidis:       select k elements corresponding to k largest values of  u_i^{1/p_i} (u_i ~ U(0,1))
-            #   Gumbel-Max Trick: select k smallest values of  -log(u_i)/p_i  (u_i ~ U(0,1))
-            #   Ziggurat:         (TODO) generate log(u_i) more efficiently, applying the Ziggurat algorithm
-            #                            to the exponential distribution, which avoids usage of transcendental
-            #                            functions for the majority of the samples.
-            keys = np.empty(n, dtype=np.float64)  # O(n)
-            u = np.random.random(n)  # O(n)
-            for i in range(n):  # n x O(1)
-                if p[i] == 0.0:
-                    keys[i] = np.inf
-                else:
-                    keys[i] = -np.log(u[i]) / p[i]
-
-            # Get indices of k smallest keys
-            if k > 1:
-                return np.argpartition(keys, k)[:k]  # O(n) average case
-            else:
-                return np.array([np.argmin(keys)])  # O(n)

max_div-0.0.3.dist-info/RECORD

@@ -1,23 +0,0 @@
-max_div/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-max_div/benchmark/__init__.py,sha256=wzyPThNW4GETpkPh5yXDKTkQbJQ1ulungL2jQL8Ak2s,45
-max_div/benchmark/sample_int.py,sha256=mueD3v0tqP0zTN9Gf1LjnvrCEm0fV3zlgcE-Eh3V0vQ,2817
-max_div/internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-max_div/internal/benchmarking/__init__.py,sha256=WNjrLlGI_vkI-nZkQMPICgi67rTVole_MCc4jNe_OxI,83
-max_div/internal/benchmarking/_micro_benchmark.py,sha256=hvQxmKG72MnG9dANrLbYm8D7NsJP-2pGapl5idX_E7I,4183
-max_div/internal/benchmarking/_timer.py,sha256=gpA3KgreDTtK2QUARJKI4Ir9dTDMKW7B5GQuThRbYh8,1050
-max_div/internal/compat/__init__.py,sha256=ApHeMuO_9zlP34BnSZMRVLVyEEv1VEkGXNJzw5ddaK4,46
-max_div/internal/compat/_numba/__init__.py,sha256=fKwHEiafrYMmk_GOaOKZBb3rDU9q0sYqzi3BPPtV0A4,631
-max_div/internal/compat/_numba/_dummy_numba.py,sha256=FPguZfpQzpWRxmc4pYSGVCoPzgofsgQO_bknF_bK8aQ,2341
-max_div/internal/compat/_numba/_helpers.py,sha256=pQqAjHYbSwPos9011xpmbkJeZ5cPBUZq14qh8G6GtjQ,402
-max_div/internal/formatting/__init__.py,sha256=UMim6fo_e4JGJo7pl8FZ1nNpmStlfbGB7O49LhCZwWo,104
-max_div/internal/formatting/_time_duration.py,sha256=dO88GPZeMbxVk0YF9Zr2Y0NLCXaiW_HwTa7S-PT9e9E,6740
-max_div/internal/utils/__init__.py,sha256=Xqb7Rh9Lq6WsUK-5B9aouwWMhAh0c1a7pF0rdaP5kgo,62
-max_div/internal/utils/_clip.py,sha256=kWUCKG9uFxNvFWvThMyFdWLlzVb9cFADngpBYl5b38U,230
-max_div/internal/utils/_precision.py,sha256=3eEUdJQmXA3Q6Tg4jb3vG0RTwOBNgnc09j5ts0gcIdw,125
-max_div/sampling/__init__.py,sha256=_tsDiQNr4brsMiROQVbJFpq7Um79HV7P0ec6ChMd_iY,33
-max_div/sampling/discrete.py,sha256=VYBpeYYIUbLeuA3Ld4PTBkVwq6ziIBW0KlkJVqmqNuU,8048
-max_div-0.0.3.dist-info/METADATA,sha256=PwZtrIAsZRKs5bCVw_SzDOQpfPtCVOcDxHTvuBRrLAM,1604
-max_div-0.0.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-max_div-0.0.3.dist-info/entry_points.txt,sha256=EL6VQ4tIThMRtNqBtQvj2yAMBJm-7OM801VYPBsRwp4,80
-max_div-0.0.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-max_div-0.0.3.dist-info/RECORD,,

max_div-0.0.3.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-benchmark_sample_int = max_div.benchmark:benchmark_sample_int