scipy 1.15.3__cp313-cp313t-win_amd64.whl → 1.16.0rc2__cp313-cp313t-win_amd64.whl

scipy/stats/_page_trend_test.py

@@ -1,9 +1,12 @@
+from dataclasses import dataclass
 from itertools import permutations
-import numpy as np
 import math
+import threading
+
+import numpy as np
+
 from ._continuous_distns import norm
 import scipy.stats
-from dataclasses import dataclass
 
 
 @dataclass
@@ -304,6 +307,8 @@ def page_trend_test(data, ranked=False, predicted_ranks=None, method='auto'):
                         method='exact')
 
     """
+    if not hasattr(_pagel_state, 'state'):
+        _pagel_state.state = _PageL()
 
     # Possible values of the method parameter and the corresponding function
     # used to evaluate the p value
@@ -405,8 +410,8 @@ def _l_p_exact(L, m, n):
     # [1] uses m, n; [5] uses n, k.
     # Switch convention here because exact calculation code references [5].
     L, n, k = int(L), int(m), int(n)
-    _pagel_state.set_k(k)
-    return _pagel_state.sf(L, n)
+    _pagel_state.state.set_k(k)
+    return _pagel_state.state.sf(L, n)
 
 
 class _PageL:
@@ -476,4 +481,6 @@ class _PageL:
 
 
 # Maintain state for faster repeat calls to page_trend_test w/ method='exact'
-_pagel_state = _PageL()
+# _PageL() is calculated once per thread and stored as an attribute on
+# this thread-local variable inside page_trend_test().
+_pagel_state = threading.local()

scipy/stats/_probability_distribution.py

@@ -30,8 +30,8 @@ class _ProbabilityDistribution(ABC):
         Notes
         -----
         Suppose a continuous probability distribution has support ``(l, r)``.
-        The following table summarizes the value returned by methods
-        of ``ContinuousDistribution`` for arguments outside the support.
+        The following table summarizes the value returned by several
+        methods when the argument is outside the support.
 
         +----------------+---------------------+---------------------+
         | Method         | Value for ``x < l`` | Value for ``x > r`` |
@@ -49,13 +49,16 @@ class _ProbabilityDistribution(ABC):
         | ``logccdf(x)`` | 0                   | -inf                |
         +----------------+---------------------+---------------------+
 
-        For the ``cdf`` and related methods, the inequality need not be
-        strict; i.e. the tabulated value is returned when the method is
-        evaluated *at* the corresponding boundary.
+        For discrete distributions, the same table is applicable with
+        ``pmf`` and ``logpmf`` substituted for ``pdf`` and ``logpdf``.
+
+        For the ``cdf`` and related methods of continuous distributions, the
+        inequality need not be strict; i.e. the tabulated value is returned
+        when the method is evaluated *at* the corresponding boundary.
 
         The following table summarizes the value returned by the inverse
-        methods of ``ContinuousDistribution`` for arguments at the boundaries
-        of the domain ``0`` to ``1``.
+        methods for arguments ``0`` and ``1``, whether the distribution
+        is continuous or discrete.
 
         +-------------+-----------+-----------+
         | Method      | ``x = 0`` | ``x = 1`` |
@@ -65,7 +68,7 @@ class _ProbabilityDistribution(ABC):
         | ``icdf(x)`` | ``r``     | ``l``     |
         +-------------+-----------+-----------+
 
-        For the inverse log-functions, the same values are returned for
+        For the inverse log-functions, the same values are returned
         for ``x = log(0)`` and ``x = log(1)``. All inverse functions return
         ``nan`` when evaluated at an argument outside the domain ``0`` to ``1``.
 
@@ -173,7 +176,7 @@ class _ProbabilityDistribution(ABC):
 
         In terms of probability density function :math:`f(x)` and support
         :math:`\chi`, the "raw" moment (about the origin) of order :math:`n` of
-        a random variable :math:`X` is:
+        a continuous random variable :math:`X` is:
 
         .. math::
 
@@ -195,6 +198,9 @@ class _ProbabilityDistribution(ABC):
             \tilde{\mu}_n(X) = \frac{\mu_n(X)}
                                     {\sigma^n}
 
+        The definitions for discrete random variables are analogous, with
+        sums over the support replacing the integrals.
+        
         Parameters
         ----------
         order : int
@@ -217,7 +223,8 @@ class _ProbabilityDistribution(ABC):
               vice versa (see Notes)
             - ``'normalize'``: normalize a central moment to get a standardized
               or vice versa
-            - ``'quadrature'``: numerically integrate according to the definition
+            - ``'quadrature'``: numerically integrate (or, in the discrete case, sum)
+              according to the definition
 
             Not all `method` options are available for all orders, kinds, and
             distributions. If the selected `method` is not available, a
@@ -365,15 +372,19 @@ class _ProbabilityDistribution(ABC):
 
     @abstractmethod
     def median(self, *, method):
-        r"""Median (50th percentil)
+        r"""Median (50th percentile)
 
         If a continuous random variable :math:`X` has probability :math:`0.5` of
         taking on a value less than :math:`m`, then :math:`m` is the median.
-        That is, the median is the value :math:`m` for which:
+
+        More generally, a median is a value :math:`m` for which:
 
         .. math::
 
-            P(X ≤ m) = 0.5 = P(X ≥ m)
+            P(X ≤ m) ≤ 0.5 ≥ P(X ≥ m)
+
+        For discrete random variables, the median may not be unique, in which
+        case the smallest value satisfying the definition is reported.
 
         Parameters
         ----------
@@ -428,8 +439,8 @@ class _ProbabilityDistribution(ABC):
 
         Informally, the mode is a value that a random variable has the highest
         probability (density) of assuming. That is, the mode is the element of
-        the support :math:`\chi` that maximizes the probability density
-        function :math:`f(x)`:
+        the support :math:`\chi` that maximizes the probability density (or mass,
+        for discrete random variables) function :math:`f(x)`:
 
         .. math::
 
@@ -443,7 +454,7 @@ class _ProbabilityDistribution(ABC):
             following options, listed in order of precedence.
 
             - ``'formula'``: use a formula for the median
-            - ``'optimization'``: numerically maximize the PDF
+            - ``'optimization'``: numerically maximize the PDF/PMF
 
             Not all `method` options are available for all distributions.
             If the selected `method` is not available, a ``NotImplementedError``
@@ -465,7 +476,7 @@ class _ProbabilityDistribution(ABC):
         For some distributions
 
         #. the mode is not unique (e.g. the uniform distribution);
-        #. the PDF has one or more singularities, and it is debateable whether
+        #. the PDF has one or more singularities, and it is debatable whether
            a singularity is considered to be in the domain and called the mode
            (e.g. the gamma distribution with shape parameter less than 1); and/or
         #. the probability density function may have one or more local maxima
@@ -737,9 +748,12 @@ class _ProbabilityDistribution(ABC):
         By definition of the support, the PDF evaluates to its minimum value
         of :math:`0` outside the support; i.e. for :math:`x < l` or
         :math:`x > r`. The maximum of the PDF may be less than or greater than
-        :math:`1`; since the valus is a probability *density*, only its integral
+        :math:`1`; since the value is a probability *density*, only its integral
         over the support must equal :math:`1`.
 
+        For discrete distributions, `pdf` returns ``inf`` at supported points
+        and ``0`` elsewhere.
+
         References
         ----------
         .. [1] Probability density function, *Wikipedia*,
@@ -823,6 +837,9 @@ class _ProbabilityDistribution(ABC):
         to work with the logarithms of probabilities and probability densities to
         avoid underflow.
 
+        For discrete distributions, `logpdf` returns ``inf`` at supported points and
+        ``-inf`` (``log(0)``) elsewhere.
+
         References
         ----------
         .. [1] Probability density function, *Wikipedia*,
@@ -846,6 +863,156 @@ class _ProbabilityDistribution(ABC):
         """
         raise NotImplementedError()
 
