scipy 1.15.3__cp311-cp311-win_amd64.whl → 1.16.0rc2__cp311-cp311-win_amd64.whl

scipy/stats/_continuous_distns.py

@@ -6,6 +6,7 @@ import warnings
 from collections.abc import Iterable
 from functools import wraps, cached_property
 import ctypes
+import operator
 
 import numpy as np
 from numpy.polynomial import Polynomial
@@ -19,7 +20,8 @@ from scipy import integrate
 import scipy.special as sc
 
 import scipy.special._ufuncs as scu
-from scipy._lib._util import _lazyselect, _lazywhere
+from scipy._lib._util import _lazyselect
+import scipy._lib.array_api_extra as xpx
 
 from . import _stats
 from ._tukeylambda_stats import (tukeylambda_variance as _tlvar,
@@ -27,7 +29,6 @@ from ._tukeylambda_stats import (tukeylambda_variance as _tlvar,
 from ._distn_infrastructure import (_vectorize_rvs_over_shapes,
     get_distribution_names, _kurtosis, _isintegral,
     rv_continuous, _skew, _get_fixed_fit_value, _check_shape, _ShapeInfo)
-from scipy.stats._distribution_infrastructure import _log1mexp
 from ._ksstats import kolmogn, kolmognp, kolmogni
 from ._constants import (_XMIN, _LOGXMIN, _EULER, _ZETA3, _SQRT_PI,
                          _SQRT_2_OVER_PI, _LOG_PI, _LOG_SQRT_2_OVER_PI)
@@ -1031,17 +1032,16 @@ class betaprime_gen(rv_continuous):
         # use the following relationship of the incomplete beta function:
         # betainc(x, a, b) = 1 - betainc(1-x, b, a)
         # see gh-17631
-        return _lazywhere(
-            x > 1, [x, a, b],
-            lambda x_, a_, b_: beta._sf(1/(1+x_), b_, a_),
-            f2=lambda x_, a_, b_: beta._cdf(x_/(1+x_), a_, b_))
+        return xpx.apply_where(
+            x > 1, (x, a, b),
+            lambda x_, a_, b_: beta._sf(1 / (1 + x_), b_, a_),
+            lambda x_, a_, b_: beta._cdf(x_ / (1 + x_), a_, b_))
 
     def _sf(self, x, a, b):
-        return _lazywhere(
-            x > 1, [x, a, b],
-            lambda x_, a_, b_: beta._cdf(1/(1+x_), b_, a_),
-            f2=lambda x_, a_, b_: beta._sf(x_/(1+x_), a_, b_)
-        )
+        return xpx.apply_where(
+            x > 1, (x, a, b),
+            lambda x_, a_, b_: beta._cdf(1 / (1 + x_), b_, a_),
+            lambda x_, a_, b_: beta._sf(x_ / (1 + x_), a_, b_))
 
     def _ppf(self, p, a, b):
         p, a, b = np.broadcast_arrays(p, a, b)
@@ -1062,10 +1062,10 @@ class betaprime_gen(rv_continuous):
         return out
 
     def _munp(self, n, a, b):
-        return _lazywhere(
+        return xpx.apply_where(
             b > n, (a, b),
             lambda a, b: np.prod([(a+i-1)/(b-i) for i in range(1, int(n)+1)], axis=0),
-            fillvalue=np.inf)
+            fill_value=np.inf)
 
 
 betaprime = betaprime_gen(a=0.0, name='betaprime')
@@ -1185,26 +1185,22 @@ class burr_gen(rv_continuous):
 
     def _pdf(self, x, c, d):
         # burr.pdf(x, c, d) = c * d * x**(-c-1) * (1+x**(-c))**(-d-1)
-        output = _lazywhere(
-            x == 0, [x, c, d],
+        output = xpx.apply_where(
+            x == 0, (x, c, d),
             lambda x_, c_, d_: c_ * d_ * (x_**(c_*d_-1)) / (1 + x_**c_),
-            f2=lambda x_, c_, d_: (c_ * d_ * (x_ ** (-c_ - 1.0)) /
-                                   ((1 + x_ ** (-c_)) ** (d_ + 1.0))))
-        if output.ndim == 0:
-            return output[()]
-        return output
+            lambda x_, c_, d_: (c_ * d_ * (x_ ** (-c_ - 1.0)) /
+                                ((1 + x_ ** (-c_)) ** (d_ + 1.0))))
+        return output[()] if output.ndim == 0 else output
 
     def _logpdf(self, x, c, d):
-        output = _lazywhere(
-            x == 0, [x, c, d],
+        output = xpx.apply_where(
+            x == 0, (x, c, d),
             lambda x_, c_, d_: (np.log(c_) + np.log(d_) + sc.xlogy(c_*d_ - 1, x_)
                                 - (d_+1) * sc.log1p(x_**(c_))),
-            f2=lambda x_, c_, d_: (np.log(c_) + np.log(d_)
-                                   + sc.xlogy(-c_ - 1, x_)
-                                   - sc.xlog1py(d_+1, x_**(-c_))))
-        if output.ndim == 0:
-            return output[()]
-        return output
+            lambda x_, c_, d_: (np.log(c_) + np.log(d_)
+                                + sc.xlogy(-c_ - 1, x_)
+                                - sc.xlog1py(d_+1, x_**(-c_))))
+        return output[()] if output.ndim == 0 else output
 
     def _cdf(self, x, c, d):
         return (1 + x**(-c))**(-d)
@@ -1232,18 +1228,16 @@ class burr_gen(rv_continuous):
         mu = np.where(c > 1.0, e1, np.nan)
         mu2_if_c = e2 - mu**2
         mu2 = np.where(c > 2.0, mu2_if_c, np.nan)
-        g1 = _lazywhere(
-            c > 3.0,
-            (c, e1, e2, e3, mu2_if_c),
-            lambda c, e1, e2, e3, mu2_if_c: ((e3 - 3*e2*e1 + 2*e1**3)
-                                             / np.sqrt((mu2_if_c)**3)),
-            fillvalue=np.nan)
-        g2 = _lazywhere(
-            c > 4.0,
-            (c, e1, e2, e3, e4, mu2_if_c),
-            lambda c, e1, e2, e3, e4, mu2_if_c: (
+        g1 = xpx.apply_where(
+            c > 3.0, (e1, e2, e3, mu2_if_c),
+            lambda e1, e2, e3, mu2_if_c: ((e3 - 3*e2*e1 + 2*e1**3)
+                                           / np.sqrt((mu2_if_c)**3)),
+            fill_value=np.nan)
+        g2 = xpx.apply_where(
+            c > 4.0, (e1, e2, e3, e4, mu2_if_c),
+            lambda e1, e2, e3, e4, mu2_if_c: (
                 ((e4 - 4*e3*e1 + 6*e2*e1**2 - 3*e1**4) / mu2_if_c**2) - 3),
-            fillvalue=np.nan)
+            fill_value=np.nan)
         if np.ndim(c) == 0:
             return mu.item(), mu2.item(), g1.item(), g2.item()
         return mu, mu2, g1, g2
@@ -1253,9 +1247,8 @@ class burr_gen(rv_continuous):
             nc = 1. * n / c
             return d * sc.beta(1.0 - nc, d + nc)
         n, c, d = np.asarray(n), np.asarray(c), np.asarray(d)
-        return _lazywhere((c > n) & (n == n) & (d == d), (c, d, n),
-                          lambda c, d, n: __munp(n, c, d),
-                          np.nan)
+        return xpx.apply_where((c > n) & (n == n) & (d == d),
+                               (n, c, d), __munp, fill_value=np.nan)
 
 
 burr = burr_gen(a=0.0, name='burr')
@@ -1344,8 +1337,8 @@ class burr12_gen(rv_continuous):
             nc = 1. * n / c
             return d * sc.beta(1.0 + nc, d - nc)
 
-        return _lazywhere(c * d > n, (n, c, d), moment_if_exists,
-                          fillvalue=np.nan)
+        return xpx.apply_where(c * d > n, (n, c, d), moment_if_exists,
+                               fill_value=np.nan)
 
 
 burr12 = burr12_gen(a=0.0, name='burr12')
@@ -1478,14 +1471,13 @@ class cauchy_gen(rv_continuous):
         #                            = -log(pi) - (2log(|x|) + log1p(1/x**2))
         # are used here.
         absx = np.abs(x)
-        # In the following _lazywhere, `f` provides better precision than `f2`
+        # In the following apply_where, `f1` provides better precision than `f2`
         # for small and moderate x, while `f2` avoids the overflow that can
         # occur with absx**2.
-        y = _lazywhere(absx < 1, (absx,),
-                       f=lambda absx: -_LOG_PI - np.log1p(absx**2),
-                       f2=lambda absx: (-_LOG_PI -
-                                        (2*np.log(absx) + np.log1p((1/absx)**2))))
-        return y
+        return xpx.apply_where(
+            absx < 1, absx,
+            lambda absx: -_LOG_PI - np.log1p(absx**2),
+            lambda absx: (-_LOG_PI - (2*np.log(absx) + np.log1p((1/absx)**2))))
 
     def _cdf(self, x):
         return np.arctan2(1, -x)/np.pi
@@ -1594,8 +1586,7 @@ class chi_gen(rv_continuous):
             return (0.5 + np.log(np.pi)/2 - (df**-1)/6 - (df**-2)/6
                     - 4/45*(df**-3) + (df**-4)/15)
 
-        return _lazywhere(df < 3e2, (df, ), regular_formula,
-                          f2=asymptotic_formula)
+        return xpx.apply_where(df < 300, df, regular_formula, asymptotic_formula)
 
 
 chi = chi_gen(a=0.0, name='chi')
@@ -1685,9 +1676,8 @@ class chi2_gen(rv_continuous):
             return (h*(-2/3 + h*(-1/3 + h*(-4/45 + h/7.5))) +
                     0.5*np.log(half_df) + c)
 
-        return _lazywhere(half_df < 125, (half_df, ),
-                          regular_formula,
-                          f2=asymptotic_formula)
+        return xpx.apply_where(half_df < 125, half_df,
+                               regular_formula, asymptotic_formula)
 
 
 chi2 = chi2_gen(a=0.0, name='chi2')
@@ -1723,9 +1713,9 @@ class cosine_gen(rv_continuous):
 
     def _logpdf(self, x):
         c = np.cos(x)
-        return _lazywhere(c != -1, (c,),
-                          lambda c: np.log1p(c) - np.log(2*np.pi),
-                          fillvalue=-np.inf)
+        return xpx.apply_where(c != -1, c,
+                               lambda c: np.log1p(c) - np.log(2*np.pi),
+                               fill_value=-np.inf)
 
     def _cdf(self, x):
         return scu._cosine_cdf(x)
@@ -1945,7 +1935,7 @@ class dpareto_lognorm_gen(rv_continuous):
         return out[()]
 
     def _logsf(self, x, u, s, a, b):
-        return _log1mexp(self._logcdf(x, u, s, a, b))
+        return scu._log1mexp(self._logcdf(x, u, s, a, b))
 
     # Infrastructure doesn't seem to do this, so...
 
@@ -2589,28 +2579,28 @@ class f_gen(rv_continuous):
         v1, v2 = 1. * dfn, 1. * dfd
         v2_2, v2_4, v2_6, v2_8 = v2 - 2., v2 - 4., v2 - 6., v2 - 8.
 
-        mu = _lazywhere(
+        mu = xpx.apply_where(
             v2 > 2, (v2, v2_2),
             lambda v2, v2_2: v2 / v2_2,
-            np.inf)
+            fill_value=np.inf)
 
-        mu2 = _lazywhere(
+        mu2 = xpx.apply_where(
             v2 > 4, (v1, v2, v2_2, v2_4),
             lambda v1, v2, v2_2, v2_4:
             2 * v2 * v2 * (v1 + v2_2) / (v1 * v2_2**2 * v2_4),
-            np.inf)
+            fill_value=np.inf)
 
-        g1 = _lazywhere(
+        g1 = xpx.apply_where(
             v2 > 6, (v1, v2_2, v2_4, v2_6),
             lambda v1, v2_2, v2_4, v2_6:
             (2 * v1 + v2_2) / v2_6 * np.sqrt(v2_4 / (v1 * (v1 + v2_2))),
-            np.nan)
+            fill_value=np.nan)
         g1 *= np.sqrt(8.)
 
-        g2 = _lazywhere(
+        g2 = xpx.apply_where(
             v2 > 8, (g1, v2_6, v2_8),
             lambda g1, v2_6, v2_8: (8 + g1 * g1 * v2_6) / v2_8,
-            np.nan)
+            fill_value=np.nan)
         g2 *= 3. / 2.
 
         return mu, mu2, g1, g2
@@ -3127,14 +3117,15 @@ class genlogistic_gen(rv_continuous):
         return mu, mu2, g1, g2
 
     def _entropy(self, c):
-        return _lazywhere(c < 8e6, (c, ),
-                          lambda c: -np.log(c) + sc.psi(c + 1) + _EULER + 1,
-                          # asymptotic expansion: psi(c) ~ log(c) - 1/(2 * c)
-                          # a = -log(c) + psi(c + 1)
-                          #   = -log(c) + psi(c) + 1/c
-                          #   ~ -log(c) + log(c) - 1/(2 * c) + 1/c
-                          #   = 1/(2 * c)
-                          f2=lambda c: 1/(2 * c) + _EULER + 1)
+        return xpx.apply_where(
+            c < 8e6, c,
+            lambda c: -np.log(c) + sc.psi(c + 1) + _EULER + 1,
+            # asymptotic expansion: psi(c) ~ log(c) - 1 / (2 * c)
+            # a = -log(c) + psi(c + 1)
+            #   = -log(c) + psi(c) + 1 / c
+            #   ~ -log(c) + log(c) - 1 / (2 * c) + 1 / c
+            #   = 1 / (2 * c)
+            lambda c: 1 / (2 * c) + _EULER + 1)
 
 
 genlogistic = genlogistic_gen(name='genlogistic')
@@ -3184,10 +3175,9 @@ class genpareto_gen(rv_continuous):
 
     def _get_support(self, c):
         c = np.asarray(c)
-        b = _lazywhere(c < 0, (c,),
-                       lambda c: -1. / c,
-                       np.inf)
-        a = np.where(c >= 0, self.a, self.a)
+        a = np.broadcast_arrays(self.a, c)[0].copy()
+        b = xpx.apply_where(c < 0, c, lambda c: -1. / c,
+                            fill_value=np.inf)
         return a, b
 
     def _pdf(self, x, c):
@@ -3195,9 +3185,9 @@ class genpareto_gen(rv_continuous):
         return np.exp(self._logpdf(x, c))
 
     def _logpdf(self, x, c):
-        return _lazywhere((x == x) & (c != 0), (x, c),
-                          lambda x, c: -sc.xlog1py(c + 1., c*x) / c,
-                          -x)
+        return xpx.apply_where((x == x) & (c != 0), (x, c),
+                               lambda x, c: -sc.xlog1py(c + 1., c*x) / c,
+                               fill_value=-x)
 
     def _cdf(self, x, c):
         return -sc.inv_boxcox1p(-x, -c)
@@ -3206,9 +3196,9 @@ class genpareto_gen(rv_continuous):
         return sc.inv_boxcox(-x, -c)
 
     def _logsf(self, x, c):
-        return _lazywhere((x == x) & (c != 0), (x, c),
-                          lambda x, c: -sc.log1p(c*x) / c,
-                          -x)
+        return xpx.apply_where((x == x) & (c != 0), (x, c),
+                               lambda x, c: -sc.log1p(c*x) / c,
+                               fill_value=-x)
 
     def _ppf(self, q, c):
         return -sc.boxcox1p(-q, -c)
@@ -3217,44 +3207,42 @@ class genpareto_gen(rv_continuous):
         return -sc.boxcox(q, -c)
 
     def _stats(self, c, moments='mv'):
-        if 'm' not in moments:
-            m = None
-        else:
-            m = _lazywhere(c < 1, (c,),
-                           lambda xi: 1/(1 - xi),
-                           np.inf)
-        if 'v' not in moments:
-            v = None
-        else:
-            v = _lazywhere(c < 1/2, (c,),
-                           lambda xi: 1 / (1 - xi)**2 / (1 - 2*xi),
-                           np.nan)
-        if 's' not in moments:
-            s = None
-        else:
-            s = _lazywhere(c < 1/3, (c,),
-                           lambda xi: (2 * (1 + xi) * np.sqrt(1 - 2*xi) /
-                                       (1 - 3*xi)),
-                           np.nan)
-        if 'k' not in moments:
-            k = None
-        else:
-            k = _lazywhere(c < 1/4, (c,),
-                           lambda xi: (3 * (1 - 2*xi) * (2*xi**2 + xi + 3) /
-                                       (1 - 3*xi) / (1 - 4*xi) - 3),
-                           np.nan)
+        m, v, s, k = None, None, None, None
+
+        if 'm' in moments:
+            m = xpx.apply_where(c < 1, c,
+                                lambda xi: 1 / (1 - xi),
+                                fill_value=np.inf)
+
+        if 'v' in moments:
+            v = xpx.apply_where(c < 1/2, c,
+                                lambda xi: 1 / (1 - xi)**2 / (1 - 2 * xi),
+                                fill_value=np.nan)
+
+        if 's' in moments:
+            s = xpx.apply_where(
+                c < 1/3, c,
+                lambda xi: 2 * (1 + xi) * np.sqrt(1 - 2*xi) / (1 - 3*xi),
+                fill_value=np.nan)
+
+        if 'k' in moments:
+            k = xpx.apply_where(
+                c < 1/4, c,
+                lambda xi: 3 * (1 - 2*xi) * (2*xi**2 + xi + 3) 
+                           / (1 - 3*xi) / (1 - 4*xi) - 3,
+                fill_value=np.nan)
+
         return m, v, s, k
 
     def _munp(self, n, c):
-        def __munp(n, c):
+        def __munp(c):
             val = 0.0
             k = np.arange(0, n + 1)
             for ki, cnk in zip(k, sc.comb(n, k)):
                 val = val + cnk * (-1) ** ki / (1.0 - c * ki)
             return np.where(c * n < 1, val * (-1.0 / c) ** n, np.inf)
-        return _lazywhere(c != 0, (c,),
-                          lambda c: __munp(n, c),
-                          sc.gamma(n + 1))
+
+        return xpx.apply_where(c != 0, c, __munp, fill_value=sc.gamma(n + 1))
 
     def _entropy(self, c):
         return 1. + c
@@ -3382,8 +3370,10 @@ class genextreme_gen(rv_continuous):
 
     def _loglogcdf(self, x, c):
         # Returns log(-log(cdf(x, c)))
-        return _lazywhere((x == x) & (c != 0), (x, c),
-                          lambda x, c: sc.log1p(-c*x)/c, -x)
+        return xpx.apply_where(
+            (x == x) & (c != 0), (x, c),
+            lambda x, c: sc.log1p(-c*x)/c, 
+            fill_value=-x)
 
     def _pdf(self, x, c):
         # genextreme.pdf(x, c) =
@@ -3392,16 +3382,19 @@ class genextreme_gen(rv_continuous):
         return np.exp(self._logpdf(x, c))
 
     def _logpdf(self, x, c):
-        cx = _lazywhere((x == x) & (c != 0), (x, c), lambda x, c: c*x, 0.0)
+        # Suppress warnings 0 * inf
+        cx = xpx.apply_where((x == x) & (c != 0), (c, x),
+                             operator.mul, fill_value=0.0)
         logex2 = sc.log1p(-cx)
         logpex2 = self._loglogcdf(x, c)
         pex2 = np.exp(logpex2)
         # Handle special cases
         np.putmask(logpex2, (c == 0) & (x == -np.inf), 0.0)
-        logpdf = _lazywhere(~((cx == 1) | (cx == -np.inf)),
-                            (pex2, logpex2, logex2),
-                            lambda pex2, lpex2, lex2: -pex2 + lpex2 - lex2,
-                            fillvalue=-np.inf)
+        logpdf = xpx.apply_where(
+            ~((cx == 1) | (cx == -np.inf)),
+            (pex2, logpex2, logex2),
+            lambda pex2, lpex2, lex2: -pex2 + lpex2 - lex2,
+            fill_value=-np.inf)
         np.putmask(logpdf, (c == 1) & (x == 1), 0.0)
         return logpdf
 
@@ -3416,13 +3409,17 @@ class genextreme_gen(rv_continuous):
 
     def _ppf(self, q, c):
         x = -np.log(-np.log(q))
-        return _lazywhere((x == x) & (c != 0), (x, c),
-                          lambda x, c: -sc.expm1(-c * x) / c, x)
+        return xpx.apply_where(
+            (x == x) & (c != 0), (x, c),
+            lambda x, c: -sc.expm1(-c * x) / c,
+            fill_value=x)
 
     def _isf(self, q, c):
         x = -np.log(-sc.log1p(-q))
-        return _lazywhere((x == x) & (c != 0), (x, c),
-                          lambda x, c: -sc.expm1(-c * x) / c, x)
+        return xpx.apply_where(
+            (x == x) & (c != 0), (x, c),
+            lambda x, c: -sc.expm1(-c * x) / c,
+            fill_value=x)
 
     def _stats(self, c):
         def g(n):
@@ -3434,11 +3431,11 @@ class genextreme_gen(rv_continuous):
         g2mg12 = np.where(abs(c) < 1e-7, (c*np.pi)**2.0/6.0, g2-g1**2.0)
         def gam2k_f(c):
             return sc.expm1(sc.gammaln(2.0*c+1.0)-2*sc.gammaln(c + 1.0))/c**2.0
-        gam2k = _lazywhere(abs(c) >= 1e-7, (c,), f=gam2k_f, fillvalue=np.pi**2.0/6.0)
+        gam2k = xpx.apply_where(abs(c) >= 1e-7, c, gam2k_f, fill_value=np.pi**2.0/6.0)
         eps = 1e-14
         def gamk_f(c):
             return sc.expm1(sc.gammaln(c + 1))/c
-        gamk = _lazywhere(abs(c) >= eps, (c,), f=gamk_f, fillvalue=-_EULER)
+        gamk = xpx.apply_where(abs(c) >= eps, c, gamk_f, fill_value=-_EULER)
 
         # mean
         m = np.where(c < -1.0, np.nan, -gamk)
@@ -3450,20 +3447,23 @@ class genextreme_gen(rv_continuous):
         def sk1_eval(c, *args):
             def sk1_eval_f(c, g1, g2, g3, g2mg12):
                 return np.sign(c)*(-g3 + (g2 + 2*g2mg12)*g1)/g2mg12**1.5
-            return _lazywhere(c >= -1./3, (c,)+args, f=sk1_eval_f, fillvalue=np.nan)
+            return xpx.apply_where(c >= -1./3, (c, *args), 
+                                   sk1_eval_f, fill_value=np.nan)
 
         sk_fill = 12*np.sqrt(6)*_ZETA3/np.pi**3
         args = (g1, g2, g3, g2mg12)
-        sk = _lazywhere(abs(c) > eps**0.29, (c,)+args, f=sk1_eval, fillvalue=sk_fill)
+        sk = xpx.apply_where(abs(c) > eps**0.29, (c, *args), 
+                             sk1_eval, fill_value=sk_fill)
 
         # kurtosis
         def ku1_eval(c, *args):
             def ku1_eval_f(g1, g2, g3, g4, g2mg12):
                 return (g4 + (-4*g3 + 3*(g2 + g2mg12)*g1)*g1)/g2mg12**2 - 3
-            return _lazywhere(c >= -1./4, args, ku1_eval_f, fillvalue=np.nan)
+            return xpx.apply_where(c >= -1./4, args, ku1_eval_f, fill_value=np.nan)
 
         args = (g1, g2, g3, g4, g2mg12)
-        ku = _lazywhere(abs(c) > eps**0.23, (c,)+args, f=ku1_eval, fillvalue=12.0/5.0)
+        ku = xpx.apply_where(abs(c) > eps**0.23, (c, *args), 
+                             ku1_eval, fill_value=12.0/5.0)
 
         return m, v, sk, ku
 
@@ -3627,8 +3627,7 @@ class gamma_gen(rv_continuous):
             return (0.5 * (1. + np.log(2*np.pi) + np.log(a)) - 1/(3 * a)
                     - (a**-2.)/12 - (a**-3.)/90 + (a**-4.)/120)
 
-        return _lazywhere(a < 250, (a, ), regular_formula,
-                          f2=asymptotic_formula)
+        return xpx.apply_where(a < 250, a, regular_formula, asymptotic_formula)
 
     def _fitstart(self, data):
         # The skewness of the gamma distribution is `2 / np.sqrt(a)`.
@@ -3858,10 +3857,10 @@ class gengamma_gen(rv_continuous):
         return np.exp(self._logpdf(x, a, c))
 
     def _logpdf(self, x, a, c):
-        return _lazywhere((x != 0) | (c > 0), (x, c),
-                          lambda x, c: (np.log(abs(c)) + sc.xlogy(c*a - 1, x)
-                                        - x**c - sc.gammaln(a)),
-                          fillvalue=-np.inf)
+        return xpx.apply_where(
+            (x != 0) | (c > 0), (x, c),
+            lambda x, c: (np.log(abs(c)) + sc.xlogy(c*a - 1, x) - x**c - sc.gammaln(a)),
+            fill_value=-np.inf)
 
     def _cdf(self, x, a, c):
         xc = x**c
@@ -3907,8 +3906,7 @@ class gengamma_gen(rv_continuous):
                     - np.log(np.abs(c)) + (a**-1.)/6 - (a**-3.)/90
                     + (np.log(a) - (a**-1.)/2 - (a**-2.)/12 + (a**-4.)/120)/c)
 
-        h = _lazywhere(a >= 2e2, (a, c), f=asymptotic, f2=regular)
-        return h
+        return xpx.apply_where(a >= 200, (a, c), asymptotic, regular)
 
 
 gengamma = gengamma_gen(a=0.0, name='gengamma')
@@ -4611,9 +4609,9 @@ class halflogistic_gen(rv_continuous):
         return 2 * sc.expit(-x)
 
     def _isf(self, q):
-        return _lazywhere(q < 0.5, (q, ),
-                          lambda q: -sc.logit(0.5 * q),
-                          f2=lambda q: 2*np.arctanh(1 - q))
+        return xpx.apply_where(q < 0.5, q,
+                               lambda q: -sc.logit(0.5 * q),
+                               lambda q: 2*np.arctanh(1 - q))
 
     def _munp(self, n):
         if n == 0:
@@ -4942,19 +4940,23 @@ class invgamma_gen(rv_continuous):
         return 1.0 / sc.gammaincinv(a, q)
 
     def _stats(self, a, moments='mvsk'):
-        m1 = _lazywhere(a > 1, (a,), lambda x: 1. / (x - 1.), np.inf)
-        m2 = _lazywhere(a > 2, (a,), lambda x: 1. / (x - 1.)**2 / (x - 2.),
-                        np.inf)
+        m1 = xpx.apply_where(a > 1, a,
+                             lambda x: 1. / (x - 1.),
+                             fill_value=np.inf)
+        m2 = xpx.apply_where(a > 2, a,
+                             lambda x: 1. / (x - 1.)**2 / (x - 2.),
+                             fill_value=np.inf)
 
         g1, g2 = None, None
         if 's' in moments:
-            g1 = _lazywhere(
-                a > 3, (a,),
-                lambda x: 4. * np.sqrt(x - 2.) / (x - 3.), np.nan)
+            g1 = xpx.apply_where(a > 3, a,
+                                 lambda x: 4. * np.sqrt(x - 2.) / (x - 3.),
+                                 fill_value=np.nan)
         if 'k' in moments:
-            g2 = _lazywhere(
-                a > 4, (a,),
-                lambda x: 6. * (5. * x - 11.) / (x - 3.) / (x - 4.), np.nan)
+            g2 = xpx.apply_where(a > 4, a,
+                                 lambda x: 6. * (5. * x - 11.) / (x - 3.) / (x - 4.),
+                                 fill_value=np.nan)
+
         return m1, m2, g1, g2
 
     def _entropy(self, a):
@@ -4969,7 +4971,7 @@ class invgamma_gen(rv_continuous):
                  + 2/3*a**-1. + a**-2./12 - a**-3./90 - a**-4./120)
             return h
 
-        h = _lazywhere(a >= 2e2, (a,), f=asymptotic, f2=regular)
+        h = xpx.apply_where(a >= 200, a, asymptotic, regular)
         return h
 
 
@@ -5029,10 +5031,10 @@ class invgauss_gen(rv_continuous):
     def _pdf(self, x, mu):
         # invgauss.pdf(x, mu) =
         #                  1 / sqrt(2*pi*x**3) * exp(-(x-mu)**2/(2*x*mu**2))
-        return 1.0/np.sqrt(2*np.pi*x**3.0)*np.exp(-1.0/(2*x)*((x-mu)/mu)**2)
+        return 1.0/np.sqrt(2*np.pi*x**3.0)*np.exp(-1.0/(2*x)*(x/mu - 1)**2)
 
     def _logpdf(self, x, mu):
-        return -0.5*np.log(2*np.pi) - 1.5*np.log(x) - ((x-mu)/mu)**2/(2*x)
+        return -0.5*np.log(2*np.pi) - 1.5*np.log(x) - (x/mu - 1)**2/(2*x)
 
     # approach adapted from equations in
     # https://journal.r-project.org/archive/2016-1/giner-smyth.pdf,
@@ -5040,14 +5042,14 @@ class invgauss_gen(rv_continuous):
 
     def _logcdf(self, x, mu):
         fac = 1 / np.sqrt(x)
-        a = _norm_logcdf(fac * ((x / mu) - 1))
-        b = 2 / mu + _norm_logcdf(-fac * ((x / mu) + 1))
+        a = _norm_logcdf(fac * (x/mu - 1))
+        b = 2 / mu + _norm_logcdf(-fac * (x/mu + 1))
         return a + np.log1p(np.exp(b - a))
 
     def _logsf(self, x, mu):
         fac = 1 / np.sqrt(x)
-        a = _norm_logsf(fac * ((x / mu) - 1))
-        b = 2 / mu + _norm_logcdf(-fac * (x + mu) / mu)
+        a = _norm_logsf(fac * (x/mu - 1))
+        b = 2 / mu + _norm_logcdf(-fac * (x/mu + 1))
         return a + np.log1p(-np.exp(b - a))
 
     def _sf(self, x, mu):
@@ -5211,9 +5213,9 @@ class geninvgauss_gen(rv_continuous):
 
     def _logquasipdf(self, x, p, b):
         # log of the quasi-density (w/o normalizing constant) used in _rvs
-        return _lazywhere(x > 0, (x, p, b),
-                          lambda x, p, b: (p - 1)*np.log(x) - b*(x + 1/x)/2,
-                          -np.inf)
+        return xpx.apply_where(x > 0, (x, p, b),
+                               lambda x, p, b: (p - 1)*np.log(x) - b*(x + 1/x)/2,
+                               fill_value=-np.inf)
 
     def _rvs(self, p, b, size=None, random_state=None):
         # if p and b are scalar, use _rvs_scalar, otherwise need to create
@@ -5761,11 +5763,11 @@ class jf_skew_t_gen(rv_continuous):
             return num / denom * sum_terms.sum()
 
         nth_moment_valid = (a > 0.5 * n) & (b > 0.5 * n) & (n >= 0)
-        return _lazywhere(
+        return xpx.apply_where(
             nth_moment_valid,
             (n, a, b),
             np.vectorize(nth_moment, otypes=[np.float64]),
-            np.nan,
+            fill_value=np.nan,
         )
 
 
@@ -6633,31 +6635,35 @@ class loggamma_gen(rv_continuous):
         # That is,
         #     exp(x)**c/Gamma(c+1) = exp(log(exp(x)**c/Gamma(c+1)))
         #                          = exp(c*x - gammaln(c+1))
-        return _lazywhere(x < _LOGXMIN, (x, c),
-                          lambda x, c: np.exp(c*x - sc.gammaln(c+1)),
-                          f2=lambda x, c: sc.gammainc(c, np.exp(x)))
+        return xpx.apply_where(
+            x < _LOGXMIN, (x, c),
+            lambda x, c: np.exp(c*x - sc.gammaln(c+1)),
+            lambda x, c: sc.gammainc(c, np.exp(x)))
 
     def _ppf(self, q, c):
         # The expression used when g < _XMIN inverts the one term expansion
         # given in the comments of _cdf().
         g = sc.gammaincinv(c, q)
-        return _lazywhere(g < _XMIN, (g, q, c),
-                          lambda g, q, c: (np.log(q) + sc.gammaln(c+1))/c,
-                          f2=lambda g, q, c: np.log(g))
+        return xpx.apply_where(
+            g < _XMIN, (g, q, c),
+            lambda g, q, c: (np.log(q) + sc.gammaln(c+1))/c,
+            lambda g, q, c: np.log(g))            
 
     def _sf(self, x, c):
         # See the comments for _cdf() for how x < _LOGXMIN is handled.
-        return _lazywhere(x < _LOGXMIN, (x, c),
-                          lambda x, c: -np.expm1(c*x - sc.gammaln(c+1)),
-                          f2=lambda x, c: sc.gammaincc(c, np.exp(x)))
+        return xpx.apply_where(
+            x < _LOGXMIN, (x, c),
+            lambda x, c: -np.expm1(c*x - sc.gammaln(c+1)),
+            lambda x, c: sc.gammaincc(c, np.exp(x)))
 
     def _isf(self, q, c):
         # The expression used when g < _XMIN inverts the complement of
         # the one term expansion given in the comments of _cdf().
         g = sc.gammainccinv(c, q)
-        return _lazywhere(g < _XMIN, (g, q, c),
-                          lambda g, q, c: (np.log1p(-q) + sc.gammaln(c+1))/c,
-                          f2=lambda g, q, c: np.log(g))
+        return xpx.apply_where(
+            g < _XMIN, (g, q, c),
+            lambda g, q, c: (np.log1p(-q) + sc.gammaln(c+1))/c,
+            lambda g, q, c: np.log(g))
 
     def _stats(self, c):
         # See, for example, "A Statistical Study of Log-Gamma Distribution", by
@@ -6679,8 +6685,7 @@ class loggamma_gen(rv_continuous):
             h = norm._entropy() + term
             return h
 
-        h = _lazywhere(c >= 45, (c, ), f=asymptotic, f2=regular)
-        return h
+        return xpx.apply_where(c >= 45, c, asymptotic, regular)
 
 
 loggamma = loggamma_gen(name='loggamma')
@@ -6786,10 +6791,11 @@ loglaplace = loglaplace_gen(a=0.0, name='loglaplace')
 
 
 def _lognorm_logpdf(x, s):
-    return _lazywhere(x != 0, (x, s),
-                      lambda x, s: (-np.log(x)**2 / (2 * s**2)
-                                    - np.log(s * x * np.sqrt(2 * np.pi))),
-                      -np.inf)
+    return xpx.apply_where(
+        x != 0, (x, s),
+        lambda x, s: (-np.log(x)**2 / (2 * s**2)
+                      - np.log(s * x * np.sqrt(2 * np.pi))),
+        fill_value=-np.inf)
 
 
 class lognorm_gen(rv_continuous):
@@ -7184,7 +7190,7 @@ class mielke_gen(rv_continuous):
             # n-th moment is defined for -k < n < s
             return sc.gamma((k+n)/s)*sc.gamma(1-n/s)/sc.gamma(k/s)
 
-        return _lazywhere(n < s, (n, k, s), nth_moment, np.inf)
+        return xpx.apply_where(n < s, (n, k, s), nth_moment, fill_value=np.inf)
 
 
 mielke = mielke_gen(a=0.0, name='mielke')
@@ -7752,11 +7758,11 @@ def _ncx2_log_pdf(x, df, nc):
     res = sc.xlogy(df2/2.0, x/nc) - 0.5*(xs - ns)**2
     corr = sc.ive(df2, xs*ns) / 2.0
     # Return res + np.log(corr) avoiding np.log(0)
-    return _lazywhere(
+    return xpx.apply_where(
         corr > 0,
         (res, corr),
-        f=lambda r, c: r + np.log(c),
-        fillvalue=-np.inf)
+        lambda r, c: r + np.log(c),
+        fill_value=-np.inf)
 
 
 class ncx2_gen(rv_continuous):
@@ -7807,39 +7813,33 @@ class ncx2_gen(rv_continuous):
         return random_state.noncentral_chisquare(df, nc, size)
 
     def _logpdf(self, x, df, nc):
-        cond = np.ones_like(x, dtype=bool) & (nc != 0)
-        return _lazywhere(cond, (x, df, nc), f=_ncx2_log_pdf,
-                          f2=lambda x, df, _: chi2._logpdf(x, df))
+        return xpx.apply_where(nc != 0, (x, df, nc), _ncx2_log_pdf,
+                               lambda x, df, _: chi2._logpdf(x, df))
 
     def _pdf(self, x, df, nc):
-        cond = np.ones_like(x, dtype=bool) & (nc != 0)
         with np.errstate(over='ignore'):  # see gh-17432
-            return _lazywhere(cond, (x, df, nc), f=scu._ncx2_pdf,
-                              f2=lambda x, df, _: chi2._pdf(x, df))
+            return xpx.apply_where(nc != 0, (x, df, nc), scu._ncx2_pdf,
+                                   lambda x, df, _: chi2._pdf(x, df))
 
     def _cdf(self, x, df, nc):
-        cond = np.ones_like(x, dtype=bool) & (nc != 0)
         with np.errstate(over='ignore'):  # see gh-17432
-            return _lazywhere(cond, (x, df, nc), f=scu._ncx2_cdf,
-                              f2=lambda x, df, _: chi2._cdf(x, df))
+            return xpx.apply_where(nc != 0, (x, df, nc), scu._ncx2_cdf,
+                                   lambda x, df, _: chi2._cdf(x, df))
 
     def _ppf(self, q, df, nc):
-        cond = np.ones_like(q, dtype=bool) & (nc != 0)
         with np.errstate(over='ignore'):  # see gh-17432
-            return _lazywhere(cond, (q, df, nc), f=scu._ncx2_ppf,
-                              f2=lambda x, df, _: chi2._ppf(x, df))
+            return xpx.apply_where(nc != 0, (q, df, nc), scu._ncx2_ppf,
+                                   lambda x, df, _: chi2._ppf(x, df))
 
     def _sf(self, x, df, nc):
-        cond = np.ones_like(x, dtype=bool) & (nc != 0)
         with np.errstate(over='ignore'):  # see gh-17432
-            return _lazywhere(cond, (x, df, nc), f=scu._ncx2_sf,
-                              f2=lambda x, df, _: chi2._sf(x, df))
+            return xpx.apply_where(nc != 0, (x, df, nc), scu._ncx2_sf,
+                                   lambda x, df, _: chi2._sf(x, df))
 
     def _isf(self, x, df, nc):
-        cond = np.ones_like(x, dtype=bool) & (nc != 0)
         with np.errstate(over='ignore'):  # see gh-17432
-            return _lazywhere(cond, (x, df, nc), f=scu._ncx2_isf,
-                              f2=lambda x, df, _: chi2._isf(x, df))
+            return xpx.apply_where(nc != 0, (x, df, nc), scu._ncx2_isf,
+                                   lambda x, df, _: chi2._isf(x, df))
 
     def _stats(self, df, nc):
         _ncx2_mean = df + nc
@@ -7998,13 +7998,10 @@ class t_gen(rv_continuous):
         return random_state.standard_t(df, size=size)
 
     def _pdf(self, x, df):
-        return _lazywhere(
+        return xpx.apply_where(
             df == np.inf, (x, df),
-            f=lambda x, df: norm._pdf(x),
-            f2=lambda x, df: (
-                np.exp(self._logpdf(x, df))
-            )
-        )
+            lambda x, df: norm._pdf(x),
+            lambda x, df: np.exp(self._logpdf(x, df)))
 
     def _logpdf(self, x, df):
 
@@ -8016,7 +8013,7 @@ class t_gen(rv_continuous):
         def norm_logpdf(x, df):
             return norm._logpdf(x)
 
-        return _lazywhere(df == np.inf, (x, df, ), f=norm_logpdf, f2=t_logpdf)
+        return xpx.apply_where(df == np.inf, (x, df), norm_logpdf, t_logpdf)
 
     def _cdf(self, x, df):
         return sc.stdtr(df, x)
@@ -8074,8 +8071,7 @@ class t_gen(rv_continuous):
                  - (df**-4.)/8 + 3/10*(df**-5.) + (df**-6.)/4)
             return h
 
-        h = _lazywhere(df >= 100, (df, ), f=asymptotic, f2=regular)
-        return h
+        return xpx.apply_where(df >= 100, df, asymptotic, regular)
 
 
 t = t_gen(name='t')
@@ -8134,8 +8130,7 @@ class nct_gen(rv_continuous):
         return sc.nctdtr(df, nc, x)
 
     def _ppf(self, q, df, nc):
-        with np.errstate(over='ignore'):  # see gh-17432
-            return scu._nct_ppf(q, df, nc)
+        return sc.nctdtrit(df, nc, q)
 
     def _sf(self, x, df, nc):
         with np.errstate(over='ignore'):  # see gh-17432
@@ -9505,10 +9500,11 @@ class recipinvgauss_gen(rv_continuous):
         return np.exp(self._logpdf(x, mu))
 
     def _logpdf(self, x, mu):
-        return _lazywhere(x > 0, (x, mu),
-                          lambda x, mu: (-(1 - mu*x)**2.0 / (2*x*mu**2.0)
-                                         - 0.5*np.log(2*np.pi*x)),
-                          fillvalue=-np.inf)
+        return xpx.apply_where(
+            x > 0, (x, mu),
+            lambda x, mu: (-(1 - mu*x)**2.0 / (2*x*mu**2.0)
+                           - 0.5*np.log(2*np.pi*x)),
+            fill_value=-np.inf)
 
     def _cdf(self, x, mu):
         trm1 = 1.0/mu - x
@@ -9699,16 +9695,16 @@ class skewnorm_gen(rv_continuous):
         return [_ShapeInfo("a", False, (-np.inf, np.inf), (False, False))]
 
     def _pdf(self, x, a):
-        return _lazywhere(
-            a == 0, (x, a), lambda x, a: _norm_pdf(x),
-            f2=lambda x, a: 2.*_norm_pdf(x)*_norm_cdf(a*x)
-        )
+        return xpx.apply_where(
+            a == 0, (x, a),
+            lambda x, a: _norm_pdf(x),
+            lambda x, a: 2.*_norm_pdf(x)*_norm_cdf(a*x))
 
     def _logpdf(self, x, a):
-        return _lazywhere(
-            a == 0, (x, a), lambda x, a: _norm_logpdf(x),
-            f2=lambda x, a: np.log(2)+_norm_logpdf(x)+_norm_logcdf(a*x),
-        )
+        return xpx.apply_where(
+            a == 0, (x, a),
+            lambda x, a: _norm_logpdf(x),
+            lambda x, a: np.log(2)+_norm_logpdf(x)+_norm_logcdf(a*x))
 
     def _cdf(self, x, a):
         a = np.atleast_1d(a)
@@ -9996,51 +9992,7 @@ class trapezoid_gen(rv_continuous):
         return 0.5 * (1.0-d+c) / (1.0+d-c) + np.log(0.5 * (1.0+d-c))
 
 
-# deprecation of trapz, see #20486
-deprmsg = ("`trapz` is deprecated in favour of `trapezoid` "
-           "and will be removed in SciPy 1.16.0.")
-
-
-class trapz_gen(trapezoid_gen):
-    # override __call__ protocol from rv_generic to also
-    # deprecate instantiation of frozen distributions
-    """
-
-    .. deprecated:: 1.14.0
-        `trapz` is deprecated and will be removed in SciPy 1.16.
-        Plese use `trapezoid` instead!
-    """
-    def __call__(self, *args, **kwds):
-        warnings.warn(deprmsg, DeprecationWarning, stacklevel=2)
-        return self.freeze(*args, **kwds)
-
-
 trapezoid = trapezoid_gen(a=0.0, b=1.0, name="trapezoid")
-trapz = trapz_gen(a=0.0, b=1.0, name="trapz")
-
-# since the deprecated class gets intantiated upon import (and we only want to
-# warn upon use), add the deprecation to each class method
-_method_names = [
-    "cdf", "entropy", "expect", "fit", "interval", "isf", "logcdf", "logpdf",
-    "logsf", "mean", "median", "moment", "pdf", "ppf", "rvs", "sf", "stats",
-    "std", "var"
-]
-
-
-class _DeprecationWrapper:
-    def __init__(self, method):
-        self.msg = (f"`trapz.{method}` is deprecated in favour of trapezoid.{method}. "
-                     "Please replace all uses of the distribution class "
-                     "`trapz` with `trapezoid`. `trapz` will be removed in SciPy 1.16.")
-        self.method = getattr(trapezoid, method)
-
-    def __call__(self, *args, **kwargs):
-        warnings.warn(self.msg, DeprecationWarning, stacklevel=2)
-        return self.method(*args, **kwargs)
-
-
-for m in _method_names:
-    setattr(trapz, m, _DeprecationWrapper(m))
 
 
 class triang_gen(rv_continuous):
@@ -10418,45 +10370,50 @@ class truncnorm_gen(rv_continuous):
             Returns n-th moment. Defined only if n >= 0.
             Function cannot broadcast due to the loop over n
             """
-            pA, pB = self._pdf(np.asarray([a, b]), a, b)
-            probs = [pA, -pB]
+            ab = np.asarray([a, b])
+            pA, pB = self._pdf(ab, a, b)
+            probs = np.asarray([pA, -pB])
+            cond = probs != 0
             moments = [0, 1]
             for k in range(1, n+1):
                 # a or b might be infinite, and the corresponding pdf value
                 # is 0 in that case, but nan is returned for the
                 # multiplication.  However, as b->infinity,  pdf(b)*b**k -> 0.
-                # So it is safe to use _lazywhere to avoid the nan.
-                vals = _lazywhere(probs, [probs, [a, b]],
-                                  lambda x, y: x * y**(k-1), fillvalue=0)
+                # So it is safe to use xpx.apply_where to avoid the nan.
+                vals = xpx.apply_where(cond, (probs, ab),
+                                       lambda x, y: x * y**(k-1),
+                                       fill_value=0)
                 mk = np.sum(vals) + (k-1) * moments[-2]
                 moments.append(mk)
             return moments[-1]
 
-        return _lazywhere((n >= 0) & (a == a) & (b == b), (n, a, b),
-                          np.vectorize(n_th_moment, otypes=[np.float64]),
-                          np.nan)
+        return xpx.apply_where((n >= 0) & (a == a) & (b == b), (n, a, b),
+                               np.vectorize(n_th_moment, otypes=[np.float64]),
+                               fill_value=np.nan)
 
     def _stats(self, a, b, moments='mv'):
         pA, pB = self.pdf(np.array([a, b]), a, b)
 
-        def _truncnorm_stats_scalar(a, b, pA, pB, moments):
+        def _truncnorm_stats_scalar(a, b, pA, pB):
+            ab = np.asarray([a, b])
             m1 = pA - pB
             mu = m1
-            # use _lazywhere to avoid nan (See detailed comment in _munp)
-            probs = [pA, -pB]
-            vals = _lazywhere(probs, [probs, [a, b]], lambda x, y: x*y,
-                              fillvalue=0)
+            # use xpx.apply_where to avoid nan (See detailed comment in _munp)
+            probs = np.asarray([pA, -pB])
+            cond = probs != 0
+            vals = xpx.apply_where(cond, (probs, ab), lambda x, y: x*y,
+                                   fill_value=0)
             m2 = 1 + np.sum(vals)
-            vals = _lazywhere(probs, [probs, [a-mu, b-mu]], lambda x, y: x*y,
-                              fillvalue=0)
+            vals = xpx.apply_where(cond, (probs, ab - mu), lambda x, y: x*y,
+                                   fill_value=0)
             # mu2 = m2 - mu**2, but not as numerically stable as:
             # mu2 = (a-mu)*pA - (b-mu)*pB + 1
             mu2 = 1 + np.sum(vals)
-            vals = _lazywhere(probs, [probs, [a, b]], lambda x, y: x*y**2,
-                              fillvalue=0)
+            vals = xpx.apply_where(cond, (probs, ab), lambda x, y: x*y**2,
+                                   fill_value=0)
             m3 = 2*m1 + np.sum(vals)
-            vals = _lazywhere(probs, [probs, [a, b]], lambda x, y: x*y**3,
-                              fillvalue=0)
+            vals = xpx.apply_where(cond, (probs, ab), lambda x, y: x*y**3,
+                                   fill_value=0)
             m4 = 3*m2 + np.sum(vals)
 
             mu3 = m3 + m1 * (-3*m2 + 2*m1**2)
@@ -10465,9 +10422,8 @@ class truncnorm_gen(rv_continuous):
             g2 = mu4 / mu2**2 - 3
             return mu, mu2, g1, g2
 
-        _truncnorm_stats = np.vectorize(_truncnorm_stats_scalar,
-                                        excluded=('moments',))
-        return _truncnorm_stats(a, b, pA, pB, moments)
+        _truncnorm_stats = np.vectorize(_truncnorm_stats_scalar)
+        return _truncnorm_stats(a, b, pA, pB)
 
 
 truncnorm = truncnorm_gen(name='truncnorm', momtype=1)
@@ -10827,9 +10783,9 @@ class tukeylambda_gen(rv_continuous):
         return [_ShapeInfo("lam", False, (-np.inf, np.inf), (False, False))]
 
     def _get_support(self, lam):
-        b = _lazywhere(lam > 0, (lam,),
-                       f=lambda lam: 1/lam,
-                       fillvalue=np.inf)
+        b = xpx.apply_where(lam > 0, lam,
+                            lambda lam: 1/lam,
+                            fill_value=np.inf)
         return -b, b
 
     def _pdf(self, x, lam):
@@ -11406,7 +11362,7 @@ class wrapcauchy_gen(rv_continuous):
             return 1 - 1/np.pi * np.arctan(cr*np.tan((2*np.pi - x)/2))
 
         cr = (1 + c)/(1 - c)
-        return _lazywhere(x < np.pi, (x, cr), f=f1, f2=f2)
+        return xpx.apply_where(x < np.pi, (x, cr), f1, f2)
 
     def _ppf(self, q, c):
         val = (1.0-c)/(1.0+c)
@@ -11425,6 +11381,10 @@ class wrapcauchy_gen(rv_continuous):
             data = data._uncensor()
         return 0.5, np.min(data), np.ptp(data)/(2*np.pi)
 
+    @inherit_docstring_from(rv_continuous)
+    def rvs(self, *args, **kwds):
+        rvs = super().rvs(*args, **kwds)
+        return np.mod(rvs, 2*np.pi)
 
 wrapcauchy = wrapcauchy_gen(a=0.0, b=2*np.pi, name='wrapcauchy')
 
@@ -11497,6 +11457,15 @@ class gennorm_gen(rv_continuous):
     def _isf(self, x, beta):
         return -self._ppf(x, beta)
 
+    def _munp(self, n, beta):
+        if n == 0:
+            return 1.
+        if n % 2 == 0:
+            c1, cn = sc.gammaln([1.0/beta, (n + 1.0)/beta])
+            return np.exp(cn - c1)
+        else:
+            return 0.
+
     def _stats(self, beta):
         c1, c3, c5 = sc.gammaln([1.0/beta, 3.0/beta, 5.0/beta])
         return 0., np.exp(c3 - c1), 0., np.exp(c5 + c1 - 2.0*c3) - 3.
@@ -11657,7 +11626,7 @@ class crystalball_gen(rv_continuous):
             return ((m/beta)**m * np.exp(-beta**2 / 2.0) *
                     (m/beta - beta - x)**(-m))
 
-        return N * _lazywhere(x > -beta, (x, beta, m), f=rhs, f2=lhs)
+        return N * xpx.apply_where(x > -beta, (x, beta, m), rhs, lhs)
 
     def _logpdf(self, x, beta, m):
         """
@@ -11672,7 +11641,7 @@ class crystalball_gen(rv_continuous):
         def lhs(x, beta, m):
             return m*np.log(m/beta) - beta**2/2 - m*np.log(m/beta - beta - x)
 
-        return np.log(N) + _lazywhere(x > -beta, (x, beta, m), f=rhs, f2=lhs)
+        return np.log(N) + xpx.apply_where(x > -beta, (x, beta, m), rhs, lhs)
 
     def _cdf(self, x, beta, m):
         """
@@ -11689,7 +11658,7 @@ class crystalball_gen(rv_continuous):
             return ((m/beta)**m * np.exp(-beta**2 / 2.0) *
                     (m/beta - beta - x)**(-m+1) / (m-1))
 
-        return N * _lazywhere(x > -beta, (x, beta, m), f=rhs, f2=lhs)
+        return N * xpx.apply_where(x > -beta, (x, beta, m), rhs, lhs)
 
     def _sf(self, x, beta, m):
         """
@@ -11705,7 +11674,7 @@ class crystalball_gen(rv_continuous):
             # Default behavior is OK in the left tail of the SF.
             return 1 - self._cdf(x, beta, m)
 
-        return _lazywhere(x > -beta, (x, beta, m), f=rhs, f2=lhs)
+        return xpx.apply_where(x > -beta, (x, beta, m), rhs, lhs)
 
     def _ppf(self, p, beta, m):
         N = 1.0 / (m/beta / (m-1) * np.exp(-beta**2 / 2.0) +
@@ -11725,7 +11694,7 @@ class crystalball_gen(rv_continuous):
             N = 1/(C + _norm_pdf_C * _norm_cdf(beta))
             return _norm_ppf(_norm_cdf(-beta) + (1/_norm_pdf_C)*(p/N - C))
 
-        return _lazywhere(p < pbeta, (p, beta, m), f=ppf_less, f2=ppf_greater)
+        return xpx.apply_where(p < pbeta, (p, beta, m), ppf_less, ppf_greater)
 
     def _munp(self, n, beta, m):
         """
@@ -11749,9 +11718,9 @@ class crystalball_gen(rv_continuous):
                         (m/beta)**(-m + k + 1))
             return A * lhs + rhs
 
-        return N * _lazywhere(n + 1 < m, (n, beta, m),
-                              np.vectorize(n_th_moment, otypes=[np.float64]),
-                              np.inf)
+        return N * xpx.apply_where(n + 1 < m, (n, beta, m),
+                                   np.vectorize(n_th_moment, otypes=[np.float64]),
+                                   fill_value=np.inf)
 
 
 crystalball = crystalball_gen(name='crystalball', longname="A Crystalball Function")
@@ -12143,11 +12112,9 @@ class rv_histogram(rv_continuous):
 
     def _entropy(self):
         """Compute entropy of distribution"""
-        res = _lazywhere(self._hpdf[1:-1] > 0.0,
-                         (self._hpdf[1:-1],),
-                         np.log,
-                         0.0)
-        return -np.sum(self._hpdf[1:-1] * res * self._hbin_widths)
+        hpdf = self._hpdf[1:-1]
+        res = xpx.apply_where(hpdf > 0.0, hpdf, np.log, fill_value=0.0)
+        return -np.sum(hpdf * res * self._hbin_widths)
 
     def _updated_ctor_param(self):
         """