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

max_div/sampling/con.py

@@ -0,0 +1,350 @@
+"""
+Methods for sampling WITH constraints.
+"""
+
+import copy
+import math
+
+import numba
+import numpy as np
+from numba import types
+
+from max_div.constraints import Constraint
+from max_div.constraints._numba import _np_con_indices, _np_con_max_value, _np_con_min_value
+from max_div.sampling import randint_numba
+
+
+# =================================================================================================
+#  randint_constrained
+# =================================================================================================
+def randint_constrained(
+    n: int,
+    k: int,
+    cons: list[Constraint],
+    p: np.ndarray | None = None,
+    seed: int | None = None,
+) -> list[int]:
+    """
+    Generate `k` unique random integers from the range `[0, n)` while satisfying given constraints.
+
+    NOTES:
+
+    * there are no guarantees are given that constraints are satisfied; a best-effort attempt will be made, with the
+    probability of the result satisfying the constraints increasing the simpler the constraints are.
+
+    * `randint_constrained` is essentially a version of [`randint`][max_div.sampling.uncon.randint] that supports constraints.
+
+    * It is strongly advised to use the fully equivalent function [randint_constrained_numba][max_div.sampling.con.randint_constraint_numba]
+      which is 10-100x faster due to its use of numba JIT compilation and efficient numpy-based data structures.
+
+    :param n: range to sample from [0, n)
+    :param k: number of unique samples to draw (no replacement)
+    :param cons: list of Constraint objects, indicating we want to sample at least `min_count`
+                 and at most `max_count` integers from `int_set`, with all values of `int_set` in range `[0, n)`.
+    :param p: optional, target probabilities for each integer in `[0, n)`. No guarantees are given if provided,
+              but will help guide qualitative preference of sampling algorithm.  Higher p[i] values will increase
+              probability of integer `i` being included in the sample, to the extent the constraints allow this.
+    :param seed: (int, optional) random seed  (not set if None or 0 are provided)
+    :return: list of samples
+    """
+
+    # --- initialize --------------------------------------
+    samples = []
+    k_remaining = k
+    cons = copy.deepcopy(cons)  # make sure we don't modify the original ones
+
+    # --- sample ------------------------------------------
+    while k_remaining > 0:
+        # --- score & thresholds ----------------
+
+        # determine how much each integer would help us satisfy min_count constraints
+        #  (at this point, hard-excluding those integers that are already sampled or that would violate max_count)
+        score = _compute_score(n, cons, samples, hard_max_constraints=True)
+
+        # determine how much improvement we need to be able to satisfy all min_count constraints
+        # with k_remaining samples
+        total_score_needed = sum([con.min_count for con in cons if con.min_count > 0])
+        score_threshold = math.ceil(total_score_needed / k_remaining)
+
+        if max(score) >= score_threshold:
+            # at this point, it still seems possible to satisfy all min_count constraints with the
+            # remaining # of samples we have.
+            #  --> STRATEGY 1: focus on those samples that help us enough to satisfy all constraints with the
+            #                  remaining # of samples we have, and do not sample from any of the others.
+            pass
+        else:
+            # we cannot satisfy all constraints with the k remaining samples.
+            #  --> STRATEGY 2: choose samples with best net effect (help achieve min_count vs not violating max_count),
+            #                  still hard-excluding already sampled integers.
+            score = _compute_score(n, cons, samples, hard_max_constraints=False)
+            score_threshold = max(score)  # this could even be negative; we focus on those samples that do least harm
+
+        # --- sample according to strategy ------
+        # construct modified probabilities, taking into account scores
+        if (p is None) or (p.size == 0):
+            p_mod = np.ones(n)  # uniform probabilities
+        else:
+            p_mod = p.copy()  # avoid modifying input array
+
+        # make sure no p_mod is == 0, such that we will always have some p_mod[i]>0 after setting some to 0
+        p_mod = np.maximum(p_mod, 1e-12 * max(p_mod))
+        for i in range(n):
+            if score[i] < score_threshold:
+                p_mod[i] = 0.0  # exclude from sampling
+
+        # one sample from p_mod
+        s = int(
+            randint_numba(
+                n=np.int32(n),
+                k=np.int32(1),
+                p=p_mod.astype(np.float32),
+                replace=False,
+                seed=np.int64(seed or 0),
+            )[0]
+        )
+
+        # --- update stats --------------------------------
+        for con in cons:
+            if s in con.int_set:
+                con.min_count -= 1
+                con.max_count -= 1
+
+        samples.append(s)
+        k_remaining -= 1
+
+    # --- done ----------------------------------------
+    return samples
+
+
+def _compute_score(
+    n: int,
+    cons: list[Constraint],
+    already_sampled: list[int],
+    hard_max_constraints: bool,
+) -> np.ndarray:
+    """
+    Score each integer in `[0, n)` based on how sampling each integer helps toward satisfying the constraints
+      - if it helps achieve a min_count that is not satisfied yet:    +1
+      - if it would violate a max_count that we already hit:          -1      if hard_max_constraints=False
+                                                                      -2**24  if hard_max_constraints=True
+      - if we already sampled it:                                     -2**24  if hard_max_constraints=True
+
+    The basic idea behind the scoring is that integers with score <= 0 will not be sampled, if at all possible.
+
+    :param n: range to score [0, n)
+    :param cons: list of Constraint objects, indicating we want to sample at least `min_count`
+                 and at most `max_count` integers from `int_set`, with all values of `int_set` in range `[0, n)`.
+    :param already_sampled: list of integers already sampled
+    :param hard_max_constraints: if True, integers that would violate max_count constraints are penalized such that they
+                                 will never be sampled.
+    :return: array of scores for each integer in `[0, n)`
+    """
+
+    # --- init --------------------------------------------
+    large_penalty = 2**24
+    if hard_max_constraints:
+        max_count_penalty = large_penalty
+    else:
+        max_count_penalty = 1
+    scores = np.zeros(n, dtype=np.int32)
+
+    # --- min_count / max_count ---------------------------
+    for con in cons:
+        if con.min_count > 0:
+            for i in con.int_set:
+                scores[i] += 1
+        if con.max_count <= 0:
+            for i in con.int_set:
+                scores[i] -= max_count_penalty
+
+    # --- already sampled ---------------------------------
+    for i in already_sampled:
+        scores[i] -= large_penalty
+
+    return scores
+
+
+# =================================================================================================
+#  randint_constrained_numba
+# =================================================================================================
+@numba.njit(
+    types.int32[:](
+        types.int32,
+        types.int32[:, :],
+        types.int32[:],
+        types.int32[:],
+        types.boolean,
+    )
+)
+def _compute_score_numba(
+    n: np.int32,
+    con_values: np.ndarray[np.int32],
+    con_indices: np.ndarray[np.int32],
+    already_sampled: np.ndarray[np.int32],
+    hard_max_constraints: bool,
+) -> np.ndarray[np.int32]:
+    """
+    Numba version of _compute_score.
+    Score each integer based on how sampling each integer helps toward satisfying the constraints.
+
+    :param n: range to score [0, n)
+    :param con_values: 2D array (n_cons, 2) with min_count and max_count for each constraint
+    :param con_indices: 1D array with constraint indices in the format described in _constraints.py
+    :param already_sampled: 1D array of integers already sampled (negative values indicate no more samples)
+    :param hard_max_constraints: if True, integers that would violate max_count constraints are heavily penalized
+    :return: array of scores for each integer
+    """
+    n_cons = con_values.shape[0]
+
+    # --- init --------------------------------------------
+    large_penalty = np.int32(2**24)
+    if hard_max_constraints:
+        max_count_penalty = large_penalty
+    else:
+        max_count_penalty = np.int32(1)
+    scores = np.zeros(n, dtype=np.int32)
+
+    # --- min_count / max_count ---------------------------
+    for i_con in np.arange(n_cons, dtype=np.int32):
+        min_val = _np_con_min_value(con_values, i_con)
+        max_val = _np_con_max_value(con_values, i_con)
+        indices = _np_con_indices(con_indices, i_con)
+
+        if min_val > 0:
+            for idx in indices:
+                scores[idx] += 1
+        if max_val <= 0:
+            for idx in indices:
+                scores[idx] -= max_count_penalty
+
+    # --- already sampled ---------------------------------
+    for i in already_sampled:
+        if i >= 0:  # negative values indicate end of valid samples
+            scores[i] -= large_penalty
+
+    return scores
+
+
+@numba.njit(
+    types.int32[:](
+        types.int32,
+        types.int32,
+        types.int32[:, :],
+        types.int32[:],
+        types.float32[:],
+        types.int64,
+    )
+)
+def randint_constrained_numba(
+    n: np.int32,
+    k: np.int32,
+    con_values: np.ndarray[np.int32],
+    con_indices: np.ndarray[np.int32],
+    p: np.ndarray[np.float32] = np.zeros(0, dtype=np.float32),
+    seed: np.int64 = 0,
+) -> np.ndarray[np.int32]:
+    """
+    Numba version of randint_constrained, which is 10-100x faster than the pure Python version.
+
+    Generate `k` unique random integers from the range `[0, n)` while satisfying given constraints.
+
+    `con_values` & `con_indices` can be obtained by using the `to_numpy` method of the [Constraints][max_div.constraints.constraints.Constraints] class.
+
+    For benchmark results, see [here](../../../../benchmarks/randint_constrained.md)
+
+    :param n: range to sample from [0, n)
+    :param k: number of unique samples to draw (no replacement)
+    :param con_values: 2D array (n_cons, 2) with min_count and max_count for each constraint
+    :param con_indices: 1D array with constraint indices in the format described in _constraints.py
+    :param p: optional, target probabilities for each integer in `[0, n)`
+    :param seed: random seed
+    :return: array of samples
+    """
+    # --- initialize --------------------------------------
+    samples = np.empty(k, dtype=np.int32)
+    k_remaining = k
+    n_cons = con_values.shape[0]
+
+    # Make a copy of con_values to track current min/max counts
+    con_values_working = con_values.copy()
+
+    sample_idx = np.int32(0)
+
+    # --- sample ------------------------------------------
+    while k_remaining > 0:
+        # --- score & thresholds ----------------
+
+        # Get already sampled integers
+        already_sampled = samples[:sample_idx]
+
+        # determine how much each integer would help us satisfy min_count constraints
+        score = _compute_score_numba(n, con_values_working, con_indices, already_sampled, True)
+
+        # determine how much improvement we need to be able to satisfy all min_count constraints
+        total_score_needed = np.int32(0)
+        for i_con in range(n_cons):
+            min_val = _np_con_min_value(con_values_working, np.int32(i_con))
+            if min_val > 0:
+                total_score_needed += min_val
+
+        score_threshold = np.int32((total_score_needed + k_remaining - 1) // k_remaining)  # ceil division
+
+        max_score = np.int32(-(2**30))
+        for s in score:
+            if s > max_score:
+                max_score = s
+
+        if max_score >= score_threshold:
+            # STRATEGY 1: focus on those samples that help satisfy constraints
+            pass
+        else:
+            # STRATEGY 2: choose samples with best net effect
+            score = _compute_score_numba(n, con_values_working, con_indices, already_sampled, False)
+            max_score = np.int32(-(2**30))
+            for s in score:
+                if s > max_score:
+                    max_score = s
+            score_threshold = max_score
+
+        # --- sample according to strategy ------
+        # construct modified probabilities
+        if p.size == 0:
+            p_mod = np.ones(n, dtype=np.float32)
+        else:
+            p_mod = p.copy()
+
+        # make sure no p_mod is == 0
+        max_p = np.float32(0.0)
+        for val in p_mod:
+            if val > max_p:
+                max_p = val
+        min_p = np.float32(1e-12 * max_p)
+        for i in range(n):
+            if p_mod[i] < min_p:
+                p_mod[i] = min_p
+
+        # zero out probabilities for scores below threshold
+        for i in range(n):
+            if score[i] < score_threshold:
+                p_mod[i] = np.float32(0.0)
+
+        # sample one integer
+        result = randint_numba(n, np.int32(1), False, p_mod, seed)
+        s = result[0]
+
+        # --- update stats --------------------------------
+        for i_con in range(n_cons):
+            indices = _np_con_indices(con_indices, np.int32(i_con))
+            for idx in indices:
+                if idx == s:
+                    # Decrement both min and max count for this constraint
+                    con_values_working[i_con, 0] -= 1
+                    con_values_working[i_con, 1] -= 1
+                    break
+
+        samples[sample_idx] = s
+        sample_idx += 1
+        k_remaining -= 1
+
+    # --- done ----------------------------------------
+    return samples

max_div/sampling/uncon.py

@@ -0,0 +1,269 @@
+"""
+Methods for sampling WITHOUT constraints.
+"""
+
+import numba
+import numpy as np
+
+from max_div.internal.math.fast_log import fast_log2_f32_poly
+from max_div.internal.math.random import (
+    rand_float32,
+    rand_int32,
+    rand_int32_array,
+    set_seed,
+)
+from max_div.internal.math.select_k_minmax import select_k_min
+
+
+# =================================================================================================
+#  randint
+# =================================================================================================
+def randint(
+    n: int,
+    k: int | None = None,
+    replace: bool = True,
+    p: np.ndarray[np.float32] | 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.
+
+    Depending on the value of `use_numba`, computations are executed by...
+
+    - `use_numba=False`: see [randint_numpy][max_div.sampling.uncon.randint_numpy]
+    - `use_numba=True`: see [randint_numba][max_div.sampling.uncon.randint_numba]
+
+    NOTES:
+
+    * If you're looking for a way to impose constraints (e.g. sample at least 2 from set {2, 4, 7, 11}),
+      check out [`randint_constrained`][max_div.sampling.con.randint_constrained].
+
+    :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.
+              (if `None` or size==0, uniform sampling is performed)
+    :param seed: Optional random seed for reproducibility. If `None` or 0, no seed is set.
+    :param use_numba: Use the custom numba-accelerated implementation, otherwise we use `np.random.choice`.
+    :return: `k=None` --> single integer; `k>=1` --> (k,)-sized array with sampled integers.
+    """
+    n = np.int32(n)
+    k = np.int32(k) if k is not None else None
+
+    if not use_numba:
+        return randint_numpy(n=n, k=k, replace=replace, p=p, seed=seed)
+
+    else:
+        # NOTE: minimal validation to make sure numba doesn't fail to compile
+        if (p is not None) and p.ndim != 1:
+            raise ValueError(f"p must be a 1D array. (here: ndim={p.ndim})")
+
+        # NOTE: we need a few if-clauses, since numba does not support optional arguments
+
+        if k is None:
+            # assume k=1 and return an integer
+            if p is None:
+                return randint_numba(n=n, k=1, replace=replace, seed=seed or 0)[0]
+            else:
+                return randint_numba(n=n, k=1, replace=replace, p=p, seed=seed or 0)[0]
+
+        else:
+            # k is specified, return array
+            if p is None:
+                return randint_numba(n=n, k=k, replace=replace, seed=seed or 0)
+            else:
+                return randint_numba(n=n, k=k, replace=replace, p=p, seed=seed or 0)
+
+
+# =================================================================================================
+#  randint_numpy
+# =================================================================================================
+def randint_numpy(
+    n: np.int32,
+    k: np.int32 | None = None,
+    replace: bool = True,
+    p: np.ndarray[float] | None = None,
+    seed: np.int64 | None = None,
+) -> np.int32 | np.ndarray[np.int32]:
+    """
+    Randomly sample `k` integers from range `[0, n-1]`, optionally with replacement and per-value probabilities.
+
+    This will always use `np.random.choice` for sampling and is intended to be used to compare against the
+    numba-accelerated version.  For production-use, use `randint_numba` or `randint` with `accelerated=True`.
+
+    :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 should have non-negative values. Sum is not require to be 1.
+    :param seed: Optional random seed for reproducibility.  If `None` or 0, no seed is set.
+    :return: `k=None` --> single integer; `k>=1` --> (k,)-sized array with sampled integers.
+    """
+
+    # --- 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.")
+    if p is not None:
+        if (p.size > 0) and (p.size != n):
+            raise ValueError(f"p must be of size n=0 or n={n}. (here: size={p.size})")
+        elif p.size == 0:
+            p = None  # indicate no probabilities specified
+
+    # --- sampling ------------------------------------
+    if seed:
+        np.random.seed(seed)
+    if p is not None:
+        p = p * (1.0 / np.sum(p))  # normalize probabilities
+
+    if k is None:
+        # returns scalar
+        return np.int32(np.random.choice(n, size=None, replace=replace, p=p))
+    else:
+        # returns array
+        return np.random.choice(n, size=k, replace=replace, p=p).astype(np.int32)
+
+
+# =================================================================================================
+#  randint_numba
+# =================================================================================================
+@numba.njit(fastmath=True)
+def randint_numba(
+    n: np.int32,
+    k: np.int32,
+    replace: bool,
+    p: np.ndarray[np.float32] = np.zeros(0, dtype=np.float32),
+    seed: np.int64 = 0,
+) -> np.ndarray[np.int32]:
+    """
+    Randomly sample `k` integers from range `[0, n-1]`, optionally with replacement and per-value probabilities.
+
+    This is a custom numba, speed-optimized implementation, using a different algorithm depending on the case:
+
+    | `p` specified  | `replace`  | `k`   | Method Used                              | Complexity      |
+    |----------------|------------|-------|------------------------------------------|-----------------|
+    | No             | `True`     | *any* | `np.random.randint`, uniform sampling    | O(k)            |
+    | No             | `False`    | *any* | k-element Fisher-Yates shuffle           | O(n)            |
+    | Yes            | *any*      | 1     | Multinomial sampling using CDF           | O(n + log(n))   |
+    | Yes            | `True`     | >1    | Multinomial sampling using CDF           | O(n + k log(n)) |
+    | Yes            | `False`    | >1    | Efraimidis-Spirakis sampling + exponential key sampling (Gumbel-Max Trick).  | O(n) |
+
+    NOTES:
+
+     - using the np.random.Generator API incurs an extra 3-4 μsec overhead per call compared to using the legacy
+       np.random functions. The main reason is that the new interface requires calls through the numpy C-API, while the
+       legacy functions are re-implemented in Numba and compiled together with the rest of the numba-accelerated code.
+       Instantiating a Generator incurs a ~10 μsec penalty, so should also be avoided to be done repeatedly.
+
+     - given the intended use-case within max_div, it is acceptable that provided probabilities are only approximately
+       taken into account.  Therefore, we use float32 representation and use a fast-approx-log function in the
+       Efraimidis-Spirakis sampling method.  Overall this can result in <1% deviation from target probabilities, i.e.
+         p[3] = 0.1 --> actual frequency in samples = [0.099 to 0.101].
+
+    <br>
+
+    :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 should have non-negative values. Sum is not require to be 1.
+              NOTE: if size is 0, indicates no probabilities specified.  (=DEFAULT)
+                    if size > 0, but not equal to max_value+1, a ValueError is raised.
+    :param seed: (default=0) Optional random seed for reproducibility. If `None` or 0, no seed is set.
+    :return: (k,)-sized array with sampled integers.
+    """
+
+    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 k == 1:
+        replace = True  # single sample, replacement makes no difference, so we can fall back to faster methods
+    elif (not replace) and (k > n):
+        raise ValueError(f"Cannot sample {k} unique values from range [0, {n}) without replacement.")
+
+    if seed != 0:
+        rng_state = set_seed(seed)
+    else:
+        rng_state = set_seed(np.random.randint(1, 1_000_000_000_000))
+
+    if p.size == 0:
+        if replace:
+            # UNIFORM sampling with replacement
+            return rand_int32_array(rng_state, 0, n, k)  # O(k)
+            # samples = np.empty(k, dtype=np.int32)
+            # for i in range(k):
+            #     samples[i] = rand_int32(rng_state, 0, n)
+            # return samples
+        else:
+            # UNIFORM sampling without replacement using Fisher-Yates shuffle
+            population = np.arange(n, dtype=np.int32)  # O(n)
+            for i in range(k):  # k x O(1)
+                j = rand_int32(rng_state, i, n)
+                population[i], population[j] = population[j], population[i]
+            return population[:k]  # O(k)
+
+    elif p.size == n:
+        if replace:
+            # NON-UNIFORM sampling with replacement using CDF
+            cdf = np.cumsum(p)  # O(n)
+            p_sum = cdf[-1]
+            samples = np.empty(k, dtype=np.int32)  # O(k)
+            # notes:
+            #  - computing the below in a loop, is faster than writing a np-vectorized one-liner
+            #  - implementing & calling a rand_float32_array outside the loop once is not faster
+            for i in range(k):  # k x O(log(n))
+                r = rand_float32(rng_state) * p_sum
+                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:         INVESTIGATE: 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.
+            #                     (Initial testing surprisingly did not show improvements)
+            if k < n:
+                keys = np.empty(n, dtype=np.float32)  # O(n)
+                # notes:
+                #  - computing -np.log(u[i]) does not seem to be noticeably slower than np.random.standard_exponential().
+                #  - implementing & calling a rand_float32_array outside the loop once is not faster
+                for i in range(n):  # n x O(1)
+                    if p[i] == 0.0:
+                        keys[i] = np.inf
+                    else:
+                        ui = rand_float32(rng_state)
+                        # NOTE: we use a fast log2 approximation here for speed; log2 vs log is irrelevant since
+                        #       it's just a scaling factor, and we are only interested in the order of the final list
+                        keys[i] = -fast_log2_f32_poly(ui, degree=2) / p[i]  # using fast log2 approximation
+
+                # Get indices of k smallest keys
+                if k <= (10 + n // 20):
+                    return select_k_min(keys, np.int32(k))  # most efficient for small k and k/n
+                else:
+                    return np.argpartition(keys, k)[:k].astype(np.int32)  # O(n) average case
+
+            else:
+                # corner case: return all elements in random order
+                # to this end we perform 1 full Fisher-Yates shuffle
+                population = np.arange(n, dtype=np.int32)  # O(n)
+                for i in range(n):  # n x O(1)
+                    j = rand_int32(rng_state, i, n)
+                    population[i], population[j] = population[j], population[i]
+                return population[:k]  # O(k)
+
+    else:
+        raise ValueError(f"p must be of size 0 (no probabilities) or size n={n}. (here: size={p.size})")

{max_div-0.0.3.dist-info → max_div-0.1.1.dist-info}/METADATA

@@ -1,16 +1,21 @@
 Metadata-Version: 2.4
 Name: max-div
-Version: 0.0.3
-Summary: Flexible Solver for Maximum Diversity Problems with Fairness Constraints.
+Version: 0.1.1
+Summary: Configurable Solver for Maximum Diversity Problems with Fairness Constraints.
 Project-URL: Documentation, https://max-div.readthedocs.io/
 Project-URL: Source, https://github.com/bertpl/max-div
-Project-URL: ChangeLog, https://github.com/bertpl/max-div/blob/develop/CHANGELOG.md
+Project-URL: ChangeLog, https://github.com/bertpl/max-div/blob/main/CHANGELOG.md
 Project-URL: Issues, https://github.com/bertpl/max-div/issues
 Project-URL: Roadmap, https://github.com/bertpl/max-div/milestones
 Author-email: Bert Pluymers <bert.pluymers@gmail.com>
 License-File: LICENSE
 Requires-Python: >=3.11
+Requires-Dist: click>=8.2.0
+Requires-Dist: icc-rt; platform_machine == 'x86_64' and platform_system == 'Linux'
+Requires-Dist: intel-cmplr-lib-rt; platform_machine == 'x86_64' and platform_system == 'Linux'
+Requires-Dist: numba>=0.57
 Requires-Dist: numpy>=2.0.0
+Requires-Dist: tqdm>=4.66.0
 Provides-Extra: docs
 Requires-Dist: mkdocs-autoapi[python]>=0.4.1; extra == 'docs'
 Requires-Dist: mkdocs-include-markdown-plugin>=7.2.0; extra == 'docs'
@@ -18,14 +23,14 @@ Requires-Dist: mkdocs-material>=9.0.0; extra == 'docs'
 Requires-Dist: mkdocs>=1.6.1; extra == 'docs'
 Requires-Dist: mkdocstrings[python]>=0.24.0; extra == 'docs'
 Requires-Dist: ruff>=0.14.0; extra == 'docs'
-Provides-Extra: numba
-Requires-Dist: numba>=0.57; extra == 'numba'
 Description-Content-Type: text/markdown
 
 ![shields.io-python-versions](https://img.shields.io/badge/python-3.11%20%7C%203.12%20%7C%203.13-blue)
-![genbadge-test-count](https://bertpl.github.io/max-div/version_artifacts/release/v0.0.3/badge-test-count.svg)
-![genbadge-test-coverage](https://bertpl.github.io/max-div/version_artifacts/release/v0.0.3/badge-coverage.svg)
-![max-div logo](https://bertpl.github.io/max-div/version_artifacts/release/v0.0.3/splash.webp)
+![genbadge-test-count](https://bertpl.github.io/max-div/version_artifacts/release/v0.1.1/badge-test-count.svg)
+![genbadge-test-coverage](https://bertpl.github.io/max-div/version_artifacts/release/v0.1.1/badge-coverage.svg)
+<p>
+  <img src="https://bertpl.github.io/max-div/version_artifacts/release/v0.1.1/splash.webp" alt="max-div logo" style="max-width: max(60%, min(100%,800px)); height: auto;">
+</p>
 
 # max-div
 Configurable Solver for Maximum Diversity Problems with Fairness Constraints.