+    def pmf(self, x, /, *, method=None):
+        r"""Probability mass function
+
+        The probability mass function ("PMF"), denoted :math:`f(x)`, is the
+        probability that the random variable :math:`X` will assume the value :math:`x`.
+
+        .. math::
+
+            f(x) = P(X = x)
+
+        `pmf` accepts `x` for :math:`x`.
+
+        Parameters
+        ----------
+        x : array_like
+            The argument of the PMF.
+        method : {None, 'formula', 'logexp'}
+            The strategy used to evaluate the PMF. By default (``None``), the
+            infrastructure chooses between the following options, listed in
+            order of precedence.
+
+            - ``'formula'``: use a formula for the PMF itself
+            - ``'logexp'``: evaluate the log-PMF and exponentiate
+
+            Not all `method` options are available for all distributions.
+            If the selected `method` is not available, a ``NotImplementedError``
+            will be raised.
+
+        Returns
+        -------
+        out : array
+            The PMF evaluated at the argument `x`.
+
+        See Also
+        --------
+        cdf
+        logpmf
+
+        Notes
+        -----
+        Suppose a discrete probability distribution has support over the integers
+        :math:`{l, l+1, ..., r-1, r}`.
+        By definition of the support, the PMF evaluates to its minimum value
+        of :math:`0` for non-integral :math:`x` and for :math:`x` outside the support;
+        i.e. for :math:`x < l` or :math:`x > r`.
+
+        For continuous distributions, `pmf` returns ``0`` at all real arguments.
+
+        References
+        ----------
+        .. [1] Probability mass function, *Wikipedia*,
+               https://en.wikipedia.org/wiki/Probability_mass_function
+
+        Examples
+        --------
+        Instantiate a distribution with the desired parameters:
+
+        >>> from scipy import stats
+        >>> X = stats.Binomial(n=10, p=0.5)
+
+        Evaluate the PMF at the desired argument:
+
+        >>> X.pmf(5)
+        np.float64(0.24609375)
+
+        """
+        raise NotImplementedError()
+
+    def logpmf(self, x, /, *, method=None):
+        r"""Log of the probability mass function
+
+        The probability mass function ("PMF"), denoted :math:`f(x)`, is the
+        probability that the random variable :math:`X` will assume the value :math:`x`.
+
+        .. math::
+
+            f(x) = \frac{d}{dx} F(x)
+
+        `logpmf` computes the logarithm of the probability mass function
+        ("log-PMF"), :math:`\log(f(x))`, but it may be numerically favorable
+        compared to the naive implementation (computing :math:`f(x)` and
+        taking the logarithm).
+
+        `logpmf` accepts `x` for :math:`x`.
+
+        Parameters
+        ----------
+        x : array_like
+            The argument of the log-PMF.
+        method : {None, 'formula', 'logexp'}
+            The strategy used to evaluate the log-PMF. By default (``None``), the
+            infrastructure chooses between the following options, listed in order
+            of precedence.
+
+            - ``'formula'``: use a formula for the log-PMF itself
+            - ``'logexp'``: evaluate the PMF and takes its logarithm
+
+            Not all `method` options are available for all distributions.
+            If the selected `method` is not available, a ``NotImplementedError``
+            will be raised.
+
+        Returns
+        -------
+        out : array
+            The log-PMF evaluated at the argument `x`.
+
+        See Also
+        --------
+        pmf
+        logcdf
+
+        Notes
+        -----
+        Suppose a discrete probability distribution has support over the integers
+        :math:`{l, l+1, ..., r-1, r}`.
+        By definition of the support, the log-PMF evaluates to its minimum value
+        of :math:`-\infty` (i.e. :math:`\log(0)`) for non-integral :math:`x` and
+        for :math:`x` outside the support; i.e. for :math:`x < l` or :math:`x > r`.
+
+        For distributions with infinite support, it is common for `pmf` to return
+        a value of ``0`` when the argument is theoretically within the support;
+        this can occur because the true value of the PMF is too small to be
+        represented by the chosen dtype. The log-PMF, however, will often be finite
+        (not ``-inf``) over a much larger domain. Consequently, it may be preferred
+        to work with the logarithms of probabilities and probability densities to
+        avoid underflow.
+
+        References
+        ----------
+        .. [1] Probability density function, *Wikipedia*,
+               https://en.wikipedia.org/wiki/Probability_density_function
+
+        Examples
+        --------
+        Instantiate a distribution with the desired parameters:
+
+        >>> import numpy as np
+        >>> from scipy import stats
+        >>> X = stats.Binomial(n=10, p=0.5)
+
+        Evaluate the log-PMF at the desired argument:
+
+        >>> X.logpmf(5)
+        np.float64(-1.4020427180880297)
+        >>> np.allclose(X.logpmf(5), np.log(X.pmf(5)))
+        True
+
+        """
+        raise NotImplementedError()
+
     @abstractmethod
     def cdf(self, x, y, /, *, method):
         r"""Cumulative distribution function
@@ -880,7 +1047,8 @@ class _ProbabilityDistribution(ABC):
             - ``'formula'``: use a formula for the CDF itself
             - ``'logexp'``: evaluate the log-CDF and exponentiate
             - ``'complement'``: evaluate the CCDF and take the complement
-            - ``'quadrature'``: numerically integrate the PDF
+            - ``'quadrature'``: numerically integrate the PDF (or, in the discrete
+              case, sum the PMF)
 
             In place of ``'complement'``, the two-argument form accepts:
 
@@ -920,6 +1088,17 @@ class _ProbabilityDistribution(ABC):
         The CDF evaluates to its minimum value of :math:`0` for :math:`x ≤ l`
         and its maximum value of :math:`1` for :math:`x ≥ r`.
 
+        Suppose a discrete probability distribution has support :math:`[l, r]`.
+        The CDF :math:`F(x)` is related to the probability mass function
+        :math:`f(x)` by:
+
+        .. math::
+
+            F(x) = \sum_{u=l}^{\lfloor x \rfloor} f(u)
+
+        The CDF evaluates to its minimum value of :math:`0` for :math:`x < l`
+        and its maximum value of :math:`1` for :math:`x ≥ r`.
+        
         The CDF is also known simply as the "distribution function".
 
         References
@@ -951,14 +1130,24 @@ class _ProbabilityDistribution(ABC):
     def icdf(self, p, /, *, method):
         r"""Inverse of the cumulative distribution function.
 
