scipy 1.15.3__cp313-cp313-macosx_12_0_arm64.whl → 1.16.0rc2__cp313-cp313-macosx_12_0_arm64.whl

scipy/stats/_entropy.py

@@ -8,7 +8,8 @@ import math
 import numpy as np
 from scipy import special
 from ._axis_nan_policy import _axis_nan_policy_factory, _broadcast_arrays
-from scipy._lib._array_api import array_namespace, xp_moveaxis_to_end
+from scipy._lib._array_api import array_namespace, xp_promote
+from scipy._lib import array_api_extra as xpx
 
 __all__ = ['entropy', 'differential_entropy']
 
@@ -19,7 +20,7 @@ __all__ = ['entropy', 'differential_entropy']
         2 if ("qk" in kwgs and kwgs["qk"] is not None)
         else 1
     ),
-    n_outputs=1, result_to_tuple=lambda x: (x,), paired=True,
+    n_outputs=1, result_to_tuple=lambda x, _: (x,), paired=True,
     too_small=-1  # entropy doesn't have too small inputs
 )
 def entropy(pk: np.typing.ArrayLike,
@@ -169,7 +170,7 @@ def _differential_entropy_is_too_small(samples, kwargs, axis=-1):
 
 
 @_axis_nan_policy_factory(
-    lambda x: x, n_outputs=1, result_to_tuple=lambda x: (x,),
+    lambda x: x, n_outputs=1, result_to_tuple=lambda x, _: (x,),
     too_small=_differential_entropy_is_too_small
 )
 def differential_entropy(
@@ -317,10 +318,8 @@ def differential_entropy(
 
     """
     xp = array_namespace(values)
-    values = xp.asarray(values)
-    if xp.isdtype(values.dtype, "integral"):  # type: ignore[union-attr]
-        values = xp.astype(values, xp.asarray(1.).dtype)
-    values = xp_moveaxis_to_end(values, axis, xp=xp)
+    values = xp_promote(values, force_floating=True, xp=xp)
+    values = xp.moveaxis(values, axis, -1)
     n = values.shape[-1]  # type: ignore[union-attr]
 
     if window_length is None:
@@ -403,9 +402,9 @@ def _ebrahimi_entropy(X, m, *, xp):
     differences = X[..., 2 * m:] - X[..., : -2 * m:]
 
     i = xp.arange(1, n+1, dtype=X.dtype)
-    ci = xp.ones_like(i)*2
-    ci[i <= m] = 1 + (i[i <= m] - 1)/m
-    ci[i >= n - m + 1] = 1 + (n - i[i >= n-m+1])/m
+    ci = xp.where(i <= m, 1 + (i - 1)/m, 2.)
+    cond = i >= n - m + 1
+    ci = xpx.at(ci, cond).set(1 + (n - i[cond])/m)
 
     logs = xp.log(n * differences / (ci * m))
     return xp.mean(logs, axis=-1)

scipy/{_lib → stats}/_finite_differences.py

@@ -1,4 +1,5 @@
 from numpy import arange, newaxis, hstack, prod, array
+from scipy import linalg
 
 
 def _central_diff_weights(Np, ndiv=1):
@@ -54,7 +55,6 @@ def _central_diff_weights(Np, ndiv=1):
         )
     if Np % 2 == 0:
         raise ValueError("The number of points must be odd.")
-    from scipy import linalg
 
     ho = Np >> 1
     x = arange(-ho, ho + 1.0)

scipy/stats/_hypotests.py

@@ -482,7 +482,7 @@ def _cdf_cvm(x, n=None):
     return y
 
 
-def _cvm_result_to_tuple(res):
+def _cvm_result_to_tuple(res, _):
     return res.statistic, res.pvalue
 
 
@@ -1725,13 +1725,17 @@ class TukeyHSDResult:
            Method."
            https://www.itl.nist.gov/div898/handbook/prc/section4/prc471.htm,
            28 November 2020.
+    .. [2] P. A. Games and J. F. Howell, "Pairwise Multiple Comparison Procedures
+           with Unequal N's and/or Variances: A Monte Carlo Study," Journal of
+           Educational Statistics, vol. 1, no. 2, pp. 113-125, Jun. 1976,
+           doi: https://doi.org/10.3102/10769986001002113.
     """
 
-    def __init__(self, statistic, pvalue, _nobs, _ntreatments, _stand_err):
+    def __init__(self, statistic, pvalue, _ntreatments, _df, _stand_err):
         self.statistic = statistic
         self.pvalue = pvalue
         self._ntreatments = _ntreatments
-        self._nobs = _nobs
+        self._df = _df
         self._stand_err = _stand_err
         self._ci = None
         self._ci_cl = None
@@ -1742,7 +1746,7 @@ class TukeyHSDResult:
         # it will be called with the default CL of .95.
         if self._ci is None:
             self.confidence_interval(confidence_level=.95)
-        s = ("Tukey's HSD Pairwise Group Comparisons"
+        s = ("Pairwise Group Comparisons"
              f" ({self._ci_cl*100:.1f}% Confidence Interval)\n")
         s += "Comparison  Statistic  p-value  Lower CI  Upper CI\n"
         for i in range(self.pvalue.shape[0]):
@@ -1777,6 +1781,10 @@ class TukeyHSDResult:
                Tukey's Method."
                https://www.itl.nist.gov/div898/handbook/prc/section4/prc471.htm,
                28 November 2020.
+        .. [2] P. A. Games and J. F. Howell, "Pairwise Multiple Comparison Procedures
+               with Unequal N's and/or Variances: A Monte Carlo Study," Journal of
+               Educational Statistics, vol. 1, no. 2, pp. 113-125, Jun. 1976,
+               doi: https://doi.org/10.3102/10769986001002113.
 
         Examples
         --------
@@ -1805,28 +1813,29 @@ class TukeyHSDResult:
             raise ValueError("Confidence level must be between 0 and 1.")
         # determine the critical value of the studentized range using the
         # appropriate confidence level, number of treatments, and degrees
-        # of freedom as determined by the number of data less the number of
-        # treatments. ("Confidence limits for Tukey's method")[1]. Note that
-        # in the cases of unequal sample sizes there will be a criterion for
-        # each group comparison.
-        params = (confidence_level, self._nobs, self._ntreatments - self._nobs)
+        # of freedom. See [1] "Confidence limits for Tukey's method" / [2] p.117
+        # "H0 was rejected if...". Note that in the cases of unequal sample sizes,
+        # there will be a criterion for each group comparison.
+        params = (confidence_level, self._ntreatments, self._df)
         srd = distributions.studentized_range.ppf(*params)
-        # also called maximum critical value, the Tukey criterion is the
+        # also called maximum critical value, the confidence_radius is the
         # studentized range critical value * the square root of mean square
         # error over the sample size.
-        tukey_criterion = srd * self._stand_err
+        confidence_radius = srd * self._stand_err
         # the confidence levels are determined by the
-        # `mean_differences` +- `tukey_criterion`
-        upper_conf = self.statistic + tukey_criterion
-        lower_conf = self.statistic - tukey_criterion
+        # `mean_differences` +- `confidence_radius`
+        upper_conf = self.statistic + confidence_radius
+        lower_conf = self.statistic - confidence_radius
         self._ci = ConfidenceInterval(low=lower_conf, high=upper_conf)
         self._ci_cl = confidence_level
         return self._ci
 
 
-def _tukey_hsd_iv(args):
+def _tukey_hsd_iv(args, equal_var):
     if (len(args)) < 2:
         raise ValueError("There must be more than 1 treatment.")
+    if not isinstance(equal_var, bool):
+        raise TypeError("Expected a boolean value for 'equal_var'")
     args = [np.asarray(arg) for arg in args]
     for arg in args:
         if arg.ndim != 1:
@@ -1838,7 +1847,7 @@ def _tukey_hsd_iv(args):
     return args
 
 
-def tukey_hsd(*args):
+def tukey_hsd(*args, equal_var=True):
     """Perform Tukey's HSD test for equality of means over multiple treatments.
 
     Tukey's honestly significant difference (HSD) test performs pairwise
@@ -1861,6 +1870,10 @@ def tukey_hsd(*args):
     sample1, sample2, ... : array_like
         The sample measurements for each group. There must be at least
         two arguments.
+    equal_var: bool, optional
+        If True (default) and equal sample size, perform Tukey-HSD test [6].
+        If True and unequal sample size, perform Tukey-Kramer test [4]_.
+        If False, perform Games-Howell test [7]_, which does not assume equal variances.
 
     Returns
     -------
@@ -1894,9 +1907,10 @@ def tukey_hsd(*args):
     3. The distributions from which the samples are drawn have the same finite
        variance.
 
-    The original formulation of the test was for samples of equal size [6]_.
-    In case of unequal sample sizes, the test uses the Tukey-Kramer method
-    [4]_.
+    The original formulation of the test was for samples of equal size drawn from
+    populations assumed to have equal variances [6]_. In case of unequal sample sizes,
+    the test uses the Tukey-Kramer method [4]_. When equal variances are not assumed
+    (``equal_var=False``), the test uses the Games-Howell method [7]_.
 
     References
     ----------
@@ -1920,6 +1934,10 @@ def tukey_hsd(*args):
     .. [6] Tukey, John W. "Comparing Individual Means in the Analysis of
            Variance." Biometrics, vol. 5, no. 2, 1949, pp. 99-114. JSTOR,
            www.jstor.org/stable/3001913. Accessed 14 June 2021.
+    .. [7] P. A. Games and J. F. Howell, "Pairwise Multiple Comparison Procedures
+           with Unequal N's and/or Variances: A Monte Carlo Study," Journal of
+           Educational Statistics, vol. 1, no. 2, pp. 113-125, Jun. 1976,
+           doi: https://doi.org/10.3102/10769986001002113.
 
 
     Examples
@@ -1950,14 +1968,14 @@ def tukey_hsd(*args):
 
     >>> res = tukey_hsd(group0, group1, group2)
     >>> print(res)
-    Tukey's HSD Pairwise Group Comparisons (95.0% Confidence Interval)
-    Comparison  Statistic  p-value   Lower CI   Upper CI
-    (0 - 1)     -4.600      0.014     -8.249     -0.951
-    (0 - 2)     -0.260      0.980     -3.909      3.389
-    (1 - 0)      4.600      0.014      0.951      8.249
-    (1 - 2)      4.340      0.020      0.691      7.989
-    (2 - 0)      0.260      0.980     -3.389      3.909
-    (2 - 1)     -4.340      0.020     -7.989     -0.691
+    Pairwise Group Comparisons (95.0% Confidence Interval)
+    Comparison  Statistic  p-value  Lower CI  Upper CI
+     (0 - 1)     -4.600     0.014    -8.249    -0.951
+     (0 - 2)     -0.260     0.980    -3.909     3.389
+     (1 - 0)      4.600     0.014     0.951     8.249
+     (1 - 2)      4.340     0.020     0.691     7.989
+     (2 - 0)      0.260     0.980    -3.389     3.909
+     (2 - 1)     -4.340     0.020    -7.989    -0.691
 
     The null hypothesis is that each group has the same mean. The p-value for
     comparisons between ``group0`` and ``group1`` as well as ``group1`` and
@@ -1986,32 +2004,47 @@ def tukey_hsd(*args):
     (2 - 0) -4.620  5.140
     (2 - 1) -9.220  0.540
     """
-    args = _tukey_hsd_iv(args)
+    args = _tukey_hsd_iv(args, equal_var)
     ntreatments = len(args)
     means = np.asarray([np.mean(arg) for arg in args])
     nsamples_treatments = np.asarray([a.size for a in args])
     nobs = np.sum(nsamples_treatments)
-
-    # determine mean square error [5]. Note that this is sometimes called
-    # mean square error within.
-    mse = (np.sum([np.var(arg, ddof=1) for arg in args] *
-                  (nsamples_treatments - 1)) / (nobs - ntreatments))
-
-    # The calculation of the standard error differs when treatments differ in
-    # size. See ("Unequal sample sizes")[1].
-    if np.unique(nsamples_treatments).size == 1:
-        # all input groups are the same length, so only one value needs to be
-        # calculated [1].
-        normalize = 2 / nsamples_treatments[0]
+    vars_ = np.asarray([np.var(arg, ddof=1) for arg in args])
+
+    if equal_var:
+        # determine mean square error [5]. Note that this is sometimes called
+        # mean square error within.
+        mse = (np.sum(vars_ * (nsamples_treatments - 1)) / (nobs - ntreatments))
+
+        # The calculation of the standard error differs when treatments differ in
+        # size. See ("Unequal sample sizes")[1].
+        if np.unique(nsamples_treatments).size == 1:
+            # all input groups are the same length, so only one value needs to be
+            # calculated [1].
+            normalize = 2 / nsamples_treatments[0]
+        else:
+            # to compare groups of differing sizes, we must compute a variance
+            # value for each individual comparison. Use broadcasting to get the
+            # resulting matrix. [3], verified against [4] (page 308).
+            normalize = 1 / nsamples_treatments + 1 / nsamples_treatments[None].T
+
+        # the standard error is used in the computation of the tukey criterion and
+        # finding the p-values.
+        stand_err = np.sqrt(normalize * mse / 2)
+        df = nobs - ntreatments
     else:
-        # to compare groups of differing sizes, we must compute a variance
-        # value for each individual comparison. Use broadcasting to get the
-        # resulting matrix. [3], verified against [4] (page 308).
-        normalize = 1 / nsamples_treatments + 1 / nsamples_treatments[None].T
-
-    # the standard error is used in the computation of the tukey criterion and
-    # finding the p-values.
-    stand_err = np.sqrt(normalize * mse / 2)
+        # `stand_err` is the denominator of the Behrens-Fisher statistic ($v$)
+        # with a factor of $\sqrt{2}$. Compare [7] p.116 "t-solution rejects H0 if...",
+        # [7] p. 117 "H0 was rejected", and definition of `t_stat` below.
+        sj2_nj = vars_ / nsamples_treatments
+        si2_ni = sj2_nj[:, np.newaxis]
+        stand_err = np.sqrt(si2_ni + sj2_nj) / 2**0.5
+
+        # `df` is the Welch degree of freedom $\nu$.
+        # See [7] p. 116 "and the degrees of freedom, $\nu$, are given by...".
+        njm1 = nsamples_treatments - 1
+        nim1 = njm1[:, np.newaxis]
+        df = (si2_ni + sj2_nj)**2 / (si2_ni**2 / nim1 + sj2_nj**2 / njm1)
 
     # the mean difference is the test statistic.
     mean_differences = means[None].T - means
@@ -2020,8 +2053,8 @@ def tukey_hsd(*args):
     # studentized range to get the p-value.
     t_stat = np.abs(mean_differences) / stand_err
 
-    params = t_stat, ntreatments, nobs - ntreatments
+    params = t_stat, ntreatments, df
     pvalues = distributions.studentized_range.sf(*params)
 
     return TukeyHSDResult(mean_differences, pvalues, ntreatments,
-                          nobs, stand_err)
+                          df, stand_err)

scipy/stats/_kde.py

@@ -17,13 +17,9 @@
 #
 #-------------------------------------------------------------------------------
 
-# Standard library imports.
-import threading
-import warnings
-
 # SciPy imports.
 from scipy import linalg, special
-from scipy._lib._util import check_random_state
+from scipy._lib._util import check_random_state, np_vecdot
 
 from numpy import (asarray, atleast_2d, reshape, zeros, newaxis, exp, pi,
                    sqrt, ravel, power, atleast_1d, squeeze, sum, transpose,
@@ -31,14 +27,11 @@ from numpy import (asarray, atleast_2d, reshape, zeros, newaxis, exp, pi,
 import numpy as np
 
 # Local imports.
-from . import _mvn
 from ._stats import gaussian_kernel_estimate, gaussian_kernel_estimate_log
-
+from ._multivariate import multivariate_normal
 
 __all__ = ['gaussian_kde']
 
-MVN_LOCK = threading.Lock()
-
 
 class gaussian_kde:
     """Representation of a kernel-density estimate using Gaussian kernels.
@@ -56,9 +49,9 @@ class gaussian_kde:
         Datapoints to estimate from. In case of univariate data this is a 1-D
         array, otherwise a 2-D array with shape (# of dims, # of data).
     bw_method : str, scalar or callable, optional
-        The method used to calculate the estimator bandwidth.  This can be
+        The method used to calculate the bandwidth factor.  This can be
         'scott', 'silverman', a scalar constant or a callable.  If a scalar,
-        this will be used directly as `kde.factor`.  If a callable, it should
+        this will be used directly as `factor`.  If a callable, it should
         take a `gaussian_kde` instance as only parameter and return a scalar.
         If None (default), 'scott' is used.  See Notes for more details.
     weights : array_like, optional
@@ -78,12 +71,11 @@ class gaussian_kde:
 
         .. versionadded:: 1.2.0
     factor : float
-        The bandwidth factor, obtained from `kde.covariance_factor`. The square
-        of `kde.factor` multiplies the covariance matrix of the data in the kde
-        estimation.
+        The bandwidth factor obtained from `covariance_factor`.
     covariance : ndarray
-        The covariance matrix of `dataset`, scaled by the calculated bandwidth
-        (`kde.factor`).
+        The kernel covariance matrix; this is the data covariance matrix
+        multiplied by the square of the bandwidth factor, e.g.
+        ``np.cov(dataset) * factor**2``.
     inv_cov : ndarray
         The inverse of `covariance`.
 
@@ -119,7 +111,8 @@ class gaussian_kde:
         neff**(-1./(d+4)),
 
     with ``neff`` the effective number of datapoints.
-    Silverman's Rule [2]_, implemented as `silverman_factor`, is::
+    Silverman's suggestion for *multivariate* data [2]_, implemented as
+    `silverman_factor`, is::
 
         (n * (d + 2) / 4.)**(-1. / (d + 4)).
 
@@ -127,6 +120,10 @@ class gaussian_kde:
 
         (neff * (d + 2) / 4.)**(-1. / (d + 4)).
 
+    Note that this is not the same as "Silverman's rule of thumb" [6]_, which
+    may be more robust in the univariate case; see documentation of the
+    ``set_bandwidth`` method for implementing a custom bandwidth rule.
+
     Good general descriptions of kernel density estimation can be found in [1]_
     and [2]_, the mathematics for this multi-dimensional implementation can be
     found in [1]_.
@@ -157,6 +154,8 @@ class gaussian_kde:
            Analysis, Vol. 36, pp. 279-298, 2001.
     .. [5] Gray P. G., 1969, Journal of the Royal Statistical Society.
            Series A (General), 132, 272
+    .. [6] Kernel density estimation. *Wikipedia.*
+           https://en.wikipedia.org/wiki/Kernel_density_estimation
 
     Examples
     --------
@@ -195,6 +194,16 @@ class gaussian_kde:
     >>> ax.set_ylim([ymin, ymax])
     >>> plt.show()
 
+    Compare against manual KDE at a point:
+
+    >>> point = [1, 2]
+    >>> mean = values.T
+    >>> cov = kernel.factor**2 * np.cov(values)
+    >>> X = stats.multivariate_normal(cov=cov)
+    >>> res = kernel.pdf(point)
+    >>> ref = X.pdf(point - mean).sum() / len(mean)
+    >>> np.allclose(res, ref)
+    True
     """
     def __init__(self, dataset, bw_method=None, weights=None):
         self.dataset = atleast_2d(asarray(dataset))
@@ -210,7 +219,7 @@ class gaussian_kde:
                 raise ValueError("`weights` input should be one-dimensional.")
             if len(self._weights) != self.n:
                 raise ValueError("`weights` input should be of length n")
-            self._neff = 1/sum(self._weights**2)
+            self._neff = 1/np_vecdot(self._weights, self._weights)
 
         # This can be converted to a warning once gh-10205 is resolved
         if self.d > self.n:
@@ -324,8 +333,8 @@ class gaussian_kde:
         sqrt_det = np.prod(np.diagonal(sum_cov_chol[0]))
         norm_const = power(2 * pi, sum_cov.shape[0] / 2.0) * sqrt_det
 
-        energies = sum(diff * tdiff, axis=0) / 2.0
-        result = sum(exp(-energies)*self.weights, axis=0) / norm_const
+        energies = np_vecdot(diff, tdiff, axis=0) / 2.0
+        result = np_vecdot(exp(-energies), self.weights, axis=0) / norm_const
 
         return result
 
@@ -359,12 +368,11 @@ class gaussian_kde:
         normalized_low = ravel((low - self.dataset) / stdev)
         normalized_high = ravel((high - self.dataset) / stdev)
 
-        value = np.sum(self.weights*(
-                        special.ndtr(normalized_high) -
-                        special.ndtr(normalized_low)))
+        delta = special.ndtr(normalized_high) - special.ndtr(normalized_low)
+        value = np_vecdot(self.weights, delta)
         return value
 
-    def integrate_box(self, low_bounds, high_bounds, maxpts=None):
+    def integrate_box(self, low_bounds, high_bounds, maxpts=None, *, rng=None):
         """Computes the integral of a pdf over a rectangular interval.
 
         Parameters
@@ -375,6 +383,11 @@ class gaussian_kde:
             A 1-D array containing the upper bounds of integration.
         maxpts : int, optional
             The maximum number of points to use for integration.
+        rng : `numpy.random.Generator`, optional
+            Pseudorandom number generator state. When `rng` is None, a new
+            generator is created using entropy from the operating system. Types
+            other than `numpy.random.Generator` are passed to
+            `numpy.random.default_rng` to instantiate a ``Generator``.
 
         Returns
         -------
@@ -382,20 +395,12 @@ class gaussian_kde:
             The result of the integral.
 
         """
-        if maxpts is not None:
-            extra_kwds = {'maxpts': maxpts}
-        else:
-            extra_kwds = {}
-
-        with MVN_LOCK:
-            value, inform = _mvn.mvnun_weighted(low_bounds, high_bounds,
-                                                self.dataset, self.weights,
-                                                self.covariance, **extra_kwds)
-        if inform:
-            msg = f'An integral in _mvn.mvnun requires more points than {self.d * 1000}'
-            warnings.warn(msg, stacklevel=2)
-
-        return value
+        low, high = low_bounds - self.dataset.T, high_bounds - self.dataset.T
+        values = multivariate_normal.cdf(
+            high, lower_limit=low, cov=self.covariance, maxpts=maxpts,
+            rng=rng
+        )
+        return np_vecdot(values, self.weights, axis=-1)
 
     def integrate_kde(self, other):
         """
@@ -437,8 +442,8 @@ class gaussian_kde:
             diff = large.dataset - mean
             tdiff = linalg.cho_solve(sum_cov_chol, diff)
 
-            energies = sum(diff * tdiff, axis=0) / 2.0
-            result += sum(exp(-energies)*large.weights, axis=0)*small.weights[i]
+            energies = np_vecdot(diff, tdiff, axis=0) / 2.0
+            result += np_vecdot(exp(-energies), large.weights, axis=0)*small.weights[i]
 
         sqrt_det = np.prod(np.diagonal(sum_cov_chol[0]))
         norm_const = power(2 * pi, sum_cov.shape[0] / 2.0) * sqrt_det
@@ -504,14 +509,13 @@ class gaussian_kde:
 
     #  Default method to calculate bandwidth, can be overwritten by subclass
     covariance_factor = scotts_factor
-    covariance_factor.__doc__ = """Computes the coefficient (`kde.factor`) that
-        multiplies the data covariance matrix to obtain the kernel covariance
-        matrix. The default is `scotts_factor`.  A subclass can overwrite this
+    covariance_factor.__doc__ = """Computes the bandwidth factor `factor`.
+        The default is `scotts_factor`.  A subclass can overwrite this
         method to provide a different method, or set it through a call to
-        `kde.set_bandwidth`."""
+        `set_bandwidth`."""
 
     def set_bandwidth(self, bw_method=None):
-        """Compute the estimator bandwidth with given method.
+        """Compute the bandwidth factor with given method.
 
         The new bandwidth calculated after a call to `set_bandwidth` is used
         for subsequent evaluations of the estimated density.
@@ -519,12 +523,12 @@ class gaussian_kde:
         Parameters
         ----------
         bw_method : str, scalar or callable, optional
-            The method used to calculate the estimator bandwidth.  This can be
+            The method used to calculate the bandwidth factor.  This can be
             'scott', 'silverman', a scalar constant or a callable.  If a
-            scalar, this will be used directly as `kde.factor`.  If a callable,
+            scalar, this will be used directly as `factor`.  If a callable,
             it should take a `gaussian_kde` instance as only parameter and
             return a scalar.  If None (default), nothing happens; the current
-            `kde.covariance_factor` method is kept.
+            `covariance_factor` method is kept.
 
         Notes
         -----
@@ -701,7 +705,7 @@ class gaussian_kde:
         try:
             return self._neff
         except AttributeError:
-            self._neff = 1/sum(self.weights**2)
+            self._neff = 1/np_vecdot(self.weights, self.weights)
             return self._neff
 
 

scipy/stats/_ksstats.py

@@ -68,7 +68,7 @@
 import numpy as np
 import scipy.special
 import scipy.special._ufuncs as scu
-from scipy._lib._finite_differences import _derivative
+from scipy.stats._finite_differences import _derivative
 
 _E128 = 128
 _EP128 = np.ldexp(np.longdouble(1), _E128)

scipy/stats/_levy_stable/__init__.py

@@ -10,8 +10,8 @@ from scipy import integrate
 from scipy.integrate._quadrature import _builtincoeffs
 from scipy import interpolate
 from scipy.interpolate import RectBivariateSpline
+import scipy._lib.array_api_extra as xpx
 import scipy.special as sc
-from scipy._lib._util import _lazywhere
 from .._distn_infrastructure import rv_continuous, _ShapeInfo, rv_continuous_frozen
 from .._continuous_distns import uniform, expon, _norm_pdf, _norm_cdf
 from .levyst import Nolan
@@ -456,13 +456,9 @@ def _rvs_Z1(alpha, beta, size=None, random_state=None):
         return res3
 
     def alphanot1func(alpha, beta, TH, aTH, bTH, cosTH, tanTH, W):
-        res = _lazywhere(
-            beta == 0,
-            (alpha, beta, TH, aTH, bTH, cosTH, tanTH, W),
-            beta0func,
-            f2=otherwise,
-        )
-        return res
+        return xpx.apply_where(
+            beta == 0, (alpha, beta, TH, aTH, bTH, cosTH, tanTH, W),
+            beta0func, otherwise)
 
     alpha = np.broadcast_to(alpha, size)
     beta = np.broadcast_to(beta, size)
@@ -474,13 +470,9 @@ def _rvs_Z1(alpha, beta, size=None, random_state=None):
     bTH = beta * TH
     cosTH = np.cos(TH)
     tanTH = np.tan(TH)
-    res = _lazywhere(
-        alpha == 1,
-        (alpha, beta, TH, aTH, bTH, cosTH, tanTH, W),
-        alpha1func,
-        f2=alphanot1func,
-    )
-    return res
+    return xpx.apply_where(
+        alpha == 1, (alpha, beta, TH, aTH, bTH, cosTH, tanTH, W),
+        alpha1func, alphanot1func)
 
 
 def _fitstart_S0(data):