-        The inverse of the cumulative distribution function ("inverse CDF"),
-        denoted :math:`F^{-1}(p)`, is the argument :math:`x` for which the
-        cumulative distribution function :math:`F(x)` evaluates to :math:`p`.
+        For monotonic continuous distributions, the inverse of the cumulative
+        distribution function ("inverse CDF"), denoted :math:`F^{-1}(p)`, is the
+        argument :math:`x` for which the cumulative distribution function
+        :math:`F(x)` evaluates to :math:`p`.
 
         .. math::
 
             F^{-1}(p) = x \quad \text{s.t.} \quad F(x) = p
 
+        When a strict "inverse" of the cumulative distribution function does not
+        exist (e.g. discrete random variables), the "inverse CDF" is defined by
+        convention as the smallest value within the support :math:`\chi` for which
+        :math:`F(x)` is at least :math:`p`.
+
+        .. math::
+
+            F^{-1}(p) = \min_\chi \quad \text{s.t.} \quad F(x) ≥ p
+
         `icdf` accepts `p` for :math:`p \in [0, 1]`.
 
         Parameters
@@ -992,7 +1181,7 @@ class _ProbabilityDistribution(ABC):
 
         Notes
         -----
-        Suppose a continuous probability distribution has support :math:`[l, r]`. The
+        Suppose a probability distribution has support :math:`[l, r]`. The
         inverse CDF returns its minimum value of :math:`l` at :math:`p = 0`
         and its maximum value of :math:`r` at :math:`p = 1`. Because the CDF
         has range :math:`[0, 1]`, the inverse CDF is only defined on the
@@ -1063,7 +1252,8 @@ class _ProbabilityDistribution(ABC):
             - ``'formula'``: use a formula for the CCDF itself
             - ``'logexp'``: evaluate the log-CCDF and exponentiate
             - ``'complement'``: evaluate the CDF and take the complement
-            - ``'quadrature'``: numerically integrate the PDF
+            - ``'quadrature'``: numerically integrate the PDF (or, in the discrete
+              case, sum the PMF)
 
             The two-argument form chooses between:
 
@@ -1103,6 +1293,17 @@ class _ProbabilityDistribution(ABC):
         The CCDF returns its minimum value of :math:`0` for :math:`x ≥ r`
         and its maximum value of :math:`1` for :math:`x ≤ l`.
 
+        Suppose a discrete probability distribution has support :math:`[l, r]`.
+        The CCDF :math:`G(x)` is related to the probability mass function
+        :math:`f(x)` by:
+
+        .. math::
+
+            G(x) = \sum_{u=\lfloor x + 1 \rfloor}^{r} f(u)
+
+        The CCDF evaluates to its minimum value of :math:`0` for :math:`x ≥ r`
+        and its maximum value of :math:`1` for :math:`x < l`.
+        
         The CCDF is also known as the "survival function".
 
         References
@@ -1146,6 +1347,15 @@ class _ProbabilityDistribution(ABC):
 
             G^{-1}(p) = x \quad \text{s.t.} \quad G(x) = p
 
+        When a strict "inverse" of the complementary cumulative distribution function
+        does not exist (e.g. discrete random variables), the "inverse CCDF" is defined
+        by convention as the smallest value within the support :math:`\chi` for which
+        :math:`G(x)` is no greater than :math:`p`.
+
+        .. math::
+
+            G^{-1}(p) = \min_\chi \quad \text{s.t.} \quad G(x) ≤ p
+
         `iccdf` accepts `p` for :math:`p \in [0, 1]`.
 
         Parameters
@@ -1174,7 +1384,7 @@ class _ProbabilityDistribution(ABC):
 
         Notes
         -----
-        Suppose a continuous probability distribution has support :math:`[l, r]`. The
+        Suppose a probability distribution has support :math:`[l, r]`. The
         inverse CCDF returns its minimum value of :math:`l` at :math:`p = 1`
         and its maximum value of :math:`r` at :math:`p = 0`. Because the CCDF
         has range :math:`[0, 1]`, the inverse CCDF is only defined on the
@@ -1249,7 +1459,8 @@ class _ProbabilityDistribution(ABC):
             - ``'logexp'``: evaluate the CDF and take the logarithm
             - ``'complement'``: evaluate the log-CCDF and take the
               logarithmic complement (see Notes)
-            - ``'quadrature'``: numerically log-integrate the log-PDF
+            - ``'quadrature'``: numerically log-integrate the log-PDF (or, in the
+              discrete case, log-sum the log-PMF)
 
             In place of ``'complement'``, the two-argument form accepts:
 
@@ -1275,7 +1486,8 @@ class _ProbabilityDistribution(ABC):
         Suppose a continuous probability distribution has support :math:`[l, r]`.
         The log-CDF evaluates to its minimum value of :math:`\log(0) = -\infty`
         for :math:`x ≤ l` and its maximum value of :math:`\log(1) = 0` for
-        :math:`x ≥ r`.
+        :math:`x ≥ r`. An analogous statement can be made for discrete distributions,
+        but the inequality governing the minimum value is strict.
 
         For distributions with infinite support, it is common for
         `cdf` to return a value of ``0`` when the argument
@@ -1368,7 +1580,7 @@ class _ProbabilityDistribution(ABC):
 
         Notes
         -----
-        Suppose a continuous probability distribution has support :math:`[l, r]`.
+        Suppose a probability distribution has support :math:`[l, r]`.
         The inverse log-CDF returns its minimum value of :math:`l` at
         :math:`\log(p) = \log(0) = -\infty` and its maximum value of :math:`r` at
         :math:`\log(p) = \log(1) = 0`. Because the log-CDF has range
@@ -1418,7 +1630,7 @@ class _ProbabilityDistribution(ABC):
 
             G(x) = 1 - F(x) = P(X > x)
 
-        A two-argument variant of this function is:
+         A two-argument variant of this function is:
 
         .. math::
 
@@ -1444,7 +1656,8 @@ class _ProbabilityDistribution(ABC):
             - ``'logexp'``: evaluate the CCDF and take the logarithm
             - ``'complement'``: evaluate the log-CDF and take the
               logarithmic complement (see Notes)
-            - ``'quadrature'``: numerically log-integrate the log-PDF
+            - ``'quadrature'``: numerically log-integrate the log-PDF (or, in the
+              discrete case, log-sum the log-PMF)
 
             The two-argument form chooses between:
 
@@ -1471,7 +1684,8 @@ class _ProbabilityDistribution(ABC):
         Suppose a continuous probability distribution has support :math:`[l, r]`.
         The log-CCDF returns its minimum value of :math:`\log(0)=-\infty` for
         :math:`x ≥ r` and its maximum value of :math:`\log(1) = 0` for
-        :math:`x ≤ l`.
+        :math:`x ≤ l`. An analogous statement can be made for discrete distributions,
+        but the inequality governing the maximum value is strict.
 
         For distributions with infinite support, it is common for
         `ccdf` to return a value of ``0`` when the argument
@@ -1554,7 +1768,7 @@ class _ProbabilityDistribution(ABC):
 
         Notes
         -----
-        Suppose a continuous probability distribution has support :math:`[l, r]`. The
+        Suppose a probability distribution has support :math:`[l, r]`. The
         inverse log-CCDF returns its minimum value of :math:`l` at
         :math:`\log(p) = \log(1) = 0` and its maximum value of :math:`r` at
         :math:`\log(p) = \log(0) = -\infty`. Because the log-CCDF has range
@@ -1567,7 +1781,7 @@ class _ProbabilityDistribution(ABC):
         however, the *logarithm* of this resulting probability may be
         represented in floating point arithmetic, in which case this function
         may be used to find the argument of the CCDF for which the *logarithm*
-        of the resulting probability is `y = \log(p)`.
+        of the resulting probability is :math:`y = \log(p)`.
 
         The "logarithmic complement" of a number :math:`z` is mathematically
         equivalent to :math:`\log(1-\exp(z))`, but it is computed to avoid loss
@@ -1601,15 +1815,18 @@ class _ProbabilityDistribution(ABC):
         r"""Logarithm of the differential entropy
 
         In terms of probability density function :math:`f(x)` and support
-        :math:`\chi`, the differential entropy (or simply "entropy") of a random
-        variable :math:`X` is:
+        :math:`\chi`, the differential entropy (or simply "entropy") of a
+        continuous random variable :math:`X` is:
 
         .. math::
 
             h(X) = - \int_{\chi} f(x) \log f(x) dx
 
+        The definition for a discrete random variable is analogous, with the PMF
+        replacing the PDF and a sum over the support replacing the integral.
+
         `logentropy` computes the logarithm of the differential entropy
-        ("log-entropy"), :math:`log(h(X))`, but it may be numerically favorable
+        ("log-entropy"), :math:`\log(h(X))`, but it may be numerically favorable
         compared to the naive implementation (computing :math:`h(X)` then
         taking the logarithm).
 
@@ -1622,8 +1839,8 @@ class _ProbabilityDistribution(ABC):
 
             - ``'formula'``: use a formula for the log-entropy itself
             - ``'logexp'``: evaluate the entropy and take the logarithm
-            - ``'quadrature'``: numerically log-integrate the logarithm of the
-              entropy integrand
+            - ``'quadrature'``: numerically log-integrate (or, in the discrete
+              case, log-sum) the logarithm of the entropy integrand (summand)
 
             Not all `method` options are available for all distributions.
             If the selected `method` is not available, a ``NotImplementedError``
@@ -1641,9 +1858,9 @@ class _ProbabilityDistribution(ABC):
 
         Notes
         -----
-        If the entropy of a distribution is negative, then the log-entropy
-        is complex with imaginary part :math:`\pi`. For
-        consistency, the result of this function always has complex dtype,
+        The differential entropy of a continuous distribution can be negative.
+        In this case, the log-entropy is complex with imaginary part :math:`\pi`.
+        For consistency, the result of this function always has complex dtype,
         regardless of the value of the imaginary part.
 
         References
@@ -1675,7 +1892,7 @@ class _ProbabilityDistribution(ABC):
 
         """
         raise NotImplementedError()
-        
+
     @abstractmethod
     def entropy(self, *, method):
         r"""Differential entropy
@@ -1688,6 +1905,9 @@ class _ProbabilityDistribution(ABC):
 
             h(X) = - \int_{\chi} f(x) \log f(x) dx
 
+        The definition for a discrete random variable is analogous, with the
+        PMF replacing the PDF and a sum over the support replacing the integral.
+
         Parameters
         ----------
         method : {None, 'formula', 'logexp', 'quadrature'}
@@ -1697,7 +1917,9 @@ class _ProbabilityDistribution(ABC):
 
             - ``'formula'``: use a formula for the entropy itself
             - ``'logexp'``: evaluate the log-entropy and exponentiate
-            - ``'quadrature'``: use numerical integration
+            - ``'quadrature'``:  numerically integrate (or, in the discrete
+              case, sum) the entropy integrand (summand)
+
 
             Not all `method` options are available for all distributions.
             If the selected `method` is not available, a ``NotImplementedError``

scipy/stats/_qmc.py

@@ -20,7 +20,7 @@ from scipy._lib._util import DecimalNumber, GeneratorType, IntNumber, SeedType
 
 if TYPE_CHECKING:
     import numpy.typing as npt
-    
+
 import scipy.stats as stats
 from scipy._lib._util import rng_integers, _rng_spawn, _transition_to_rng
 from scipy.sparse.csgraph import minimum_spanning_tree
@@ -76,9 +76,9 @@ def check_random_state(seed=None):
         Random number generator.
 
     """
-    if seed is None or isinstance(seed, (numbers.Integral, np.integer)):
+    if seed is None or isinstance(seed, numbers.Integral | np.integer):
         return np.random.default_rng(seed)
-    elif isinstance(seed, (np.random.RandomState, np.random.Generator)):
+    elif isinstance(seed, np.random.RandomState | np.random.Generator):
         return seed
     else:
         raise ValueError(f'{seed!r} cannot be used to seed a'
@@ -266,7 +266,10 @@ def discrepancy(
     * ``MD``: Mixture Discrepancy - mix between CD/WD covering more criteria
     * ``L2-star``: L2-star discrepancy - like CD BUT variant to rotation
 
-    See [2]_ for precise definitions of each method.
+    Methods ``CD``, ``WD``, and ``MD`` implement the right hand side of equations
+    9, 10, and 18 of [2]_, respectively; the square root is not taken. On the
+    other hand, ``L2-star`` computes the quantity given by equation 10 of
+    [3]_ as implemented by subsequent equations; the square root is taken.
 
     Lastly, using ``iterative=True``, it is possible to compute the
     discrepancy as if we had :math:`n+1` samples. This is useful if we want
@@ -1117,14 +1120,16 @@ class Halton(QMCEngine):
     Pseudo-random number generator that generalize the Van der Corput sequence
     for multiple dimensions. The Halton sequence uses the base-two Van der
     Corput sequence for the first dimension, base-three for its second and
-    base-:math:`n` for its n-dimension.
+    base-:math:`p` for its :math:`n`-dimension, with :math:`p` the
+    :math:`n`'th prime.
 
     Parameters
     ----------
     d : int
         Dimension of the parameter space.
     scramble : bool, optional
-        If True, use Owen scrambling. Otherwise no scrambling is done.
+        If True, use random scrambling from [2]_. Otherwise no scrambling
+        is done.
         Default is True.
     optimization : {None, "random-cd", "lloyd"}, optional
         Whether to use an optimization scheme to improve the quality after
@@ -1584,7 +1589,7 @@ class LatinHypercube(QMCEngine):
         for j in range(n_col):
             perms = self.rng.permutation(p)
             oa_sample_[:, j] = perms[oa_sample[:, j]]
-        
+
         oa_sample = oa_sample_
         # following is making a scrambled OA into an OA-LHS
         oa_lhs_sample = np.zeros(shape=(n_row, n_col))
@@ -1858,7 +1863,7 @@ class Sobol(QMCEngine):
             # verify n is 2**n
             if not (n & (n - 1) == 0):
                 warnings.warn("The balance properties of Sobol' points require"
-                              " n to be a power of 2.", stacklevel=2)
+                              " n to be a power of 2.", stacklevel=3)
 
             if n == 1:
                 sample = self._first_point
@@ -2121,7 +2126,7 @@ class PoissonDisk(QMCEngine):
 
         # sample to generate per iteration in the hypersphere around center
         self.ncandidates = ncandidates
-        
+
         if u_bounds is None:
             u_bounds = np.ones(d)
         if l_bounds is None: