Add files using upload-large-folder tool

.gitattributes

@@ -232,3 +232,4 @@ Data/Tsukuyomi/wavs/VOICEACTRESS100_100.wav filter=lfs diff=lfs merge=lfs -text
 .venv/Lib/site-packages/torch/lib/cudnn_engines_precompiled64_9.dll filter=lfs diff=lfs merge=lfs -text
 .venv/Lib/site-packages/torch/lib/dnnl.lib filter=lfs diff=lfs merge=lfs -text
 .venv/Lib/site-packages/torch/lib/torch_cuda.dll filter=lfs diff=lfs merge=lfs -text
+.venv/Lib/site-packages/scipy/signal/_spectral.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text

.venv/Lib/site-packages/scipy/signal/_spectral.cp39-win_amd64.pyd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:34c12e9119432a42d10bb2fde95094848e3810fc5b47c12c09bbdaa7b821ee32
+size 1009152

.venv/Lib/site-packages/scipy/special/__init__.py

@@ -0,0 +1,863 @@
+"""
+========================================
+Special functions (:mod:`scipy.special`)
+========================================
+
+.. currentmodule:: scipy.special
+
+Almost all of the functions below accept NumPy arrays as input
+arguments as well as single numbers. This means they follow
+broadcasting and automatic array-looping rules. Technically,
+they are `NumPy universal functions
+<https://numpy.org/doc/stable/user/basics.ufuncs.html#ufuncs-basics>`_.
+Functions which do not accept NumPy arrays are marked by a warning
+in the section description.
+
+.. seealso::
+
+   `scipy.special.cython_special` -- Typed Cython versions of special functions
+
+
+Error handling
+==============
+
+Errors are handled by returning NaNs or other appropriate values.
+Some of the special function routines can emit warnings or raise
+exceptions when an error occurs. By default this is disabled; to
+query and control the current error handling state the following
+functions are provided.
+
+.. autosummary::
+   :toctree: generated/
+
+   geterr                 -- Get the current way of handling special-function errors.
+   seterr                 -- Set how special-function errors are handled.
+   errstate               -- Context manager for special-function error handling.
+   SpecialFunctionWarning -- Warning that can be emitted by special functions.
+   SpecialFunctionError   -- Exception that can be raised by special functions.
+
+Available functions
+===================
+
+Airy functions
+--------------
+
+.. autosummary::
+   :toctree: generated/
+
+   airy     -- Airy functions and their derivatives.
+   airye    -- Exponentially scaled Airy functions and their derivatives.
+   ai_zeros -- Compute `nt` zeros and values of the Airy function Ai and its derivative.
+   bi_zeros -- Compute `nt` zeros and values of the Airy function Bi and its derivative.
+   itairy   -- Integrals of Airy functions
+
+
+Elliptic functions and integrals
+--------------------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   ellipj    -- Jacobian elliptic functions.
+   ellipk    -- Complete elliptic integral of the first kind.
+   ellipkm1  -- Complete elliptic integral of the first kind around `m` = 1.
+   ellipkinc -- Incomplete elliptic integral of the first kind.
+   ellipe    -- Complete elliptic integral of the second kind.
+   ellipeinc -- Incomplete elliptic integral of the second kind.
+   elliprc   -- Degenerate symmetric integral RC.
+   elliprd   -- Symmetric elliptic integral of the second kind.
+   elliprf   -- Completely-symmetric elliptic integral of the first kind.
+   elliprg   -- Completely-symmetric elliptic integral of the second kind.
+   elliprj   -- Symmetric elliptic integral of the third kind.
+
+Bessel functions
+----------------
+
+.. autosummary::
+   :toctree: generated/
+
+   jv            -- Bessel function of the first kind of real order and \
+                    complex argument.
+   jve           -- Exponentially scaled Bessel function of order `v`.
+   yn            -- Bessel function of the second kind of integer order and \
+                    real argument.
+   yv            -- Bessel function of the second kind of real order and \
+                    complex argument.
+   yve           -- Exponentially scaled Bessel function of the second kind \
+                    of real order.
+   kn            -- Modified Bessel function of the second kind of integer \
+                    order `n`
+   kv            -- Modified Bessel function of the second kind of real order \
+                    `v`
+   kve           -- Exponentially scaled modified Bessel function of the \
+                    second kind.
+   iv            -- Modified Bessel function of the first kind of real order.
+   ive           -- Exponentially scaled modified Bessel function of the \
+                    first kind.
+   hankel1       -- Hankel function of the first kind.
+   hankel1e      -- Exponentially scaled Hankel function of the first kind.
+   hankel2       -- Hankel function of the second kind.
+   hankel2e      -- Exponentially scaled Hankel function of the second kind.
+   wright_bessel -- Wright's generalized Bessel function.
+
+The following function does not accept NumPy arrays (it is not a
+universal function):
+
+.. autosummary::
+   :toctree: generated/
+
+   lmbda -- Jahnke-Emden Lambda function, Lambdav(x).
+
+Zeros of Bessel functions
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The following functions do not accept NumPy arrays (they are not
+universal functions):
+
+.. autosummary::
+   :toctree: generated/
+
+   jnjnp_zeros -- Compute zeros of integer-order Bessel functions Jn and Jn'.
+   jnyn_zeros  -- Compute nt zeros of Bessel functions Jn(x), Jn'(x), Yn(x), and Yn'(x).
+   jn_zeros    -- Compute zeros of integer-order Bessel function Jn(x).
+   jnp_zeros   -- Compute zeros of integer-order Bessel function derivative Jn'(x).
+   yn_zeros    -- Compute zeros of integer-order Bessel function Yn(x).
+   ynp_zeros   -- Compute zeros of integer-order Bessel function derivative Yn'(x).
+   y0_zeros    -- Compute nt zeros of Bessel function Y0(z), and derivative at each zero.
+   y1_zeros    -- Compute nt zeros of Bessel function Y1(z), and derivative at each zero.
+   y1p_zeros   -- Compute nt zeros of Bessel derivative Y1'(z), and value at each zero.
+
+Faster versions of common Bessel functions
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   j0  -- Bessel function of the first kind of order 0.
+   j1  -- Bessel function of the first kind of order 1.
+   y0  -- Bessel function of the second kind of order 0.
+   y1  -- Bessel function of the second kind of order 1.
+   i0  -- Modified Bessel function of order 0.
+   i0e -- Exponentially scaled modified Bessel function of order 0.
+   i1  -- Modified Bessel function of order 1.
+   i1e -- Exponentially scaled modified Bessel function of order 1.
+   k0  -- Modified Bessel function of the second kind of order 0, :math:`K_0`.
+   k0e -- Exponentially scaled modified Bessel function K of order 0
+   k1  -- Modified Bessel function of the second kind of order 1, :math:`K_1(x)`.
+   k1e -- Exponentially scaled modified Bessel function K of order 1.
+
+Integrals of Bessel functions
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   itj0y0     -- Integrals of Bessel functions of order 0.
+   it2j0y0    -- Integrals related to Bessel functions of order 0.
+   iti0k0     -- Integrals of modified Bessel functions of order 0.
+   it2i0k0    -- Integrals related to modified Bessel functions of order 0.
+   besselpoly -- Weighted integral of a Bessel function.
+
+Derivatives of Bessel functions
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   jvp  -- Compute nth derivative of Bessel function Jv(z) with respect to `z`.
+   yvp  -- Compute nth derivative of Bessel function Yv(z) with respect to `z`.
+   kvp  -- Compute nth derivative of real-order modified Bessel function Kv(z)
+   ivp  -- Compute nth derivative of modified Bessel function Iv(z) with respect to `z`.
+   h1vp -- Compute nth derivative of Hankel function H1v(z) with respect to `z`.
+   h2vp -- Compute nth derivative of Hankel function H2v(z) with respect to `z`.
+
+Spherical Bessel functions
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   spherical_jn -- Spherical Bessel function of the first kind or its derivative.
+   spherical_yn -- Spherical Bessel function of the second kind or its derivative.
+   spherical_in -- Modified spherical Bessel function of the first kind or its derivative.
+   spherical_kn -- Modified spherical Bessel function of the second kind or its derivative.
+
+Riccati-Bessel functions
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+The following functions do not accept NumPy arrays (they are not
+universal functions):
+
+.. autosummary::
+   :toctree: generated/
+
+   riccati_jn -- Compute Ricatti-Bessel function of the first kind and its derivative.
+   riccati_yn -- Compute Ricatti-Bessel function of the second kind and its derivative.
+
+Struve functions
+----------------
+
+.. autosummary::
+   :toctree: generated/
+
+   struve       -- Struve function.
+   modstruve    -- Modified Struve function.
+   itstruve0    -- Integral of the Struve function of order 0.
+   it2struve0   -- Integral related to the Struve function of order 0.
+   itmodstruve0 -- Integral of the modified Struve function of order 0.
+
+
+Raw statistical functions
+-------------------------
+
+.. seealso:: :mod:`scipy.stats`: Friendly versions of these functions.
+
+Binomial distribution
+^^^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   bdtr         -- Binomial distribution cumulative distribution function.
+   bdtrc        -- Binomial distribution survival function.
+   bdtri        -- Inverse function to `bdtr` with respect to `p`.
+   bdtrik       -- Inverse function to `bdtr` with respect to `k`.
+   bdtrin       -- Inverse function to `bdtr` with respect to `n`.
+
+Beta distribution
+^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   btdtr        -- Cumulative distribution function of the beta distribution.
+   btdtri       -- The `p`-th quantile of the beta distribution.
+   btdtria      -- Inverse of `btdtr` with respect to `a`.
+   btdtrib      -- btdtria(a, p, x).
+
+F distribution
+^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   fdtr         -- F cumulative distribution function.
+   fdtrc        -- F survival function.
+   fdtri        -- The `p`-th quantile of the F-distribution.
+   fdtridfd     -- Inverse to `fdtr` vs dfd.
+
+Gamma distribution
+^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   gdtr         -- Gamma distribution cumulative distribution function.
+   gdtrc        -- Gamma distribution survival function.
+   gdtria       -- Inverse of `gdtr` vs a.
+   gdtrib       -- Inverse of `gdtr` vs b.
+   gdtrix       -- Inverse of `gdtr` vs x.
+
+Negative binomial distribution
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   nbdtr        -- Negative binomial cumulative distribution function.
+   nbdtrc       -- Negative binomial survival function.
+   nbdtri       -- Inverse of `nbdtr` vs `p`.
+   nbdtrik      -- Inverse of `nbdtr` vs `k`.
+   nbdtrin      -- Inverse of `nbdtr` vs `n`.
+
+Noncentral F distribution
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   ncfdtr       -- Cumulative distribution function of the non-central F distribution.
+   ncfdtridfd   -- Calculate degrees of freedom (denominator) for the noncentral F-distribution.
+   ncfdtridfn   -- Calculate degrees of freedom (numerator) for the noncentral F-distribution.
+   ncfdtri      -- Inverse cumulative distribution function of the non-central F distribution.
+   ncfdtrinc    -- Calculate non-centrality parameter for non-central F distribution.
+
+Noncentral t distribution
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   nctdtr       -- Cumulative distribution function of the non-central `t` distribution.
+   nctdtridf    -- Calculate degrees of freedom for non-central t distribution.
+   nctdtrit     -- Inverse cumulative distribution function of the non-central t distribution.
+   nctdtrinc    -- Calculate non-centrality parameter for non-central t distribution.
+
+Normal distribution
+^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   nrdtrimn     -- Calculate mean of normal distribution given other params.
+   nrdtrisd     -- Calculate standard deviation of normal distribution given other params.
+   ndtr         -- Normal cumulative distribution function.
+   log_ndtr     -- Logarithm of normal cumulative distribution function.
+   ndtri        -- Inverse of `ndtr` vs x.
+   ndtri_exp    -- Inverse of `log_ndtr` vs x.
+
+Poisson distribution
+^^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   pdtr         -- Poisson cumulative distribution function.
+   pdtrc        -- Poisson survival function.
+   pdtri        -- Inverse to `pdtr` vs m.
+   pdtrik       -- Inverse to `pdtr` vs k.
+
+Student t distribution
+^^^^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   stdtr        -- Student t distribution cumulative distribution function.
+   stdtridf     -- Inverse of `stdtr` vs df.
+   stdtrit      -- Inverse of `stdtr` vs `t`.
+
+Chi square distribution
+^^^^^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   chdtr        -- Chi square cumulative distribution function.
+   chdtrc       -- Chi square survival function.
+   chdtri       -- Inverse to `chdtrc`.
+   chdtriv      -- Inverse to `chdtr` vs `v`.
+
+Non-central chi square distribution
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   chndtr       -- Non-central chi square cumulative distribution function.
+   chndtridf    -- Inverse to `chndtr` vs `df`.
+   chndtrinc    -- Inverse to `chndtr` vs `nc`.
+   chndtrix     -- Inverse to `chndtr` vs `x`.
+
+Kolmogorov distribution
+^^^^^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   smirnov      -- Kolmogorov-Smirnov complementary cumulative distribution function.
+   smirnovi     -- Inverse to `smirnov`.
+   kolmogorov   -- Complementary cumulative distribution function of Kolmogorov distribution.
+   kolmogi      -- Inverse function to `kolmogorov`.
+
+Box-Cox transformation
+^^^^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   boxcox       -- Compute the Box-Cox transformation.
+   boxcox1p     -- Compute the Box-Cox transformation of 1 + `x`.
+   inv_boxcox   -- Compute the inverse of the Box-Cox transformation.
+   inv_boxcox1p -- Compute the inverse of the Box-Cox transformation.
+
+
+Sigmoidal functions
+^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   logit        -- Logit ufunc for ndarrays.
+   expit        -- Logistic sigmoid function.
+   log_expit    -- Logarithm of the logistic sigmoid function.
+
+Miscellaneous
+^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   tklmbda      -- Tukey-Lambda cumulative distribution function.
+   owens_t      -- Owen's T Function.
+
+
+Information Theory functions
+----------------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   entr         -- Elementwise function for computing entropy.
+   rel_entr     -- Elementwise function for computing relative entropy.
+   kl_div       -- Elementwise function for computing Kullback-Leibler divergence.
+   huber        -- Huber loss function.
+   pseudo_huber -- Pseudo-Huber loss function.
+
+
+Gamma and related functions
+---------------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   gamma        -- Gamma function.
+   gammaln      -- Logarithm of the absolute value of the Gamma function for real inputs.
+   loggamma     -- Principal branch of the logarithm of the Gamma function.
+   gammasgn     -- Sign of the gamma function.
+   gammainc     -- Regularized lower incomplete gamma function.
+   gammaincinv  -- Inverse to `gammainc`.
+   gammaincc    -- Regularized upper incomplete gamma function.
+   gammainccinv -- Inverse to `gammaincc`.
+   beta         -- Beta function.
+   betaln       -- Natural logarithm of absolute value of beta function.
+   betainc      -- Incomplete beta integral.
+   betaincc     -- Complemented incomplete beta integral.
+   betaincinv   -- Inverse function to beta integral.
+   betainccinv  -- Inverse of the complemented incomplete beta integral.
+   psi          -- The digamma function.
+   rgamma       -- Gamma function inverted.
+   polygamma    -- Polygamma function n.
+   multigammaln -- Returns the log of multivariate gamma, also sometimes called the generalized gamma.
+   digamma      -- psi(x[, out]).
+   poch         -- Rising factorial (z)_m.
+
+
+Error function and Fresnel integrals
+------------------------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   erf           -- Returns the error function of complex argument.
+   erfc          -- Complementary error function, ``1 - erf(x)``.
+   erfcx         -- Scaled complementary error function, ``exp(x**2) * erfc(x)``.
+   erfi          -- Imaginary error function, ``-i erf(i z)``.
+   erfinv        -- Inverse function for erf.
+   erfcinv       -- Inverse function for erfc.
+   wofz          -- Faddeeva function.
+   dawsn         -- Dawson's integral.
+   fresnel       -- Fresnel sin and cos integrals.
+   fresnel_zeros -- Compute nt complex zeros of sine and cosine Fresnel integrals S(z) and C(z).
+   modfresnelp   -- Modified Fresnel positive integrals.
+   modfresnelm   -- Modified Fresnel negative integrals.
+   voigt_profile -- Voigt profile.
+
+The following functions do not accept NumPy arrays (they are not
+universal functions):
+
+.. autosummary::
+   :toctree: generated/
+
+   erf_zeros      -- Compute nt complex zeros of error function erf(z).
+   fresnelc_zeros -- Compute nt complex zeros of cosine Fresnel integral C(z).
+   fresnels_zeros -- Compute nt complex zeros of sine Fresnel integral S(z).
+
+Legendre functions
+------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   lpmv     -- Associated Legendre function of integer order and real degree.
+   sph_harm -- Compute spherical harmonics.
+
+The following functions do not accept NumPy arrays (they are not
+universal functions):
+
+.. autosummary::
+   :toctree: generated/
+
+   clpmn -- Associated Legendre function of the first kind for complex arguments.
+   lpn   -- Legendre function of the first kind.
+   lqn   -- Legendre function of the second kind.
+   lpmn  -- Sequence of associated Legendre functions of the first kind.
+   lqmn  -- Sequence of associated Legendre functions of the second kind.
+
+Ellipsoidal harmonics
+---------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   ellip_harm   -- Ellipsoidal harmonic functions E^p_n(l).
+   ellip_harm_2 -- Ellipsoidal harmonic functions F^p_n(l).
+   ellip_normal -- Ellipsoidal harmonic normalization constants gamma^p_n.
+
+Orthogonal polynomials
+----------------------
+
+The following functions evaluate values of orthogonal polynomials:
+
+.. autosummary::
+   :toctree: generated/
+
+   assoc_laguerre   -- Compute the generalized (associated) Laguerre polynomial of degree n and order k.
+   eval_legendre    -- Evaluate Legendre polynomial at a point.
+   eval_chebyt      -- Evaluate Chebyshev polynomial of the first kind at a point.
+   eval_chebyu      -- Evaluate Chebyshev polynomial of the second kind at a point.
+   eval_chebyc      -- Evaluate Chebyshev polynomial of the first kind on [-2, 2] at a point.
+   eval_chebys      -- Evaluate Chebyshev polynomial of the second kind on [-2, 2] at a point.
+   eval_jacobi      -- Evaluate Jacobi polynomial at a point.
+   eval_laguerre    -- Evaluate Laguerre polynomial at a point.
+   eval_genlaguerre -- Evaluate generalized Laguerre polynomial at a point.
+   eval_hermite     -- Evaluate physicist's Hermite polynomial at a point.
+   eval_hermitenorm -- Evaluate probabilist's (normalized) Hermite polynomial at a point.
+   eval_gegenbauer  -- Evaluate Gegenbauer polynomial at a point.
+   eval_sh_legendre -- Evaluate shifted Legendre polynomial at a point.
+   eval_sh_chebyt   -- Evaluate shifted Chebyshev polynomial of the first kind at a point.
+   eval_sh_chebyu   -- Evaluate shifted Chebyshev polynomial of the second kind at a point.
+   eval_sh_jacobi   -- Evaluate shifted Jacobi polynomial at a point.
+
+The following functions compute roots and quadrature weights for
+orthogonal polynomials:
+
+.. autosummary::
+   :toctree: generated/
+
+   roots_legendre    -- Gauss-Legendre quadrature.
+   roots_chebyt      -- Gauss-Chebyshev (first kind) quadrature.
+   roots_chebyu      -- Gauss-Chebyshev (second kind) quadrature.
+   roots_chebyc      -- Gauss-Chebyshev (first kind) quadrature.
+   roots_chebys      -- Gauss-Chebyshev (second kind) quadrature.
+   roots_jacobi      -- Gauss-Jacobi quadrature.
+   roots_laguerre    -- Gauss-Laguerre quadrature.
+   roots_genlaguerre -- Gauss-generalized Laguerre quadrature.
+   roots_hermite     -- Gauss-Hermite (physicst's) quadrature.
+   roots_hermitenorm -- Gauss-Hermite (statistician's) quadrature.
+   roots_gegenbauer  -- Gauss-Gegenbauer quadrature.
+   roots_sh_legendre -- Gauss-Legendre (shifted) quadrature.
+   roots_sh_chebyt   -- Gauss-Chebyshev (first kind, shifted) quadrature.
+   roots_sh_chebyu   -- Gauss-Chebyshev (second kind, shifted) quadrature.
+   roots_sh_jacobi   -- Gauss-Jacobi (shifted) quadrature.
+
+The functions below, in turn, return the polynomial coefficients in
+``orthopoly1d`` objects, which function similarly as `numpy.poly1d`.
+The ``orthopoly1d`` class also has an attribute ``weights``, which returns
+the roots, weights, and total weights for the appropriate form of Gaussian
+quadrature. These are returned in an ``n x 3`` array with roots in the first
+column, weights in the second column, and total weights in the final column.
+Note that ``orthopoly1d`` objects are converted to `~numpy.poly1d` when doing
+arithmetic, and lose information of the original orthogonal polynomial.
+
+.. autosummary::
+   :toctree: generated/
+
+   legendre    -- Legendre polynomial.
+   chebyt      -- Chebyshev polynomial of the first kind.
+   chebyu      -- Chebyshev polynomial of the second kind.
+   chebyc      -- Chebyshev polynomial of the first kind on :math:`[-2, 2]`.
+   chebys      -- Chebyshev polynomial of the second kind on :math:`[-2, 2]`.
+   jacobi      -- Jacobi polynomial.
+   laguerre    -- Laguerre polynomial.
+   genlaguerre -- Generalized (associated) Laguerre polynomial.
+   hermite     -- Physicist's Hermite polynomial.
+   hermitenorm -- Normalized (probabilist's) Hermite polynomial.
+   gegenbauer  -- Gegenbauer (ultraspherical) polynomial.
+   sh_legendre -- Shifted Legendre polynomial.
+   sh_chebyt   -- Shifted Chebyshev polynomial of the first kind.
+   sh_chebyu   -- Shifted Chebyshev polynomial of the second kind.
+   sh_jacobi   -- Shifted Jacobi polynomial.
+
+.. warning::
+
+   Computing values of high-order polynomials (around ``order > 20``) using
+   polynomial coefficients is numerically unstable. To evaluate polynomial
+   values, the ``eval_*`` functions should be used instead.
+
+
+Hypergeometric functions
+------------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   hyp2f1 -- Gauss hypergeometric function 2F1(a, b; c; z).
+   hyp1f1 -- Confluent hypergeometric function 1F1(a, b; x).
+   hyperu -- Confluent hypergeometric function U(a, b, x) of the second kind.
+   hyp0f1 -- Confluent hypergeometric limit function 0F1.
+
+
+Parabolic cylinder functions
+----------------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   pbdv -- Parabolic cylinder function D.
+   pbvv -- Parabolic cylinder function V.
+   pbwa -- Parabolic cylinder function W.
+
+The following functions do not accept NumPy arrays (they are not
+universal functions):
+
+.. autosummary::
+   :toctree: generated/
+
+   pbdv_seq -- Parabolic cylinder functions Dv(x) and derivatives.
+   pbvv_seq -- Parabolic cylinder functions Vv(x) and derivatives.
+   pbdn_seq -- Parabolic cylinder functions Dn(z) and derivatives.
+
+Mathieu and related functions
+-----------------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   mathieu_a -- Characteristic value of even Mathieu functions.
+   mathieu_b -- Characteristic value of odd Mathieu functions.
+
+The following functions do not accept NumPy arrays (they are not
+universal functions):
+
+.. autosummary::
+   :toctree: generated/
+
+   mathieu_even_coef -- Fourier coefficients for even Mathieu and modified Mathieu functions.
+   mathieu_odd_coef  -- Fourier coefficients for even Mathieu and modified Mathieu functions.
+
+The following return both function and first derivative:
+
+.. autosummary::
+   :toctree: generated/
+
+   mathieu_cem     -- Even Mathieu function and its derivative.
+   mathieu_sem     -- Odd Mathieu function and its derivative.
+   mathieu_modcem1 -- Even modified Mathieu function of the first kind and its derivative.
+   mathieu_modcem2 -- Even modified Mathieu function of the second kind and its derivative.
+   mathieu_modsem1 -- Odd modified Mathieu function of the first kind and its derivative.
+   mathieu_modsem2 -- Odd modified Mathieu function of the second kind and its derivative.
+
+Spheroidal wave functions
+-------------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   pro_ang1   -- Prolate spheroidal angular function of the first kind and its derivative.
+   pro_rad1   -- Prolate spheroidal radial function of the first kind and its derivative.
+   pro_rad2   -- Prolate spheroidal radial function of the second kind and its derivative.
+   obl_ang1   -- Oblate spheroidal angular function of the first kind and its derivative.
+   obl_rad1   -- Oblate spheroidal radial function of the first kind and its derivative.
+   obl_rad2   -- Oblate spheroidal radial function of the second kind and its derivative.
+   pro_cv     -- Characteristic value of prolate spheroidal function.
+   obl_cv     -- Characteristic value of oblate spheroidal function.
+   pro_cv_seq -- Characteristic values for prolate spheroidal wave functions.
+   obl_cv_seq -- Characteristic values for oblate spheroidal wave functions.
+
+The following functions require pre-computed characteristic value:
+
+.. autosummary::
+   :toctree: generated/
+
+   pro_ang1_cv -- Prolate spheroidal angular function pro_ang1 for precomputed characteristic value.
+   pro_rad1_cv -- Prolate spheroidal radial function pro_rad1 for precomputed characteristic value.
+   pro_rad2_cv -- Prolate spheroidal radial function pro_rad2 for precomputed characteristic value.
+   obl_ang1_cv -- Oblate spheroidal angular function obl_ang1 for precomputed characteristic value.
+   obl_rad1_cv -- Oblate spheroidal radial function obl_rad1 for precomputed characteristic value.
+   obl_rad2_cv -- Oblate spheroidal radial function obl_rad2 for precomputed characteristic value.
+
+Kelvin functions
+----------------
+
+.. autosummary::
+   :toctree: generated/
+
+   kelvin       -- Kelvin functions as complex numbers.
+   kelvin_zeros -- Compute nt zeros of all Kelvin functions.
+   ber          -- Kelvin function ber.
+   bei          -- Kelvin function bei
+   berp         -- Derivative of the Kelvin function `ber`.
+   beip         -- Derivative of the Kelvin function `bei`.
+   ker          -- Kelvin function ker.
+   kei          -- Kelvin function ker.
+   kerp         -- Derivative of the Kelvin function ker.
+   keip         -- Derivative of the Kelvin function kei.
+
+The following functions do not accept NumPy arrays (they are not
+universal functions):
+
+.. autosummary::
+   :toctree: generated/
+
+   ber_zeros  -- Compute nt zeros of the Kelvin function ber(x).
+   bei_zeros  -- Compute nt zeros of the Kelvin function bei(x).
+   berp_zeros -- Compute nt zeros of the Kelvin function ber'(x).
+   beip_zeros -- Compute nt zeros of the Kelvin function bei'(x).
+   ker_zeros  -- Compute nt zeros of the Kelvin function ker(x).
+   kei_zeros  -- Compute nt zeros of the Kelvin function kei(x).
+   kerp_zeros -- Compute nt zeros of the Kelvin function ker'(x).
+   keip_zeros -- Compute nt zeros of the Kelvin function kei'(x).
+
+Combinatorics
+-------------
+
+.. autosummary::
+   :toctree: generated/
+
+   comb -- The number of combinations of N things taken k at a time.
+   perm -- Permutations of N things taken k at a time, i.e., k-permutations of N.
+   stirling2 -- Stirling numbers of the second kind.
+
+Lambert W and related functions
+-------------------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   lambertw    -- Lambert W function.
+   wrightomega -- Wright Omega function.
+
+Other special functions
+-----------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   agm         -- Arithmetic, Geometric Mean.
+   bernoulli   -- Bernoulli numbers B0..Bn (inclusive).
+   binom       -- Binomial coefficient
+   diric       -- Periodic sinc function, also called the Dirichlet function.
+   euler       -- Euler numbers E0..En (inclusive).
+   expn        -- Exponential integral E_n.
+   exp1        -- Exponential integral E_1 of complex argument z.
+   expi        -- Exponential integral Ei.
+   factorial   -- The factorial of a number or array of numbers.
+   factorial2  -- Double factorial.
+   factorialk  -- Multifactorial of n of order k, n(!!...!).
+   shichi      -- Hyperbolic sine and cosine integrals.
+   sici        -- Sine and cosine integrals.
+   softmax     -- Softmax function.
+   log_softmax -- Logarithm of softmax function.
+   spence      -- Spence's function, also known as the dilogarithm.
+   zeta        -- Riemann zeta function.
+   zetac       -- Riemann zeta function minus 1.
+
+Convenience functions
+---------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   cbrt      -- Cube root of `x`.
+   exp10     -- 10**x.
+   exp2      -- 2**x.
+   radian    -- Convert from degrees to radians.
+   cosdg     -- Cosine of the angle `x` given in degrees.
+   sindg     -- Sine of angle given in degrees.
+   tandg     -- Tangent of angle x given in degrees.
+   cotdg     -- Cotangent of the angle `x` given in degrees.
+   log1p     -- Calculates log(1+x) for use when `x` is near zero.
+   expm1     -- ``exp(x) - 1`` for use when `x` is near zero.
+   cosm1     -- ``cos(x) - 1`` for use when `x` is near zero.
+   powm1     -- ``x**y - 1`` for use when `y` is near zero or `x` is near 1.
+   round     -- Round to nearest integer.
+   xlogy     -- Compute ``x*log(y)`` so that the result is 0 if ``x = 0``.
+   xlog1py   -- Compute ``x*log1p(y)`` so that the result is 0 if ``x = 0``.
+   logsumexp -- Compute the log of the sum of exponentials of input elements.
+   exprel    -- Relative error exponential, (exp(x)-1)/x, for use when `x` is near zero.
+   sinc      -- Return the sinc function.
+
+"""  # noqa: E501
+
+import warnings
+
+from ._sf_error import SpecialFunctionWarning, SpecialFunctionError
+
+from . import _ufuncs
+from ._ufuncs import *
+
+# Replace some function definitions from _ufuncs to add Array API support
+from ._support_alternative_backends import (
+    log_ndtr, ndtr, ndtri, erf, erfc, i0, i0e, i1, i1e,
+    gammaln, gammainc, gammaincc, logit, expit)
+
+from . import _basic
+from ._basic import *
+
+from ._logsumexp import logsumexp, softmax, log_softmax
+
+from . import _orthogonal
+from ._orthogonal import *
+
+from ._spfun_stats import multigammaln
+from ._ellip_harm import (
+    ellip_harm,
+    ellip_harm_2,
+    ellip_normal
+)
+from ._lambertw import lambertw
+from ._spherical_bessel import (
+    spherical_jn,
+    spherical_yn,
+    spherical_in,
+    spherical_kn
+)
+
+# Deprecated namespaces, to be removed in v2.0.0
+from . import add_newdocs, basic, orthogonal, specfun, sf_error, spfun_stats
+
+# We replace some function definitions from _ufuncs with those from
+# _support_alternative_backends above, but those are all listed in _ufuncs.__all__,
+# so there is no need to consider _support_alternative_backends.__all__ here.
+__all__ = _ufuncs.__all__ + _basic.__all__ + _orthogonal.__all__
+__all__ += [
+    'SpecialFunctionWarning',
+    'SpecialFunctionError',
+    'logsumexp',
+    'softmax',
+    'log_softmax',
+    'multigammaln',
+    'ellip_harm',
+    'ellip_harm_2',
+    'ellip_normal',
+    'lambertw',
+    'spherical_jn',
+    'spherical_yn',
+    'spherical_in',
+    'spherical_kn',
+]
+
+from scipy._lib._testutils import PytestTester
+test = PytestTester(__name__)
+del PytestTester
+
+_depr_msg = ('\nThis function was deprecated in SciPy 1.12.0, and will be '
+             'removed in SciPy 1.14.0.  Use scipy.special.{} instead.')
+
+
+def btdtr(*args, **kwargs):  # type: ignore [no-redef]
+    warnings.warn(_depr_msg.format('betainc'), category=DeprecationWarning,
+                  stacklevel=2)
+    return _ufuncs.btdtr(*args, **kwargs)
+
+
+btdtr.__doc__ = _ufuncs.btdtr.__doc__  # type: ignore [misc]
+
+
+def btdtri(*args, **kwargs):  # type: ignore [no-redef]
+    warnings.warn(_depr_msg.format('betaincinv'), category=DeprecationWarning,
+                  stacklevel=2)
+    return _ufuncs.btdtri(*args, **kwargs)
+
+
+btdtri.__doc__ = _ufuncs.btdtri.__doc__  # type: ignore [misc]
+
+
+def _get_include():
+    """This function is for development purposes only.
+
+    This function could disappear or its behavior could change at any time.
+    """
+    import os
+    return os.path.dirname(__file__)

.venv/Lib/site-packages/scipy/special/_precompute/cosine_cdf.py

@@ -0,0 +1,17 @@
+import mpmath
+
+
+def f(x):
+    return (mpmath.pi + x + mpmath.sin(x)) / (2*mpmath.pi)
+
+
+# Note: 40 digits might be overkill; a few more digits than the default
+# might be sufficient.
+mpmath.mp.dps = 40
+ts = mpmath.taylor(f, -mpmath.pi, 20)
+p, q = mpmath.pade(ts, 9, 10)
+
+p = [float(c) for c in p]
+q = [float(c) for c in q]
+print('p =', p)
+print('q =', q)

.venv/Lib/site-packages/scipy/special/_precompute/expn_asy.py

@@ -0,0 +1,54 @@
+"""Precompute the polynomials for the asymptotic expansion of the
+generalized exponential integral.
+
+Sources
+-------
+[1] NIST, Digital Library of Mathematical Functions,
+    https://dlmf.nist.gov/8.20#ii
+
+"""
+import os
+
+try:
+    import sympy
+    from sympy import Poly
+    x = sympy.symbols('x')
+except ImportError:
+    pass
+
+
+def generate_A(K):
+    A = [Poly(1, x)]
+    for k in range(K):
+        A.append(Poly(1 - 2*k*x, x)*A[k] + Poly(x*(x + 1))*A[k].diff())
+    return A
+
+
+WARNING = """\
+/* This file was automatically generated by _precompute/expn_asy.py.
+ * Do not edit it manually!
+ */
+"""
+
+
+def main():
+    print(__doc__)
+    fn = os.path.join('..', 'cephes', 'expn.h')
+
+    K = 12
+    A = generate_A(K)
+    with open(fn + '.new', 'w') as f:
+        f.write(WARNING)
+        f.write(f"#define nA {len(A)}\n")
+        for k, Ak in enumerate(A):
+            ', '.join([str(x.evalf(18)) for x in Ak.coeffs()])
+            f.write(f"static const double A{k}[] = {{tmp}};\n")
+        ", ".join([f"A{k}" for k in range(K + 1)])
+        f.write("static const double *A[] = {{tmp}};\n")
+        ", ".join([str(Ak.degree()) for Ak in A])
+        f.write("static const int Adegs[] = {{tmp}};\n")
+    os.rename(fn + '.new', fn)
+
+
+if __name__ == "__main__":
+    main()

.venv/Lib/site-packages/scipy/special/_precompute/gammainc_asy.py

@@ -0,0 +1,116 @@
+"""
+Precompute coefficients of Temme's asymptotic expansion for gammainc.
+
+This takes about 8 hours to run on a 2.3 GHz Macbook Pro with 4GB ram.
+
+Sources:
+[1] NIST, "Digital Library of Mathematical Functions",
+    https://dlmf.nist.gov/
+
+"""
+import os
+from scipy.special._precompute.utils import lagrange_inversion
+
+try:
+    import mpmath as mp
+except ImportError:
+    pass
+
+
+def compute_a(n):
+    """a_k from DLMF 5.11.6"""
+    a = [mp.sqrt(2)/2]
+    for k in range(1, n):
+        ak = a[-1]/k
+        for j in range(1, len(a)):
+            ak -= a[j]*a[-j]/(j + 1)
+        ak /= a[0]*(1 + mp.mpf(1)/(k + 1))
+        a.append(ak)
+    return a
+
+
+def compute_g(n):
+    """g_k from DLMF 5.11.3/5.11.5"""
+    a = compute_a(2*n)
+    g = [mp.sqrt(2)*mp.rf(0.5, k)*a[2*k] for k in range(n)]
+    return g
+
+
+def eta(lam):
+    """Function from DLMF 8.12.1 shifted to be centered at 0."""
+    if lam > 0:
+        return mp.sqrt(2*(lam - mp.log(lam + 1)))
+    elif lam < 0:
+        return -mp.sqrt(2*(lam - mp.log(lam + 1)))
+    else:
+        return 0
+
+
+def compute_alpha(n):
+    """alpha_n from DLMF 8.12.13"""
+    coeffs = mp.taylor(eta, 0, n - 1)
+    return lagrange_inversion(coeffs)
+
+
+def compute_d(K, N):
+    """d_{k, n} from DLMF 8.12.12"""
+    M = N + 2*K
+    d0 = [-mp.mpf(1)/3]
+    alpha = compute_alpha(M + 2)
+    for n in range(1, M):
+        d0.append((n + 2)*alpha[n+2])
+    d = [d0]
+    g = compute_g(K)
+    for k in range(1, K):
+        dk = []
+        for n in range(M - 2*k):
+            dk.append((-1)**k*g[k]*d[0][n] + (n + 2)*d[k-1][n+2])
+        d.append(dk)
+    for k in range(K):
+        d[k] = d[k][:N]
+    return d
+
+
+header = \
+r"""/* This file was automatically generated by _precomp/gammainc.py.
+ * Do not edit it manually!
+ */
+
+#ifndef IGAM_H
+#define IGAM_H
+
+#define K {}
+#define N {}
+
+static const double d[K][N] =
+{{"""
+
+footer = \
+r"""
+#endif
+"""
+
+
+def main():
+    print(__doc__)
+    K = 25
+    N = 25
+    with mp.workdps(50):
+        d = compute_d(K, N)
+    fn = os.path.join(os.path.dirname(__file__), '..', 'cephes', 'igam.h')
+    with open(fn + '.new', 'w') as f:
+        f.write(header.format(K, N))
+        for k, row in enumerate(d):
+            row = [mp.nstr(x, 17, min_fixed=0, max_fixed=0) for x in row]
+            f.write('{')
+            f.write(", ".join(row))
+            if k < K - 1:
+                f.write('},\n')
+            else:
+                f.write('}};\n')
+        f.write(footer)
+    os.rename(fn + '.new', fn)
+
+
+if __name__ == "__main__":
+    main()

.venv/Lib/site-packages/scipy/special/_precompute/gammainc_data.py

@@ -0,0 +1,124 @@
+"""Compute gammainc and gammaincc for large arguments and parameters
+and save the values to data files for use in tests. We can't just
+compare to mpmath's gammainc in test_mpmath.TestSystematic because it
+would take too long.
+
+Note that mpmath's gammainc is computed using hypercomb, but since it
+doesn't allow the user to increase the maximum number of terms used in
+the series it doesn't converge for many arguments. To get around this
+we copy the mpmath implementation but use more terms.
+
+This takes about 17 minutes to run on a 2.3 GHz Macbook Pro with 4GB
+ram.
+
+Sources:
+[1] Fredrik Johansson and others. mpmath: a Python library for
+    arbitrary-precision floating-point arithmetic (version 0.19),
+    December 2013. http://mpmath.org/.
+
+"""
+import os
+from time import time
+import numpy as np
+from numpy import pi
+
+from scipy.special._mptestutils import mpf2float
+
+try:
+    import mpmath as mp
+except ImportError:
+    pass
+
+
+def gammainc(a, x, dps=50, maxterms=10**8):
+    """Compute gammainc exactly like mpmath does but allow for more
+    summands in hypercomb. See
+
+    mpmath/functions/expintegrals.py#L134
+
+    in the mpmath github repository.
+
+    """
+    with mp.workdps(dps):
+        z, a, b = mp.mpf(a), mp.mpf(x), mp.mpf(x)
+        G = [z]
+        negb = mp.fneg(b, exact=True)
+
+        def h(z):
+            T1 = [mp.exp(negb), b, z], [1, z, -1], [], G, [1], [1+z], b
+            return (T1,)
+
+        res = mp.hypercomb(h, [z], maxterms=maxterms)
+        return mpf2float(res)
+
+
+def gammaincc(a, x, dps=50, maxterms=10**8):
+    """Compute gammaincc exactly like mpmath does but allow for more
+    terms in hypercomb. See
+
+    mpmath/functions/expintegrals.py#L187
+
+    in the mpmath github repository.
+
+    """
+    with mp.workdps(dps):
+        z, a = a, x
+
+        if mp.isint(z):
+            try:
+                # mpmath has a fast integer path
+                return mpf2float(mp.gammainc(z, a=a, regularized=True))
+            except mp.libmp.NoConvergence:
+                pass
+        nega = mp.fneg(a, exact=True)
+        G = [z]
+        # Use 2F0 series when possible; fall back to lower gamma representation
+        try:
+            def h(z):
+                r = z-1
+                return [([mp.exp(nega), a], [1, r], [], G, [1, -r], [], 1/nega)]
+            return mpf2float(mp.hypercomb(h, [z], force_series=True))
+        except mp.libmp.NoConvergence:
+            def h(z):
+                T1 = [], [1, z-1], [z], G, [], [], 0
+                T2 = [-mp.exp(nega), a, z], [1, z, -1], [], G, [1], [1+z], a
+                return T1, T2
+            return mpf2float(mp.hypercomb(h, [z], maxterms=maxterms))
+
+
+def main():
+    t0 = time()
+    # It would be nice to have data for larger values, but either this
+    # requires prohibitively large precision (dps > 800) or mpmath has
+    # a bug. For example, gammainc(1e20, 1e20, dps=800) returns a
+    # value around 0.03, while the true value should be close to 0.5
+    # (DLMF 8.12.15).
+    print(__doc__)
+    pwd = os.path.dirname(__file__)
+    r = np.logspace(4, 14, 30)
+    ltheta = np.logspace(np.log10(pi/4), np.log10(np.arctan(0.6)), 30)
+    utheta = np.logspace(np.log10(pi/4), np.log10(np.arctan(1.4)), 30)
+
+    regimes = [(gammainc, ltheta), (gammaincc, utheta)]
+    for func, theta in regimes:
+        rg, thetag = np.meshgrid(r, theta)
+        a, x = rg*np.cos(thetag), rg*np.sin(thetag)
+        a, x = a.flatten(), x.flatten()
+        dataset = []
+        for i, (a0, x0) in enumerate(zip(a, x)):
+            if func == gammaincc:
+                # Exploit the fast integer path in gammaincc whenever
+                # possible so that the computation doesn't take too
+                # long
+                a0, x0 = np.floor(a0), np.floor(x0)
+            dataset.append((a0, x0, func(a0, x0)))
+        dataset = np.array(dataset)
+        filename = os.path.join(pwd, '..', 'tests', 'data', 'local',
+                                f'{func.__name__}.txt')
+        np.savetxt(filename, dataset)
+
+    print(f"{(time() - t0)/60} minutes elapsed")
+
+
+if __name__ == "__main__":
+    main()

.venv/Lib/site-packages/scipy/special/_precompute/lambertw.py

@@ -0,0 +1,68 @@
+"""Compute a Pade approximation for the principal branch of the
+Lambert W function around 0 and compare it to various other
+approximations.
+
+"""
+import numpy as np
+
+try:
+    import mpmath
+    import matplotlib.pyplot as plt
+except ImportError:
+    pass
+
+
+def lambertw_pade():
+    derivs = [mpmath.diff(mpmath.lambertw, 0, n=n) for n in range(6)]
+    p, q = mpmath.pade(derivs, 3, 2)
+    return p, q
+
+
+def main():
+    print(__doc__)
+    with mpmath.workdps(50):
+        p, q = lambertw_pade()
+        p, q = p[::-1], q[::-1]
+        print(f"p = {p}")
+        print(f"q = {q}")
+
+    x, y = np.linspace(-1.5, 1.5, 75), np.linspace(-1.5, 1.5, 75)
+    x, y = np.meshgrid(x, y)
+    z = x + 1j*y
+    lambertw_std = []
+    for z0 in z.flatten():
+        lambertw_std.append(complex(mpmath.lambertw(z0)))
+    lambertw_std = np.array(lambertw_std).reshape(x.shape)
+
+    fig, axes = plt.subplots(nrows=3, ncols=1)
+    # Compare Pade approximation to true result
+    p = np.array([float(p0) for p0 in p])
+    q = np.array([float(q0) for q0 in q])
+    pade_approx = np.polyval(p, z)/np.polyval(q, z)
+    pade_err = abs(pade_approx - lambertw_std)
+    axes[0].pcolormesh(x, y, pade_err)
+    # Compare two terms of asymptotic series to true result
+    asy_approx = np.log(z) - np.log(np.log(z))
+    asy_err = abs(asy_approx - lambertw_std)
+    axes[1].pcolormesh(x, y, asy_err)
+    # Compare two terms of the series around the branch point to the
+    # true result
+    p = np.sqrt(2*(np.exp(1)*z + 1))
+    series_approx = -1 + p - p**2/3
+    series_err = abs(series_approx - lambertw_std)
+    im = axes[2].pcolormesh(x, y, series_err)
+
+    fig.colorbar(im, ax=axes.ravel().tolist())
+    plt.show()
+
+    fig, ax = plt.subplots(nrows=1, ncols=1)
+    pade_better = pade_err < asy_err
+    im = ax.pcolormesh(x, y, pade_better)
+    t = np.linspace(-0.3, 0.3)
+    ax.plot(-2.5*abs(t) - 0.2, t, 'r')
+    fig.colorbar(im, ax=ax)
+    plt.show()
+
+
+if __name__ == '__main__':
+    main()

.venv/Lib/site-packages/scipy/special/_precompute/loggamma.py

@@ -0,0 +1,43 @@
+"""Precompute series coefficients for log-Gamma."""
+
+try:
+    import mpmath
+except ImportError:
+    pass
+
+
+def stirling_series(N):
+    with mpmath.workdps(100):
+        coeffs = [mpmath.bernoulli(2*n)/(2*n*(2*n - 1))
+                  for n in range(1, N + 1)]
+    return coeffs
+
+
+def taylor_series_at_1(N):
+    coeffs = []
+    with mpmath.workdps(100):
+        coeffs.append(-mpmath.euler)
+        for n in range(2, N + 1):
+            coeffs.append((-1)**n*mpmath.zeta(n)/n)
+    return coeffs
+
+
+def main():
+    print(__doc__)
+    print()
+    stirling_coeffs = [mpmath.nstr(x, 20, min_fixed=0, max_fixed=0)
+                       for x in stirling_series(8)[::-1]]
+    taylor_coeffs = [mpmath.nstr(x, 20, min_fixed=0, max_fixed=0)
+                     for x in taylor_series_at_1(23)[::-1]]
+    print("Stirling series coefficients")
+    print("----------------------------")
+    print("\n".join(stirling_coeffs))
+    print()
+    print("Taylor series coefficients")
+    print("--------------------------")
+    print("\n".join(taylor_coeffs))
+    print()
+
+
+if __name__ == '__main__':
+    main()

.venv/Lib/site-packages/scipy/special/_precompute/struve_convergence.py

@@ -0,0 +1,131 @@
+"""
+Convergence regions of the expansions used in ``struve.c``
+
+Note that for v >> z both functions tend rapidly to 0,
+and for v << -z, they tend to infinity.
+
+The floating-point functions over/underflow in the lower left and right
+corners of the figure.
+
+
+Figure legend
+=============
+
+Red region
+    Power series is close (1e-12) to the mpmath result
+
+Blue region
+    Asymptotic series is close to the mpmath result
+
+Green region
+    Bessel series is close to the mpmath result
+
+Dotted colored lines
+    Boundaries of the regions
+
+Solid colored lines
+    Boundaries estimated by the routine itself. These will be used
+    for determining which of the results to use.
+
+Black dashed line
+    The line z = 0.7*|v| + 12
+
+"""
+import numpy as np
+import matplotlib.pyplot as plt
+
+import mpmath
+
+
+def err_metric(a, b, atol=1e-290):
+    m = abs(a - b) / (atol + abs(b))
+    m[np.isinf(b) & (a == b)] = 0
+    return m
+
+
+def do_plot(is_h=True):
+    from scipy.special._ufuncs import (_struve_power_series,
+                                       _struve_asymp_large_z,
+                                       _struve_bessel_series)
+
+    vs = np.linspace(-1000, 1000, 91)
+    zs = np.sort(np.r_[1e-5, 1.0, np.linspace(0, 700, 91)[1:]])
+
+    rp = _struve_power_series(vs[:,None], zs[None,:], is_h)
+    ra = _struve_asymp_large_z(vs[:,None], zs[None,:], is_h)
+    rb = _struve_bessel_series(vs[:,None], zs[None,:], is_h)
+
+    mpmath.mp.dps = 50
+    if is_h:
+        def sh(v, z):
+            return float(mpmath.struveh(mpmath.mpf(v), mpmath.mpf(z)))
+    else:
+        def sh(v, z):
+            return float(mpmath.struvel(mpmath.mpf(v), mpmath.mpf(z)))
+    ex = np.vectorize(sh, otypes='d')(vs[:,None], zs[None,:])
+
+    err_a = err_metric(ra[0], ex) + 1e-300
+    err_p = err_metric(rp[0], ex) + 1e-300
+    err_b = err_metric(rb[0], ex) + 1e-300
+
+    err_est_a = abs(ra[1]/ra[0])
+    err_est_p = abs(rp[1]/rp[0])
+    err_est_b = abs(rb[1]/rb[0])
+
+    z_cutoff = 0.7*abs(vs) + 12
+
+    levels = [-1000, -12]
+
+    plt.cla()
+
+    plt.hold(1)
+    plt.contourf(vs, zs, np.log10(err_p).T,
+                 levels=levels, colors=['r', 'r'], alpha=0.1)
+    plt.contourf(vs, zs, np.log10(err_a).T,
+                 levels=levels, colors=['b', 'b'], alpha=0.1)
+    plt.contourf(vs, zs, np.log10(err_b).T,
+                 levels=levels, colors=['g', 'g'], alpha=0.1)
+
+    plt.contour(vs, zs, np.log10(err_p).T,
+                levels=levels, colors=['r', 'r'], linestyles=[':', ':'])
+    plt.contour(vs, zs, np.log10(err_a).T,
+                levels=levels, colors=['b', 'b'], linestyles=[':', ':'])
+    plt.contour(vs, zs, np.log10(err_b).T,
+                levels=levels, colors=['g', 'g'], linestyles=[':', ':'])
+
+    lp = plt.contour(vs, zs, np.log10(err_est_p).T,
+                     levels=levels, colors=['r', 'r'], linestyles=['-', '-'])
+    la = plt.contour(vs, zs, np.log10(err_est_a).T,
+                     levels=levels, colors=['b', 'b'], linestyles=['-', '-'])
+    lb = plt.contour(vs, zs, np.log10(err_est_b).T,
+                     levels=levels, colors=['g', 'g'], linestyles=['-', '-'])
+
+    plt.clabel(lp, fmt={-1000: 'P', -12: 'P'})
+    plt.clabel(la, fmt={-1000: 'A', -12: 'A'})
+    plt.clabel(lb, fmt={-1000: 'B', -12: 'B'})
+
+    plt.plot(vs, z_cutoff, 'k--')
+
+    plt.xlim(vs.min(), vs.max())
+    plt.ylim(zs.min(), zs.max())
+
+    plt.xlabel('v')
+    plt.ylabel('z')
+
+
+def main():
+    plt.clf()
+    plt.subplot(121)
+    do_plot(True)
+    plt.title('Struve H')
+
+    plt.subplot(122)
+    do_plot(False)
+    plt.title('Struve L')
+
+    plt.savefig('struve_convergence.png')
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()

.venv/Lib/site-packages/scipy/special/_precompute/utils.py

@@ -0,0 +1,38 @@
+try:
+    import mpmath as mp
+except ImportError:
+    pass
+
+try:
+    from sympy.abc import x
+except ImportError:
+    pass
+
+
+def lagrange_inversion(a):
+    """Given a series
+
+    f(x) = a[1]*x + a[2]*x**2 + ... + a[n-1]*x**(n - 1),
+
+    use the Lagrange inversion formula to compute a series
+
+    g(x) = b[1]*x + b[2]*x**2 + ... + b[n-1]*x**(n - 1)
+
+    so that f(g(x)) = g(f(x)) = x mod x**n. We must have a[0] = 0, so
+    necessarily b[0] = 0 too.
+
+    The algorithm is naive and could be improved, but speed isn't an
+    issue here and it's easy to read.
+
+    """
+    n = len(a)
+    f = sum(a[i]*x**i for i in range(n))
+    h = (x/f).series(x, 0, n).removeO()
+    hpower = [h**0]
+    for k in range(n):
+        hpower.append((hpower[-1]*h).expand())
+    b = [mp.mpf(0)]
+    for k in range(1, n):
+        b.append(hpower[k].coeff(x, k - 1)/k)
+    b = [mp.mpf(x) for x in b]
+    return b

.venv/Lib/site-packages/scipy/special/_precompute/wright_bessel.py

@@ -0,0 +1,342 @@
+"""Precompute coefficients of several series expansions
+of Wright's generalized Bessel function Phi(a, b, x).
+
+See https://dlmf.nist.gov/10.46.E1 with rho=a, beta=b, z=x.
+"""
+from argparse import ArgumentParser, RawTextHelpFormatter
+import numpy as np
+from scipy.integrate import quad
+from scipy.optimize import minimize_scalar, curve_fit
+from time import time
+
+try:
+    import sympy
+    from sympy import EulerGamma, Rational, S, Sum, \
+        factorial, gamma, gammasimp, pi, polygamma, symbols, zeta
+    from sympy.polys.polyfuncs import horner
+except ImportError:
+    pass
+
+
+def series_small_a():
+    """Tylor series expansion of Phi(a, b, x) in a=0 up to order 5.
+    """
+    order = 5
+    a, b, x, k = symbols("a b x k")
+    A = []  # terms with a
+    X = []  # terms with x
+    B = []  # terms with b (polygammas)
+    # Phi(a, b, x) = exp(x)/gamma(b) * sum(A[i] * X[i] * B[i])
+    expression = Sum(x**k/factorial(k)/gamma(a*k+b), (k, 0, S.Infinity))
+    expression = gamma(b)/sympy.exp(x) * expression
+
+    # nth term of taylor series in a=0: a^n/n! * (d^n Phi(a, b, x)/da^n at a=0)
+    for n in range(0, order+1):
+        term = expression.diff(a, n).subs(a, 0).simplify().doit()
+        # set the whole bracket involving polygammas to 1
+        x_part = (term.subs(polygamma(0, b), 1)
+                  .replace(polygamma, lambda *args: 0))
+        # sign convention: x part always positive
+        x_part *= (-1)**n
+
+        A.append(a**n/factorial(n))
+        X.append(horner(x_part))
+        B.append(horner((term/x_part).simplify()))
+
+    s = "Tylor series expansion of Phi(a, b, x) in a=0 up to order 5.\n"
+    s += "Phi(a, b, x) = exp(x)/gamma(b) * sum(A[i] * X[i] * B[i], i=0..5)\n"
+    for name, c in zip(['A', 'X', 'B'], [A, X, B]):
+        for i in range(len(c)):
+            s += f"\n{name}[{i}] = " + str(c[i])
+    return s
+
+
+# expansion of digamma
+def dg_series(z, n):
+    """Symbolic expansion of digamma(z) in z=0 to order n.
+
+    See https://dlmf.nist.gov/5.7.E4 and with https://dlmf.nist.gov/5.5.E2
+    """
+    k = symbols("k")
+    return -1/z - EulerGamma + \
+        sympy.summation((-1)**k * zeta(k) * z**(k-1), (k, 2, n+1))
+
+
+def pg_series(k, z, n):
+    """Symbolic expansion of polygamma(k, z) in z=0 to order n."""
+    return sympy.diff(dg_series(z, n+k), z, k)
+
+
+def series_small_a_small_b():
+    """Tylor series expansion of Phi(a, b, x) in a=0 and b=0 up to order 5.
+
+    Be aware of cancellation of poles in b=0 of digamma(b)/Gamma(b) and
+    polygamma functions.
+
+    digamma(b)/Gamma(b) = -1 - 2*M_EG*b + O(b^2)
+    digamma(b)^2/Gamma(b) = 1/b + 3*M_EG + b*(-5/12*PI^2+7/2*M_EG^2) + O(b^2)
+    polygamma(1, b)/Gamma(b) = 1/b + M_EG + b*(1/12*PI^2 + 1/2*M_EG^2) + O(b^2)
+    and so on.
+    """
+    order = 5
+    a, b, x, k = symbols("a b x k")
+    M_PI, M_EG, M_Z3 = symbols("M_PI M_EG M_Z3")
+    c_subs = {pi: M_PI, EulerGamma: M_EG, zeta(3): M_Z3}
+    A = []  # terms with a
+    X = []  # terms with x
+    B = []  # terms with b (polygammas expanded)
+    C = []  # terms that generate B
+    # Phi(a, b, x) = exp(x) * sum(A[i] * X[i] * B[i])
+    # B[0] = 1
+    # B[k] = sum(C[k] * b**k/k!, k=0..)
+    # Note: C[k] can be obtained from a series expansion of 1/gamma(b).
+    expression = gamma(b)/sympy.exp(x) * \
+        Sum(x**k/factorial(k)/gamma(a*k+b), (k, 0, S.Infinity))
+
+    # nth term of taylor series in a=0: a^n/n! * (d^n Phi(a, b, x)/da^n at a=0)
+    for n in range(0, order+1):
+        term = expression.diff(a, n).subs(a, 0).simplify().doit()
+        # set the whole bracket involving polygammas to 1
+        x_part = (term.subs(polygamma(0, b), 1)
+                  .replace(polygamma, lambda *args: 0))
+        # sign convention: x part always positive
+        x_part *= (-1)**n
+        # expansion of polygamma part with 1/gamma(b)
+        pg_part = term/x_part/gamma(b)
+        if n >= 1:
+            # Note: highest term is digamma^n
+            pg_part = pg_part.replace(polygamma,
+                                      lambda k, x: pg_series(k, x, order+1+n))
+            pg_part = (pg_part.series(b, 0, n=order+1-n)
+                       .removeO()
+                       .subs(polygamma(2, 1), -2*zeta(3))
+                       .simplify()
+                       )
+
+        A.append(a**n/factorial(n))
+        X.append(horner(x_part))
+        B.append(pg_part)
+
+    # Calculate C and put in the k!
+    C = sympy.Poly(B[1].subs(c_subs), b).coeffs()
+    C.reverse()
+    for i in range(len(C)):
+        C[i] = (C[i] * factorial(i)).simplify()
+
+    s = "Tylor series expansion of Phi(a, b, x) in a=0 and b=0 up to order 5."
+    s += "\nPhi(a, b, x) = exp(x) * sum(A[i] * X[i] * B[i], i=0..5)\n"
+    s += "B[0] = 1\n"
+    s += "B[i] = sum(C[k+i-1] * b**k/k!, k=0..)\n"
+    s += "\nM_PI = pi"
+    s += "\nM_EG = EulerGamma"
+    s += "\nM_Z3 = zeta(3)"
+    for name, c in zip(['A', 'X'], [A, X]):
+        for i in range(len(c)):
+            s += f"\n{name}[{i}] = "
+            s += str(c[i])
+    # For C, do also compute the values numerically
+    for i in range(len(C)):
+        s += f"\n# C[{i}] = "
+        s += str(C[i])
+        s += f"\nC[{i}] = "
+        s += str(C[i].subs({M_EG: EulerGamma, M_PI: pi, M_Z3: zeta(3)})
+                 .evalf(17))
+
+    # Does B have the assumed structure?
+    s += "\n\nTest if B[i] does have the assumed structure."
+    s += "\nC[i] are derived from B[1] alone."
+    s += "\nTest B[2] == C[1] + b*C[2] + b^2/2*C[3] + b^3/6*C[4] + .."
+    test = sum([b**k/factorial(k) * C[k+1] for k in range(order-1)])
+    test = (test - B[2].subs(c_subs)).simplify()
+    s += f"\ntest successful = {test==S(0)}"
+    s += "\nTest B[3] == C[2] + b*C[3] + b^2/2*C[4] + .."
+    test = sum([b**k/factorial(k) * C[k+2] for k in range(order-2)])
+    test = (test - B[3].subs(c_subs)).simplify()
+    s += f"\ntest successful = {test==S(0)}"
+    return s
+
+
+def asymptotic_series():
+    """Asymptotic expansion for large x.
+
+    Phi(a, b, x) ~ Z^(1/2-b) * exp((1+a)/a * Z) * sum_k (-1)^k * C_k / Z^k
+    Z = (a*x)^(1/(1+a))
+
+    Wright (1935) lists the coefficients C_0 and C_1 (he calls them a_0 and
+    a_1). With slightly different notation, Paris (2017) lists coefficients
+    c_k up to order k=3.
+    Paris (2017) uses ZP = (1+a)/a * Z  (ZP = Z of Paris) and
+    C_k = C_0 * (-a/(1+a))^k * c_k
+    """
+    order = 8
+
+    class g(sympy.Function):
+        """Helper function g according to Wright (1935)
+
+        g(n, rho, v) = (1 + (rho+2)/3 * v + (rho+2)*(rho+3)/(2*3) * v^2 + ...)
+
+        Note: Wright (1935) uses square root of above definition.
+        """
+        nargs = 3
+
+        @classmethod
+        def eval(cls, n, rho, v):
+            if not n >= 0:
+                raise ValueError("must have n >= 0")
+            elif n == 0:
+                return 1
+            else:
+                return g(n-1, rho, v) \
+                    + gammasimp(gamma(rho+2+n)/gamma(rho+2)) \
+                    / gammasimp(gamma(3+n)/gamma(3))*v**n
+
+    class coef_C(sympy.Function):
+        """Calculate coefficients C_m for integer m.
+
+        C_m is the coefficient of v^(2*m) in the Taylor expansion in v=0 of
+        Gamma(m+1/2)/(2*pi) * (2/(rho+1))^(m+1/2) * (1-v)^(-b)
+            * g(rho, v)^(-m-1/2)
+        """
+        nargs = 3
+
+        @classmethod
+        def eval(cls, m, rho, beta):
+            if not m >= 0:
+                raise ValueError("must have m >= 0")
+
+            v = symbols("v")
+            expression = (1-v)**(-beta) * g(2*m, rho, v)**(-m-Rational(1, 2))
+            res = expression.diff(v, 2*m).subs(v, 0) / factorial(2*m)
+            res = res * (gamma(m + Rational(1, 2)) / (2*pi)
+                         * (2/(rho+1))**(m + Rational(1, 2)))
+            return res
+
+    # in order to have nice ordering/sorting of expressions, we set a = xa.
+    xa, b, xap1 = symbols("xa b xap1")
+    C0 = coef_C(0, xa, b)
+    # a1 = a(1, rho, beta)
+    s = "Asymptotic expansion for large x\n"
+    s += "Phi(a, b, x) = Z**(1/2-b) * exp((1+a)/a * Z) \n"
+    s += "               * sum((-1)**k * C[k]/Z**k, k=0..6)\n\n"
+    s += "Z      = pow(a * x, 1/(1+a))\n"
+    s += "A[k]   = pow(a, k)\n"
+    s += "B[k]   = pow(b, k)\n"
+    s += "Ap1[k] = pow(1+a, k)\n\n"
+    s += "C[0] = 1./sqrt(2. * M_PI * Ap1[1])\n"
+    for i in range(1, order+1):
+        expr = (coef_C(i, xa, b) / (C0/(1+xa)**i)).simplify()
+        factor = [x.denominator() for x in sympy.Poly(expr).coeffs()]
+        factor = sympy.lcm(factor)
+        expr = (expr * factor).simplify().collect(b, sympy.factor)
+        expr = expr.xreplace({xa+1: xap1})
+        s += f"C[{i}] = C[0] / ({factor} * Ap1[{i}])\n"
+        s += f"C[{i}] *= {str(expr)}\n\n"
+    import re
+    re_a = re.compile(r'xa\*\*(\d+)')
+    s = re_a.sub(r'A[\1]', s)
+    re_b = re.compile(r'b\*\*(\d+)')
+    s = re_b.sub(r'B[\1]', s)
+    s = s.replace('xap1', 'Ap1[1]')
+    s = s.replace('xa', 'a')
+    # max integer = 2^31-1 = 2,147,483,647. Solution: Put a point after 10
+    # or more digits.
+    re_digits = re.compile(r'(\d{10,})')
+    s = re_digits.sub(r'\1.', s)
+    return s
+
+
+def optimal_epsilon_integral():
+    """Fit optimal choice of epsilon for integral representation.
+
+    The integrand of
+        int_0^pi P(eps, a, b, x, phi) * dphi
+    can exhibit oscillatory behaviour. It stems from the cosine of P and can be
+    minimized by minimizing the arc length of the argument
+        f(phi) = eps * sin(phi) - x * eps^(-a) * sin(a * phi) + (1 - b) * phi
+    of cos(f(phi)).
+    We minimize the arc length in eps for a grid of values (a, b, x) and fit a
+    parametric function to it.
+    """
+    def fp(eps, a, b, x, phi):
+        """Derivative of f w.r.t. phi."""
+        eps_a = np.power(1. * eps, -a)
+        return eps * np.cos(phi) - a * x * eps_a * np.cos(a * phi) + 1 - b
+
+    def arclength(eps, a, b, x, epsrel=1e-2, limit=100):
+        """Compute Arc length of f.
+
+        Note that the arc length of a function f from t0 to t1 is given by
+            int_t0^t1 sqrt(1 + f'(t)^2) dt
+        """
+        return quad(lambda phi: np.sqrt(1 + fp(eps, a, b, x, phi)**2),
+                    0, np.pi,
+                    epsrel=epsrel, limit=100)[0]
+
+    # grid of minimal arc length values
+    data_a = [1e-3, 0.1, 0.5, 0.9, 1, 2, 4, 5, 6, 8]
+    data_b = [0, 1, 4, 7, 10]
+    data_x = [1, 1.5, 2, 4, 10, 20, 50, 100, 200, 500, 1e3, 5e3, 1e4]
+    data_a, data_b, data_x = np.meshgrid(data_a, data_b, data_x)
+    data_a, data_b, data_x = (data_a.flatten(), data_b.flatten(),
+                              data_x.flatten())
+    best_eps = []
+    for i in range(data_x.size):
+        best_eps.append(
+            minimize_scalar(lambda eps: arclength(eps, data_a[i], data_b[i],
+                                                  data_x[i]),
+                            bounds=(1e-3, 1000),
+                            method='Bounded', options={'xatol': 1e-3}).x
+        )
+    best_eps = np.array(best_eps)
+    # pandas would be nice, but here a dictionary is enough
+    df = {'a': data_a,
+          'b': data_b,
+          'x': data_x,
+          'eps': best_eps,
+          }
+
+    def func(data, A0, A1, A2, A3, A4, A5):
+        """Compute parametric function to fit."""
+        a = data['a']
+        b = data['b']
+        x = data['x']
+        return (A0 * b * np.exp(-0.5 * a)
+                + np.exp(A1 + 1 / (1 + a) * np.log(x) - A2 * np.exp(-A3 * a)
+                         + A4 / (1 + np.exp(A5 * a))))
+
+    func_params = list(curve_fit(func, df, df['eps'], method='trf')[0])
+
+    s = "Fit optimal eps for integrand P via minimal arc length\n"
+    s += "with parametric function:\n"
+    s += "optimal_eps = (A0 * b * exp(-a/2) + exp(A1 + 1 / (1 + a) * log(x)\n"
+    s += "              - A2 * exp(-A3 * a) + A4 / (1 + exp(A5 * a)))\n\n"
+    s += "Fitted parameters A0 to A5 are:\n"
+    s += ', '.join([f'{x:.5g}' for x in func_params])
+    return s
+
+
+def main():
+    t0 = time()
+    parser = ArgumentParser(description=__doc__,
+                            formatter_class=RawTextHelpFormatter)
+    parser.add_argument('action', type=int, choices=[1, 2, 3, 4],
+                        help='chose what expansion to precompute\n'
+                             '1 : Series for small a\n'
+                             '2 : Series for small a and small b\n'
+                             '3 : Asymptotic series for large x\n'
+                             '    This may take some time (>4h).\n'
+                             '4 : Fit optimal eps for integral representation.'
+                        )
+    args = parser.parse_args()
+
+    switch = {1: lambda: print(series_small_a()),
+              2: lambda: print(series_small_a_small_b()),
+              3: lambda: print(asymptotic_series()),
+              4: lambda: print(optimal_epsilon_integral())
+              }
+    switch.get(args.action, lambda: print("Invalid input."))()
+    print(f"\n{(time() - t0)/60:.1f} minutes elapsed.\n")
+
+
+if __name__ == '__main__':
+    main()

.venv/Lib/site-packages/scipy/special/_precompute/wright_bessel_data.py

@@ -0,0 +1,152 @@
+"""Compute a grid of values for Wright's generalized Bessel function
+and save the values to data files for use in tests. Using mpmath directly in
+tests would take too long.
+
+This takes about 10 minutes to run on a 2.7 GHz i7 Macbook Pro.
+"""
+from functools import lru_cache
+import os
+from time import time
+
+import numpy as np
+from scipy.special._mptestutils import mpf2float
+
+try:
+    import mpmath as mp
+except ImportError:
+    pass
+
+# exp_inf: smallest value x for which exp(x) == inf
+exp_inf = 709.78271289338403
+
+
+# 64 Byte per value
+@lru_cache(maxsize=100_000)
+def rgamma_cached(x, dps):
+    with mp.workdps(dps):
+        return mp.rgamma(x)
+
+
+def mp_wright_bessel(a, b, x, dps=50, maxterms=2000):
+    """Compute Wright's generalized Bessel function as Series with mpmath.
+    """
+    with mp.workdps(dps):
+        a, b, x = mp.mpf(a), mp.mpf(b), mp.mpf(x)
+        res = mp.nsum(lambda k: x**k / mp.fac(k)
+                      * rgamma_cached(a * k + b, dps=dps),
+                      [0, mp.inf],
+                      tol=dps, method='s', steps=[maxterms]
+                      )
+        return mpf2float(res)
+
+
+def main():
+    t0 = time()
+    print(__doc__)
+    pwd = os.path.dirname(__file__)
+    eps = np.finfo(float).eps * 100
+
+    a_range = np.array([eps,
+                        1e-4 * (1 - eps), 1e-4, 1e-4 * (1 + eps),
+                        1e-3 * (1 - eps), 1e-3, 1e-3 * (1 + eps),
+                        0.1, 0.5,
+                        1 * (1 - eps), 1, 1 * (1 + eps),
+                        1.5, 2, 4.999, 5, 10])
+    b_range = np.array([0, eps, 1e-10, 1e-5, 0.1, 1, 2, 10, 20, 100])
+    x_range = np.array([0, eps, 1 - eps, 1, 1 + eps,
+                        1.5,
+                        2 - eps, 2, 2 + eps,
+                        9 - eps, 9, 9 + eps,
+                        10 * (1 - eps), 10, 10 * (1 + eps),
+                        100 * (1 - eps), 100, 100 * (1 + eps),
+                        500, exp_inf, 1e3, 1e5, 1e10, 1e20])
+
+    a_range, b_range, x_range = np.meshgrid(a_range, b_range, x_range,
+                                            indexing='ij')
+    a_range = a_range.flatten()
+    b_range = b_range.flatten()
+    x_range = x_range.flatten()
+
+    # filter out some values, especially too large x
+    bool_filter = ~((a_range < 5e-3) & (x_range >= exp_inf))
+    bool_filter = bool_filter & ~((a_range < 0.2) & (x_range > exp_inf))
+    bool_filter = bool_filter & ~((a_range < 0.5) & (x_range > 1e3))
+    bool_filter = bool_filter & ~((a_range < 0.56) & (x_range > 5e3))
+    bool_filter = bool_filter & ~((a_range < 1) & (x_range > 1e4))
+    bool_filter = bool_filter & ~((a_range < 1.4) & (x_range > 1e5))
+    bool_filter = bool_filter & ~((a_range < 1.8) & (x_range > 1e6))
+    bool_filter = bool_filter & ~((a_range < 2.2) & (x_range > 1e7))
+    bool_filter = bool_filter & ~((a_range < 2.5) & (x_range > 1e8))
+    bool_filter = bool_filter & ~((a_range < 2.9) & (x_range > 1e9))
+    bool_filter = bool_filter & ~((a_range < 3.3) & (x_range > 1e10))
+    bool_filter = bool_filter & ~((a_range < 3.7) & (x_range > 1e11))
+    bool_filter = bool_filter & ~((a_range < 4) & (x_range > 1e12))
+    bool_filter = bool_filter & ~((a_range < 4.4) & (x_range > 1e13))
+    bool_filter = bool_filter & ~((a_range < 4.7) & (x_range > 1e14))
+    bool_filter = bool_filter & ~((a_range < 5.1) & (x_range > 1e15))
+    bool_filter = bool_filter & ~((a_range < 5.4) & (x_range > 1e16))
+    bool_filter = bool_filter & ~((a_range < 5.8) & (x_range > 1e17))
+    bool_filter = bool_filter & ~((a_range < 6.2) & (x_range > 1e18))
+    bool_filter = bool_filter & ~((a_range < 6.2) & (x_range > 1e18))
+    bool_filter = bool_filter & ~((a_range < 6.5) & (x_range > 1e19))
+    bool_filter = bool_filter & ~((a_range < 6.9) & (x_range > 1e20))
+
+    # filter out known values that do not meet the required numerical accuracy
+    # see test test_wright_data_grid_failures
+    failing = np.array([
+        [0.1, 100, 709.7827128933841],
+        [0.5, 10, 709.7827128933841],
+        [0.5, 10, 1000],
+        [0.5, 100, 1000],
+        [1, 20, 100000],
+        [1, 100, 100000],
+        [1.0000000000000222, 20, 100000],
+        [1.0000000000000222, 100, 100000],
+        [1.5, 0, 500],
+        [1.5, 2.220446049250313e-14, 500],
+        [1.5, 1.e-10, 500],
+        [1.5, 1.e-05, 500],
+        [1.5, 0.1, 500],
+        [1.5, 20, 100000],
+        [1.5, 100, 100000],
+        ]).tolist()
+
+    does_fail = np.full_like(a_range, False, dtype=bool)
+    for i in range(x_range.size):
+        if [a_range[i], b_range[i], x_range[i]] in failing:
+            does_fail[i] = True
+
+    # filter and flatten
+    a_range = a_range[bool_filter]
+    b_range = b_range[bool_filter]
+    x_range = x_range[bool_filter]
+    does_fail = does_fail[bool_filter]
+
+    dataset = []
+    print(f"Computing {x_range.size} single points.")
+    print("Tests will fail for the following data points:")
+    for i in range(x_range.size):
+        a = a_range[i]
+        b = b_range[i]
+        x = x_range[i]
+        # take care of difficult corner cases
+        maxterms = 1000
+        if a < 1e-6 and x >= exp_inf/10:
+            maxterms = 2000
+        f = mp_wright_bessel(a, b, x, maxterms=maxterms)
+        if does_fail[i]:
+            print("failing data point a, b, x, value = "
+                  f"[{a}, {b}, {x}, {f}]")
+        else:
+            dataset.append((a, b, x, f))
+    dataset = np.array(dataset)
+
+    filename = os.path.join(pwd, '..', 'tests', 'data', 'local',
+                            'wright_bessel.txt')
+    np.savetxt(filename, dataset)
+
+    print(f"{(time() - t0)/60:.1f} minutes elapsed")
+
+
+if __name__ == "__main__":
+    main()

.venv/Lib/site-packages/scipy/special/_precompute/wrightomega.py

@@ -0,0 +1,41 @@
+import numpy as np
+
+try:
+    import mpmath
+except ImportError:
+    pass
+
+
+def mpmath_wrightomega(x):
+    return mpmath.lambertw(mpmath.exp(x), mpmath.mpf('-0.5'))
+
+
+def wrightomega_series_error(x):
+    series = x
+    desired = mpmath_wrightomega(x)
+    return abs(series - desired) / desired
+
+
+def wrightomega_exp_error(x):
+    exponential_approx = mpmath.exp(x)
+    desired = mpmath_wrightomega(x)
+    return abs(exponential_approx - desired) / desired
+
+
+def main():
+    desired_error = 2 * np.finfo(float).eps
+    print('Series Error')
+    for x in [1e5, 1e10, 1e15, 1e20]:
+        with mpmath.workdps(100):
+            error = wrightomega_series_error(x)
+        print(x, error, error < desired_error)
+
+    print('Exp error')
+    for x in [-10, -25, -50, -100, -200, -400, -700, -740]:
+        with mpmath.workdps(100):
+            error = wrightomega_exp_error(x)
+        print(x, error, error < desired_error)
+
+
+if __name__ == '__main__':
+    main()

.venv/Lib/site-packages/scipy/special/_precompute/zetac.py

@@ -0,0 +1,27 @@
+"""Compute the Taylor series for zeta(x) - 1 around x = 0."""
+try:
+    import mpmath
+except ImportError:
+    pass
+
+
+def zetac_series(N):
+    coeffs = []
+    with mpmath.workdps(100):
+        coeffs.append(-1.5)
+        for n in range(1, N):
+            coeff = mpmath.diff(mpmath.zeta, 0, n)/mpmath.factorial(n)
+            coeffs.append(coeff)
+    return coeffs
+
+
+def main():
+    print(__doc__)
+    coeffs = zetac_series(10)
+    coeffs = [mpmath.nstr(x, 20, min_fixed=0, max_fixed=0)
+              for x in coeffs]
+    print("\n".join(coeffs[::-1]))
+
+
+if __name__ == '__main__':
+    main()

.venv/Lib/site-packages/scipy/special/_ufuncs_cxx.pyx

@@ -0,0 +1,181 @@
+# This file is automatically generated by _generate_pyx.py.
+# Do not edit manually!
+
+from libc.math cimport NAN
+
+include "_ufuncs_extra_code_common.pxi"
+
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double complex _func_ccospi "ccospi"(double complex) noexcept nogil
+cdef void *_export_ccospi = <void*>_func_ccospi
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double complex _func_lambertw_scalar "lambertw_scalar"(double complex, long, double) noexcept nogil
+cdef void *_export_lambertw_scalar = <void*>_func_lambertw_scalar
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double complex _func_csinpi "csinpi"(double complex) noexcept nogil
+cdef void *_export_csinpi = <void*>_func_csinpi
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double _func__stirling2_inexact "_stirling2_inexact"(double, double) noexcept nogil
+cdef void *_export__stirling2_inexact = <void*>_func__stirling2_inexact
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef float _func_ibeta_float "ibeta_float"(float, float, float) noexcept nogil
+cdef void *_export_ibeta_float = <void*>_func_ibeta_float
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double _func_ibeta_double "ibeta_double"(double, double, double) noexcept nogil
+cdef void *_export_ibeta_double = <void*>_func_ibeta_double
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef float _func_ibetac_float "ibetac_float"(float, float, float) noexcept nogil
+cdef void *_export_ibetac_float = <void*>_func_ibetac_float
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double _func_ibetac_double "ibetac_double"(double, double, double) noexcept nogil
+cdef void *_export_ibetac_double = <void*>_func_ibetac_double
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef float _func_ibetac_inv_float "ibetac_inv_float"(float, float, float) noexcept nogil
+cdef void *_export_ibetac_inv_float = <void*>_func_ibetac_inv_float
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double _func_ibetac_inv_double "ibetac_inv_double"(double, double, double) noexcept nogil
+cdef void *_export_ibetac_inv_double = <void*>_func_ibetac_inv_double
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef float _func_ibeta_inv_float "ibeta_inv_float"(float, float, float) noexcept nogil
+cdef void *_export_ibeta_inv_float = <void*>_func_ibeta_inv_float
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double _func_ibeta_inv_double "ibeta_inv_double"(double, double, double) noexcept nogil
+cdef void *_export_ibeta_inv_double = <void*>_func_ibeta_inv_double
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double _func_binom "binom"(double, double) noexcept nogil
+cdef void *_export_binom = <void*>_func_binom
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double _func_faddeeva_dawsn "faddeeva_dawsn"(double) noexcept nogil
+cdef void *_export_faddeeva_dawsn = <void*>_func_faddeeva_dawsn
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double complex _func_faddeeva_dawsn_complex "faddeeva_dawsn_complex"(double complex) noexcept nogil
+cdef void *_export_faddeeva_dawsn_complex = <void*>_func_faddeeva_dawsn_complex
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double _func_fellint_RC "fellint_RC"(double, double) noexcept nogil
+cdef void *_export_fellint_RC = <void*>_func_fellint_RC
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double complex _func_cellint_RC "cellint_RC"(double complex, double complex) noexcept nogil
+cdef void *_export_cellint_RC = <void*>_func_cellint_RC
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double _func_fellint_RD "fellint_RD"(double, double, double) noexcept nogil
+cdef void *_export_fellint_RD = <void*>_func_fellint_RD
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double complex _func_cellint_RD "cellint_RD"(double complex, double complex, double complex) noexcept nogil
+cdef void *_export_cellint_RD = <void*>_func_cellint_RD
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double _func_fellint_RF "fellint_RF"(double, double, double) noexcept nogil
+cdef void *_export_fellint_RF = <void*>_func_fellint_RF
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double complex _func_cellint_RF "cellint_RF"(double complex, double complex, double complex) noexcept nogil
+cdef void *_export_cellint_RF = <void*>_func_cellint_RF
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double _func_fellint_RG "fellint_RG"(double, double, double) noexcept nogil
+cdef void *_export_fellint_RG = <void*>_func_fellint_RG
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double complex _func_cellint_RG "cellint_RG"(double complex, double complex, double complex) noexcept nogil
+cdef void *_export_cellint_RG = <void*>_func_cellint_RG
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double _func_fellint_RJ "fellint_RJ"(double, double, double, double) noexcept nogil
+cdef void *_export_fellint_RJ = <void*>_func_fellint_RJ
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double complex _func_cellint_RJ "cellint_RJ"(double complex, double complex, double complex, double complex) noexcept nogil
+cdef void *_export_cellint_RJ = <void*>_func_cellint_RJ
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double complex _func_faddeeva_erf "faddeeva_erf"(double complex) noexcept nogil
+cdef void *_export_faddeeva_erf = <void*>_func_faddeeva_erf
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double complex _func_faddeeva_erfc_complex "faddeeva_erfc_complex"(double complex) noexcept nogil
+cdef void *_export_faddeeva_erfc_complex = <void*>_func_faddeeva_erfc_complex
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double _func_faddeeva_erfcx "faddeeva_erfcx"(double) noexcept nogil
+cdef void *_export_faddeeva_erfcx = <void*>_func_faddeeva_erfcx
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double complex _func_faddeeva_erfcx_complex "faddeeva_erfcx_complex"(double complex) noexcept nogil
+cdef void *_export_faddeeva_erfcx_complex = <void*>_func_faddeeva_erfcx_complex
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double _func_faddeeva_erfi "faddeeva_erfi"(double) noexcept nogil
+cdef void *_export_faddeeva_erfi = <void*>_func_faddeeva_erfi
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double complex _func_faddeeva_erfi_complex "faddeeva_erfi_complex"(double complex) noexcept nogil
+cdef void *_export_faddeeva_erfi_complex = <void*>_func_faddeeva_erfi_complex
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef float _func_erfinv_float "erfinv_float"(float) noexcept nogil
+cdef void *_export_erfinv_float = <void*>_func_erfinv_float
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double _func_erfinv_double "erfinv_double"(double) noexcept nogil
+cdef void *_export_erfinv_double = <void*>_func_erfinv_double
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double _func_expit "expit"(double) noexcept nogil
+cdef void *_export_expit = <void*>_func_expit
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef float _func_expitf "expitf"(float) noexcept nogil
+cdef void *_export_expitf = <void*>_func_expitf
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef long double _func_expitl "expitl"(long double) noexcept nogil
+cdef void *_export_expitl = <void*>_func_expitl
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double complex _func_cgamma "cgamma"(double complex) noexcept nogil
+cdef void *_export_cgamma = <void*>_func_cgamma
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double _func_hyp1f1_double "hyp1f1_double"(double, double, double) noexcept nogil
+cdef void *_export_hyp1f1_double = <void*>_func_hyp1f1_double
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double _func_log_expit "log_expit"(double) noexcept nogil
+cdef void *_export_log_expit = <void*>_func_log_expit
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef float _func_log_expitf "log_expitf"(float) noexcept nogil
+cdef void *_export_log_expitf = <void*>_func_log_expitf
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef long double _func_log_expitl "log_expitl"(long double) noexcept nogil
+cdef void *_export_log_expitl = <void*>_func_log_expitl
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double _func_faddeeva_log_ndtr "faddeeva_log_ndtr"(double) noexcept nogil
+cdef void *_export_faddeeva_log_ndtr = <void*>_func_faddeeva_log_ndtr
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double complex _func_faddeeva_log_ndtr_complex "faddeeva_log_ndtr_complex"(double complex) noexcept nogil
+cdef void *_export_faddeeva_log_ndtr_complex = <void*>_func_faddeeva_log_ndtr_complex
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double _func_loggamma_real "loggamma_real"(double) noexcept nogil
+cdef void *_export_loggamma_real = <void*>_func_loggamma_real
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double complex _func_loggamma "loggamma"(double complex) noexcept nogil
+cdef void *_export_loggamma = <void*>_func_loggamma
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double _func_logit "logit"(double) noexcept nogil
+cdef void *_export_logit = <void*>_func_logit
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef float _func_logitf "logitf"(float) noexcept nogil
+cdef void *_export_logitf = <void*>_func_logitf
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef long double _func_logitl "logitl"(long double) noexcept nogil
+cdef void *_export_logitl = <void*>_func_logitl
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double complex _func_faddeeva_ndtr "faddeeva_ndtr"(double complex) noexcept nogil
+cdef void *_export_faddeeva_ndtr = <void*>_func_faddeeva_ndtr
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef float _func_powm1_float "powm1_float"(float, float) noexcept nogil
+cdef void *_export_powm1_float = <void*>_func_powm1_float
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double _func_powm1_double "powm1_double"(double, double) noexcept nogil
+cdef void *_export_powm1_double = <void*>_func_powm1_double
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double complex _func_cdigamma "cdigamma"(double complex) noexcept nogil
+cdef void *_export_cdigamma = <void*>_func_cdigamma
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double _func_digamma "digamma"(double) noexcept nogil
+cdef void *_export_digamma = <void*>_func_digamma
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double complex _func_crgamma "crgamma"(double complex) noexcept nogil
+cdef void *_export_crgamma = <void*>_func_crgamma
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double _func_faddeeva_voigt_profile "faddeeva_voigt_profile"(double, double, double) noexcept nogil
+cdef void *_export_faddeeva_voigt_profile = <void*>_func_faddeeva_voigt_profile
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double complex _func_faddeeva_w "faddeeva_w"(double complex) noexcept nogil
+cdef void *_export_faddeeva_w = <void*>_func_faddeeva_w
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double complex _func_wrightomega "wrightomega"(double complex) noexcept nogil
+cdef void *_export_wrightomega = <void*>_func_wrightomega
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double _func_wrightomega_real "wrightomega_real"(double) noexcept nogil
+cdef void *_export_wrightomega_real = <void*>_func_wrightomega_real

.venv/Lib/site-packages/scipy/special/_ufuncs_cxx_defs.h

@@ -0,0 +1,68 @@
+#ifndef UFUNCS_PROTO_H
+#define UFUNCS_PROTO_H 1
+#include "_special.h"
+npy_cdouble ccospi(npy_cdouble);
+npy_cdouble lambertw_scalar(npy_cdouble, npy_long, npy_double);
+npy_cdouble csinpi(npy_cdouble);
+#include "stirling2.h"
+npy_double _stirling2_inexact(npy_double, npy_double);
+#include "boost_special_functions.h"
+npy_float ibeta_float(npy_float, npy_float, npy_float);
+npy_double ibeta_double(npy_double, npy_double, npy_double);
+npy_float ibetac_float(npy_float, npy_float, npy_float);
+npy_double ibetac_double(npy_double, npy_double, npy_double);
+npy_float ibetac_inv_float(npy_float, npy_float, npy_float);
+npy_double ibetac_inv_double(npy_double, npy_double, npy_double);
+npy_float ibeta_inv_float(npy_float, npy_float, npy_float);
+npy_double ibeta_inv_double(npy_double, npy_double, npy_double);
+npy_double binom(npy_double, npy_double);
+#include "_faddeeva.h"
+npy_double faddeeva_dawsn(npy_double);
+npy_cdouble faddeeva_dawsn_complex(npy_cdouble);
+#include "ellint_carlson_wrap.hh"
+npy_double fellint_RC(npy_double, npy_double);
+npy_cdouble cellint_RC(npy_cdouble, npy_cdouble);
+npy_double fellint_RD(npy_double, npy_double, npy_double);
+npy_cdouble cellint_RD(npy_cdouble, npy_cdouble, npy_cdouble);
+npy_double fellint_RF(npy_double, npy_double, npy_double);
+npy_cdouble cellint_RF(npy_cdouble, npy_cdouble, npy_cdouble);
+npy_double fellint_RG(npy_double, npy_double, npy_double);
+npy_cdouble cellint_RG(npy_cdouble, npy_cdouble, npy_cdouble);
+npy_double fellint_RJ(npy_double, npy_double, npy_double, npy_double);
+npy_cdouble cellint_RJ(npy_cdouble, npy_cdouble, npy_cdouble, npy_cdouble);
+npy_cdouble faddeeva_erf(npy_cdouble);
+npy_cdouble faddeeva_erfc_complex(npy_cdouble);
+npy_double faddeeva_erfcx(npy_double);
+npy_cdouble faddeeva_erfcx_complex(npy_cdouble);
+npy_double faddeeva_erfi(npy_double);
+npy_cdouble faddeeva_erfi_complex(npy_cdouble);
+npy_float erfinv_float(npy_float);
+npy_double erfinv_double(npy_double);
+#include "_logit.h"
+npy_double expit(npy_double);
+npy_float expitf(npy_float);
+npy_longdouble expitl(npy_longdouble);
+npy_cdouble cgamma(npy_cdouble);
+npy_double hyp1f1_double(npy_double, npy_double, npy_double);
+npy_double log_expit(npy_double);
+npy_float log_expitf(npy_float);
+npy_longdouble log_expitl(npy_longdouble);
+npy_double faddeeva_log_ndtr(npy_double);
+npy_cdouble faddeeva_log_ndtr_complex(npy_cdouble);
+npy_double loggamma_real(npy_double);
+npy_cdouble loggamma(npy_cdouble);
+npy_double logit(npy_double);
+npy_float logitf(npy_float);
+npy_longdouble logitl(npy_longdouble);
+npy_cdouble faddeeva_ndtr(npy_cdouble);
+npy_float powm1_float(npy_float, npy_float);
+npy_double powm1_double(npy_double, npy_double);
+npy_cdouble cdigamma(npy_cdouble);
+npy_double digamma(npy_double);
+npy_cdouble crgamma(npy_cdouble);
+npy_double faddeeva_voigt_profile(npy_double, npy_double, npy_double);
+npy_cdouble faddeeva_w(npy_cdouble);
+#include "_wright.h"
+npy_cdouble wrightomega(npy_cdouble);
+npy_double wrightomega_real(npy_double);
+#endif

.venv/Lib/site-packages/scipy/special/_ufuncs_defs.h

@@ -0,0 +1,185 @@
+#ifndef UFUNCS_PROTO_H
+#define UFUNCS_PROTO_H 1
+#include "_cosine.h"
+npy_double cosine_cdf(npy_double);
+npy_double cosine_invcdf(npy_double);
+#include "cephes.h"
+npy_double cospi(npy_double);
+npy_double igam_fac(npy_double, npy_double);
+npy_double kolmogc(npy_double);
+npy_double kolmogci(npy_double);
+npy_double kolmogp(npy_double);
+npy_double lanczos_sum_expg_scaled(npy_double);
+npy_double lgam1p(npy_double);
+npy_double log1pmx(npy_double);
+npy_double riemann_zeta(npy_double);
+#include "scaled_exp1.h"
+npy_double scaled_exp1(npy_double);
+npy_double sinpi(npy_double);
+npy_double smirnovc(npy_int, npy_double);
+npy_double smirnovci(npy_int, npy_double);
+npy_double smirnovp(npy_int, npy_double);
+npy_double struve_asymp_large_z(npy_double, npy_double, npy_int, npy_double *);
+npy_double struve_bessel_series(npy_double, npy_double, npy_int, npy_double *);
+npy_double struve_power_series(npy_double, npy_double, npy_int, npy_double *);
+npy_double zeta(npy_double, npy_double);
+#include "amos_wrappers.h"
+npy_int airy_wrap(npy_double, npy_double *, npy_double *, npy_double *, npy_double *);
+npy_int cairy_wrap(npy_cdouble, npy_cdouble *, npy_cdouble *, npy_cdouble *, npy_cdouble *);
+npy_int cairy_wrap_e(npy_cdouble, npy_cdouble *, npy_cdouble *, npy_cdouble *, npy_cdouble *);
+npy_int cairy_wrap_e_real(npy_double, npy_double *, npy_double *, npy_double *, npy_double *);
+npy_double bdtr(npy_double, npy_int, npy_double);
+npy_double bdtrc(npy_double, npy_int, npy_double);
+npy_double bdtri(npy_double, npy_int, npy_double);
+#include "specfun_wrappers.h"
+npy_double bei_wrap(npy_double);
+npy_double beip_wrap(npy_double);
+npy_double ber_wrap(npy_double);
+npy_double berp_wrap(npy_double);
+npy_double besselpoly(npy_double, npy_double, npy_double);
+npy_double beta(npy_double, npy_double);
+npy_double lbeta(npy_double, npy_double);
+npy_double btdtr(npy_double, npy_double, npy_double);
+npy_double incbi(npy_double, npy_double, npy_double);
+npy_double cbrt(npy_double);
+npy_double chdtr(npy_double, npy_double);
+npy_double chdtrc(npy_double, npy_double);
+npy_double chdtri(npy_double, npy_double);
+npy_double cosdg(npy_double);
+npy_double cosm1(npy_double);
+npy_double cotdg(npy_double);
+npy_double ellpe(npy_double);
+npy_double ellie(npy_double, npy_double);
+npy_int ellpj(npy_double, npy_double, npy_double *, npy_double *, npy_double *, npy_double *);
+npy_double ellik(npy_double, npy_double);
+npy_double ellpk(npy_double);
+npy_double erf(npy_double);
+npy_double erfc(npy_double);
+npy_double erfcinv(npy_double);
+npy_cdouble cexp1_wrap(npy_cdouble);
+npy_double exp1_wrap(npy_double);
+npy_double exp10(npy_double);
+npy_double exp2(npy_double);
+npy_cdouble cexpi_wrap(npy_cdouble);
+npy_double expi_wrap(npy_double);
+npy_double expm1(npy_double);
+npy_double expn(npy_int, npy_double);
+npy_double fdtr(npy_double, npy_double, npy_double);
+npy_double fdtrc(npy_double, npy_double, npy_double);
+npy_double fdtri(npy_double, npy_double, npy_double);
+npy_int fresnl(npy_double, npy_double *, npy_double *);
+npy_int cfresnl_wrap(npy_cdouble, npy_cdouble *, npy_cdouble *);
+npy_double Gamma(npy_double);
+npy_double igam(npy_double, npy_double);
+npy_double igamc(npy_double, npy_double);
+npy_double igamci(npy_double, npy_double);
+npy_double igami(npy_double, npy_double);
+npy_double lgam(npy_double);
+npy_double gammasgn(npy_double);
+npy_double gdtr(npy_double, npy_double, npy_double);
+npy_double gdtrc(npy_double, npy_double, npy_double);
+npy_cdouble cbesh_wrap1(npy_double, npy_cdouble);
+npy_cdouble cbesh_wrap1_e(npy_double, npy_cdouble);
+npy_cdouble cbesh_wrap2(npy_double, npy_cdouble);
+npy_cdouble cbesh_wrap2_e(npy_double, npy_cdouble);
+npy_cdouble chyp1f1_wrap(npy_double, npy_double, npy_cdouble);
+npy_double hyp2f1(npy_double, npy_double, npy_double, npy_double);
+npy_double i0(npy_double);
+npy_double i0e(npy_double);
+npy_double i1(npy_double);
+npy_double i1e(npy_double);
+npy_int it2i0k0_wrap(npy_double, npy_double *, npy_double *);
+npy_int it2j0y0_wrap(npy_double, npy_double *, npy_double *);
+npy_double it2struve0_wrap(npy_double);
+npy_int itairy_wrap(npy_double, npy_double *, npy_double *, npy_double *, npy_double *);
+npy_int it1i0k0_wrap(npy_double, npy_double *, npy_double *);
+npy_int it1j0y0_wrap(npy_double, npy_double *, npy_double *);
+npy_double itmodstruve0_wrap(npy_double);
+npy_double itstruve0_wrap(npy_double);
+npy_cdouble cbesi_wrap(npy_double, npy_cdouble);
+npy_double iv(npy_double, npy_double);
+npy_cdouble cbesi_wrap_e(npy_double, npy_cdouble);
+npy_double cbesi_wrap_e_real(npy_double, npy_double);
+npy_double j0(npy_double);
+npy_double j1(npy_double);
+npy_cdouble cbesj_wrap(npy_double, npy_cdouble);
+npy_double cbesj_wrap_real(npy_double, npy_double);
+npy_cdouble cbesj_wrap_e(npy_double, npy_cdouble);
+npy_double cbesj_wrap_e_real(npy_double, npy_double);
+npy_double k0(npy_double);
+npy_double k0e(npy_double);
+npy_double k1(npy_double);
+npy_double k1e(npy_double);
+npy_double kei_wrap(npy_double);
+npy_double keip_wrap(npy_double);
+npy_int kelvin_wrap(npy_double, npy_cdouble *, npy_cdouble *, npy_cdouble *, npy_cdouble *);
+npy_double ker_wrap(npy_double);
+npy_double kerp_wrap(npy_double);
+npy_double cbesk_wrap_real_int(npy_int, npy_double);
+npy_double kolmogi(npy_double);
+npy_double kolmogorov(npy_double);
+npy_cdouble cbesk_wrap(npy_double, npy_cdouble);
+npy_double cbesk_wrap_real(npy_double, npy_double);
+npy_cdouble cbesk_wrap_e(npy_double, npy_cdouble);
+npy_double cbesk_wrap_e_real(npy_double, npy_double);
+npy_double log1p(npy_double);
+npy_double pmv_wrap(npy_double, npy_double, npy_double);
+npy_double cem_cva_wrap(npy_double, npy_double);
+npy_double sem_cva_wrap(npy_double, npy_double);
+npy_int cem_wrap(npy_double, npy_double, npy_double, npy_double *, npy_double *);
+npy_int mcm1_wrap(npy_double, npy_double, npy_double, npy_double *, npy_double *);
+npy_int mcm2_wrap(npy_double, npy_double, npy_double, npy_double *, npy_double *);
+npy_int msm1_wrap(npy_double, npy_double, npy_double, npy_double *, npy_double *);
+npy_int msm2_wrap(npy_double, npy_double, npy_double, npy_double *, npy_double *);
+npy_int sem_wrap(npy_double, npy_double, npy_double, npy_double *, npy_double *);
+npy_int modified_fresnel_minus_wrap(npy_double, npy_cdouble *, npy_cdouble *);
+npy_int modified_fresnel_plus_wrap(npy_double, npy_cdouble *, npy_cdouble *);
+npy_double struve_l(npy_double, npy_double);
+npy_double nbdtr(npy_int, npy_int, npy_double);
+npy_double nbdtrc(npy_int, npy_int, npy_double);
+npy_double nbdtri(npy_int, npy_int, npy_double);
+npy_double ndtr(npy_double);
+npy_double ndtri(npy_double);
+npy_double oblate_aswfa_nocv_wrap(npy_double, npy_double, npy_double, npy_double, npy_double *);
+npy_int oblate_aswfa_wrap(npy_double, npy_double, npy_double, npy_double, npy_double, npy_double *, npy_double *);
+npy_double oblate_segv_wrap(npy_double, npy_double, npy_double);
+npy_double oblate_radial1_nocv_wrap(npy_double, npy_double, npy_double, npy_double, npy_double *);
+npy_int oblate_radial1_wrap(npy_double, npy_double, npy_double, npy_double, npy_double, npy_double *, npy_double *);
+npy_double oblate_radial2_nocv_wrap(npy_double, npy_double, npy_double, npy_double, npy_double *);
+npy_int oblate_radial2_wrap(npy_double, npy_double, npy_double, npy_double, npy_double, npy_double *, npy_double *);
+npy_double owens_t(npy_double, npy_double);
+npy_int pbdv_wrap(npy_double, npy_double, npy_double *, npy_double *);
+npy_int pbvv_wrap(npy_double, npy_double, npy_double *, npy_double *);
+npy_int pbwa_wrap(npy_double, npy_double, npy_double *, npy_double *);
+npy_double pdtr(npy_double, npy_double);
+npy_double pdtrc(npy_double, npy_double);
+npy_double pdtri(npy_int, npy_double);
+npy_double poch(npy_double, npy_double);
+npy_double prolate_aswfa_nocv_wrap(npy_double, npy_double, npy_double, npy_double, npy_double *);
+npy_int prolate_aswfa_wrap(npy_double, npy_double, npy_double, npy_double, npy_double, npy_double *, npy_double *);
+npy_double prolate_segv_wrap(npy_double, npy_double, npy_double);
+npy_double prolate_radial1_nocv_wrap(npy_double, npy_double, npy_double, npy_double, npy_double *);
+npy_int prolate_radial1_wrap(npy_double, npy_double, npy_double, npy_double, npy_double, npy_double *, npy_double *);
+npy_double prolate_radial2_nocv_wrap(npy_double, npy_double, npy_double, npy_double, npy_double *);
+npy_int prolate_radial2_wrap(npy_double, npy_double, npy_double, npy_double, npy_double, npy_double *, npy_double *);
+npy_double radian(npy_double, npy_double, npy_double);
+npy_double rgamma(npy_double);
+npy_double round(npy_double);
+npy_int shichi(npy_double, npy_double *, npy_double *);
+npy_int sici(npy_double, npy_double *, npy_double *);
+npy_double sindg(npy_double);
+npy_double smirnov(npy_int, npy_double);
+npy_double smirnovi(npy_int, npy_double);
+npy_double spence(npy_double);
+npy_double struve_h(npy_double, npy_double);
+npy_double tandg(npy_double);
+npy_double tukeylambdacdf(npy_double, npy_double);
+npy_double y0(npy_double);
+npy_double y1(npy_double);
+npy_double yn(npy_int, npy_double);
+npy_cdouble cbesy_wrap(npy_double, npy_cdouble);
+npy_double cbesy_wrap_real(npy_double, npy_double);
+npy_cdouble cbesy_wrap_e(npy_double, npy_cdouble);
+npy_double cbesy_wrap_e_real(npy_double, npy_double);
+npy_double zetac(npy_double);
+#endif

.venv/Lib/site-packages/scipy/special/special/binom.h

@@ -0,0 +1,85 @@
+/* Translated from Cython into C++ by SciPy developers in 2024.
+ *
+ * Original authors: Pauli Virtanen, Eric Moore
+ */
+
+// Binomial coefficient
+
+#pragma once
+
+#include "config.h"
+
+#include "cephes/beta.h"
+#include "cephes/gamma.h"
+
+namespace special {
+
+SPECFUN_HOST_DEVICE inline double binom(double n, double k) {
+    double kx, nx, num, den, dk, sgn;
+
+    if (n < 0) {
+        nx = std::floor(n);
+        if (n == nx) {
+            // Undefined
+            return std::numeric_limits<double>::quiet_NaN();
+        }
+    }
+
+    kx = std::floor(k);
+    if (k == kx && (std::abs(n) > 1E-8 || n == 0)) {
+        /* Integer case: use multiplication formula for less rounding
+         * error for cases where the result is an integer.
+         *
+         * This cannot be used for small nonzero n due to loss of
+         * precision. */
+        nx = std::floor(n);
+        if (nx == n && kx > nx / 2 && nx > 0) {
+            // Reduce kx by symmetry
+            kx = nx - kx;
+        }
+
+        if (kx >= 0 && kx < 20) {
+            num = 1.0;
+            den = 1.0;
+            for (int i = 1; i < 1 + static_cast<int>(kx); i++) {
+                num *= i + n - kx;
+                den *= i;
+                if (std::abs(num) > 1E50) {
+                    num /= den;
+                    den = 1.0;
+                }
+            }
+            return num / den;
+        }
+    }
+
+    // general case
+    if (n >= 1E10 * k and k > 0) {
+        // avoid under/overflows intermediate results
+        return std::exp(-cephes::lbeta(1 + n - k, 1 + k) - std::log(n + 1));
+    }
+    if (k > 1E8 * std::abs(n)) {
+        // avoid loss of precision
+        num = cephes::Gamma(1 + n) / std::abs(k) + cephes::Gamma(1 + n) * n / (2 * k * k); // + ...
+        num /= M_PI * std::pow(std::abs(k), n);
+        if (k > 0) {
+            kx = std::floor(k);
+            if (static_cast<int>(kx) == kx) {
+                dk = k - kx;
+                sgn = (static_cast<int>(kx) % 2 == 0) ? 1 : -1;
+            } else {
+                dk = k;
+                sgn = 1;
+            }
+            return num * std::sin((dk - n) * M_PI) * sgn;
+        }
+        kx = std::floor(k);
+        if (static_cast<int>(kx) == kx) {
+            return 0;
+        }
+        return num * std::sin(k * M_PI);
+    }
+    return 1 / (n + 1) / cephes::beta(1 + n - k, 1 + k);
+}
+
+} // namespace special

.venv/Lib/site-packages/scipy/special/special/config.h

@@ -0,0 +1,158 @@
+#pragma once
+
+// Define math constants if they are not available
+#ifndef M_E
+#define M_E 2.71828182845904523536
+#endif
+
+#ifndef M_LOG2E
+#define M_LOG2E 1.44269504088896340736
+#endif
+
+#ifndef M_LOG10E
+#define M_LOG10E 0.434294481903251827651
+#endif
+
+#ifndef M_LN2
+#define M_LN2 0.693147180559945309417
+#endif
+
+#ifndef M_LN10
+#define M_LN10 2.30258509299404568402
+#endif
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+#ifndef M_PI_2
+#define M_PI_2 1.57079632679489661923
+#endif
+
+#ifndef M_PI_4
+#define M_PI_4 0.785398163397448309616
+#endif
+
+#ifndef M_1_PI
+#define M_1_PI 0.318309886183790671538
+#endif
+
+#ifndef M_2_PI
+#define M_2_PI 0.636619772367581343076
+#endif
+
+#ifndef M_2_SQRTPI
+#define M_2_SQRTPI 1.12837916709551257390
+#endif
+
+#ifndef M_SQRT2
+#define M_SQRT2 1.41421356237309504880
+#endif
+
+#ifndef M_SQRT1_2
+#define M_SQRT1_2 0.707106781186547524401
+#endif
+
+#ifdef __CUDACC__
+#define SPECFUN_HOST_DEVICE __host__ __device__
+
+#include <cuda/std/cmath>
+#include <cuda/std/limits>
+
+// Fallback to global namespace for functions unsupported on NVRTC Jit
+#ifdef _LIBCUDACXX_COMPILER_NVRTC
+#include <cuda_runtime.h>
+#endif
+
+namespace std {
+
+SPECFUN_HOST_DEVICE inline double abs(double num) { return cuda::std::abs(num); }
+
+SPECFUN_HOST_DEVICE inline double exp(double num) { return cuda::std::exp(num); }
+
+SPECFUN_HOST_DEVICE inline double log(double num) { return cuda::std::log(num); }
+
+SPECFUN_HOST_DEVICE inline double sqrt(double num) { return cuda::std::sqrt(num); }
+
+SPECFUN_HOST_DEVICE inline bool isnan(double num) { return cuda::std::isnan(num); }
+
+SPECFUN_HOST_DEVICE inline bool isfinite(double num) { return cuda::std::isfinite(num); }
+
+SPECFUN_HOST_DEVICE inline double pow(double x, double y) { return cuda::std::pow(x, y); }
+
+SPECFUN_HOST_DEVICE inline double sin(double x) { return cuda::std::sin(x); }
+
+SPECFUN_HOST_DEVICE inline double tan(double x) { return cuda::std::tan(x); }
+
+SPECFUN_HOST_DEVICE inline double sinh(double x) { return cuda::std::sinh(x); }
+
+SPECFUN_HOST_DEVICE inline double cosh(double x) { return cuda::std::cosh(x); }
+
+SPECFUN_HOST_DEVICE inline bool signbit(double x) { return cuda::std::signbit(x); }
+
+// Fallback to global namespace for functions unsupported on NVRTC
+#ifndef _LIBCUDACXX_COMPILER_NVRTC
+SPECFUN_HOST_DEVICE inline double ceil(double x) { return cuda::std::ceil(x); }
+SPECFUN_HOST_DEVICE inline double floor(double x) { return cuda::std::floor(x); }
+SPECFUN_HOST_DEVICE inline double trunc(double x) { return cuda::std::trunc(x); }
+SPECFUN_HOST_DEVICE inline double fma(double x, double y, double z) { return cuda::std::fma(x, y, z); }
+SPECFUN_HOST_DEVICE inline double copysign(double x, double y) { return cuda::std::copysign(x, y); }
+SPECFUN_HOST_DEVICE inline double modf(double value, double *iptr) { return cuda::std::modf(value, iptr); }
+
+#else
+SPECFUN_HOST_DEVICE inline double ceil(double x) { return ::ceil(x); }
+SPECFUN_HOST_DEVICE inline double floor(double x) { return ::floor(x); }
+SPECFUN_HOST_DEVICE inline double trunc(double x) { return ::trunc(x); }
+SPECFUN_HOST_DEVICE inline double fma(double x, double y, double z) { return ::fma(x, y, z); }
+SPECFUN_HOST_DEVICE inline double copysign(double x, double y) { return ::copysign(x, y); }
+SPECFUN_HOST_DEVICE inline double modf(double value, double *iptr) { return ::modf(value, iptr); }
+#endif
+
+template <typename T>
+using numeric_limits = cuda::std::numeric_limits<T>;
+
+// Must use thrust for complex types in order to support CuPy
+template <typename T>
+using complex = thrust::complex<T>;
+
+template <typename T>
+SPECFUN_HOST_DEVICE T abs(const complex<T> &z) {
+    return thrust::abs(z);
+}
+
+template <typename T>
+SPECFUN_HOST_DEVICE complex<T> exp(const complex<T> &z) {
+    return thrust::exp(z);
+}
+
+template <typename T>
+SPECFUN_HOST_DEVICE complex<T> log(const complex<T> &z) {
+    return thrust::log(z);
+}
+
+template <typename T>
+SPECFUN_HOST_DEVICE T norm(const complex<T> &z) {
+    return thrust::norm(z);
+}
+
+template <typename T>
+SPECFUN_HOST_DEVICE complex<T> sqrt(const complex<T> &z) {
+    return thrust::sqrt(z);
+}
+
+template <typename T>
+SPECFUN_HOST_DEVICE complex<T> conj(const complex<T> &z) {
+    return thrust::conj(z);
+}
+
+} // namespace std
+
+#else
+#define SPECFUN_HOST_DEVICE
+
+#include <cmath>
+#include <complex>
+#include <limits>
+#include <math.h>
+
+#endif

.venv/Lib/site-packages/scipy/special/special/digamma.h

@@ -0,0 +1,198 @@
+/* Translated from Cython into C++ by SciPy developers in 2024.
+ * Original header comment appears below.
+ */
+
+/* An implementation of the digamma function for complex arguments.
+ *
+ * Author: Josh Wilson
+ *
+ * Distributed under the same license as Scipy.
+ *
+ * Sources:
+ * [1] "The Digital Library of Mathematical Functions", dlmf.nist.gov
+ *
+ * [2] mpmath (version 0.19), http://mpmath.org
+ */
+
+#pragma once
+
+#include "cephes/psi.h"
+#include "cephes/zeta.h"
+#include "config.h"
+#include "error.h"
+#include "trig.h"
+
+namespace special {
+namespace detail {
+    // All of the following were computed with mpmath
+    // Location of the positive root
+    constexpr double digamma_posroot = 1.4616321449683623;
+    // Value of the positive root
+    constexpr double digamma_posrootval = -9.2412655217294275e-17;
+    // Location of the negative root
+    constexpr double digamma_negroot = -0.504083008264455409;
+    // Value of the negative root
+    constexpr double digamma_negrootval = 7.2897639029768949e-17;
+
+    template <typename T>
+    SPECFUN_HOST_DEVICE T digamma_zeta_series(T z, double root, double rootval) {
+        T res = rootval;
+        T coeff = -1.0;
+
+        z = z - root;
+        T term;
+        for (int n = 1; n < 100; n++) {
+            coeff *= -z;
+            term = coeff * cephes::zeta(n + 1, root);
+            res += term;
+            if (std::abs(term) < std::numeric_limits<double>::epsilon() * std::abs(res)) {
+                break;
+            }
+        }
+        return res;
+    }
+
+    SPECFUN_HOST_DEVICE inline std::complex<double> digamma_forward_recurrence(std::complex<double> z,
+                                                                               std::complex<double> psiz, int n) {
+        /* Compute digamma(z + n) using digamma(z) using the recurrence
+         * relation
+         *
+         * digamma(z + 1) = digamma(z) + 1/z.
+         *
+         * See https://dlmf.nist.gov/5.5#E2 */
+        std::complex<double> res = psiz;
+
+        for (int k = 0; k < n; k++) {
+            res += 1.0 / (z + static_cast<double>(k));
+        }
+        return res;
+    }
+
+    SPECFUN_HOST_DEVICE inline std::complex<double> digamma_backward_recurrence(std::complex<double> z,
+                                                                                std::complex<double> psiz, int n) {
+        /* Compute digamma(z - n) using digamma(z) and a recurrence relation. */
+        std::complex<double> res = psiz;
+
+        for (int k = 1; k < n + 1; k++) {
+            res -= 1.0 / (z - static_cast<double>(k));
+        }
+        return res;
+    }
+
+    SPECFUN_HOST_DEVICE inline std::complex<double> digamma_asymptotic_series(std::complex<double> z) {
+        /* Evaluate digamma using an asymptotic series. See
+         *
+         * https://dlmf.nist.gov/5.11#E2 */
+        double bernoulli2k[] = {
+            0.166666666666666667,  -0.0333333333333333333, 0.0238095238095238095, -0.0333333333333333333,
+            0.0757575757575757576, -0.253113553113553114,  1.16666666666666667,   -7.09215686274509804,
+            54.9711779448621554,   -529.124242424242424,   6192.12318840579710,   -86580.2531135531136,
+            1425517.16666666667,   -27298231.0678160920,   601580873.900642368,   -15116315767.0921569};
+        std::complex<double> rzz = 1.0 / z / z;
+        std::complex<double> zfac = 1.0;
+        std::complex<double> term;
+        std::complex<double> res;
+
+        if (!(std::isfinite(z.real()) && std::isfinite(z.imag()))) {
+            /* Check for infinity (or nan) and return early.
+             * Result of division by complex infinity is implementation dependent.
+             * and has been observed to vary between C++ stdlib and CUDA stdlib.
+             */
+            return std::log(z);
+        }
+
+        res = std::log(z) - 0.5 / z;
+
+        for (int k = 1; k < 17; k++) {
+            zfac *= rzz;
+            term = -bernoulli2k[k - 1] * zfac / (2 * static_cast<double>(k));
+            res += term;
+            if (std::abs(term) < std::numeric_limits<double>::epsilon() * std::abs(res)) {
+                break;
+            }
+        }
+        return res;
+    }
+
+} // namespace detail
+
+SPECFUN_HOST_DEVICE inline double digamma(double z) {
+    /* Wrap Cephes' psi to take advantage of the series expansion around
+     * the smallest negative zero.
+     */
+    if (std::abs(z - detail::digamma_negroot) < 0.3) {
+        return detail::digamma_zeta_series(z, detail::digamma_negroot, detail::digamma_negrootval);
+    }
+    return cephes::psi(z);
+}
+
+SPECFUN_HOST_DEVICE inline std::complex<double> digamma(std::complex<double> z) {
+    /*
+     * Compute the digamma function for complex arguments. The strategy
+     * is:
+     *
+     * - Around the two zeros closest to the origin (posroot and negroot)
+     * use a Taylor series with precomputed zero order coefficient.
+     * - If close to the origin, use a recurrence relation to step away
+     * from the origin.
+     * - If close to the negative real axis, use the reflection formula
+     * to move to the right halfplane.
+     * - If |z| is large (> 16), use the asymptotic series.
+     * - If |z| is small, use a recurrence relation to make |z| large
+     * enough to use the asymptotic series.
+     */
+    double absz = std::abs(z);
+    std::complex<double> res = 0;
+    /* Use the asymptotic series for z away from the negative real axis
+     * with abs(z) > smallabsz. */
+    int smallabsz = 16;
+    /* Use the reflection principle for z with z.real < 0 that are within
+     * smallimag of the negative real axis.
+     * int smallimag = 6  # unused below except in a comment */
+
+    if (z.real() <= 0.0 && std::ceil(z.real()) == z) {
+        // Poles
+        set_error("digamma", SF_ERROR_SINGULAR, NULL);
+        return {std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()};
+    }
+    if (std::abs(z - detail::digamma_negroot) < 0.3) {
+        // First negative root.
+        return detail::digamma_zeta_series(z, detail::digamma_negroot, detail::digamma_negrootval);
+    }
+
+    if (z.real() < 0 and std::abs(z.imag()) < smallabsz) {
+        /* Reflection formula for digamma. See
+         *
+         *https://dlmf.nist.gov/5.5#E4
+         */
+        res = -M_PI * cospi(z) / sinpi(z);
+        z = 1.0 - z;
+        absz = std::abs(z);
+    }
+
+    if (absz < 0.5) {
+        /* Use one step of the recurrence relation to step away from
+         * the pole. */
+        res = -1.0 / z;
+        z += 1.0;
+        absz = std::abs(z);
+    }
+
+    if (std::abs(z - detail::digamma_posroot) < 0.5) {
+        res += detail::digamma_zeta_series(z, detail::digamma_posroot, detail::digamma_posrootval);
+    } else if (absz > smallabsz) {
+        res += detail::digamma_asymptotic_series(z);
+    } else if (z.real() >= 0.0) {
+        double n = std::trunc(smallabsz - absz) + 1;
+        std::complex<double> init = detail::digamma_asymptotic_series(z + n);
+        res += detail::digamma_backward_recurrence(z + n, init, n);
+    } else {
+        // z.real() < 0, absz < smallabsz, and z.imag() > smallimag
+        double n = std::trunc(smallabsz - absz) - 1;
+        std::complex<double> init = detail::digamma_asymptotic_series(z - n);
+        res += detail::digamma_forward_recurrence(z - n, init, n);
+    }
+    return res;
+}
+
+} // namespace special

.venv/Lib/site-packages/scipy/special/special/error.h

@@ -0,0 +1,42 @@
+#pragma once
+
+// should be included from config.h, but that won't work until we've cleanly separated out the C and C++ parts of the
+// code
+#ifdef __CUDACC__
+#define SPECFUN_HOST_DEVICE __host__ __device__
+#else
+#define SPECFUN_HOST_DEVICE
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    SF_ERROR_OK = 0,    /* no error */
+    SF_ERROR_SINGULAR,  /* singularity encountered */
+    SF_ERROR_UNDERFLOW, /* floating point underflow */
+    SF_ERROR_OVERFLOW,  /* floating point overflow */
+    SF_ERROR_SLOW,      /* too many iterations required */
+    SF_ERROR_LOSS,      /* loss of precision */
+    SF_ERROR_NO_RESULT, /* no result obtained */
+    SF_ERROR_DOMAIN,    /* out of domain */
+    SF_ERROR_ARG,       /* invalid input parameter */
+    SF_ERROR_OTHER,     /* unclassified error */
+    SF_ERROR__LAST
+} sf_error_t;
+
+#ifdef __cplusplus
+namespace special {
+
+#ifndef SP_SPECFUN_ERROR
+    SPECFUN_HOST_DEVICE inline void set_error(const char *func_name, sf_error_t code, const char *fmt, ...) {
+        // nothing
+    }
+#else
+    void set_error(const char *func_name, sf_error_t code, const char *fmt, ...);
+#endif
+} // namespace special
+
+} // closes extern "C"
+#endif

.venv/Lib/site-packages/scipy/special/tests/test_wright_bessel.py

@@ -0,0 +1,115 @@
+# Reference MPMATH implementation:
+#
+# import mpmath
+# from mpmath import nsum
+#
+# def Wright_Series_MPMATH(a, b, z, dps=50, method='r+s+e', steps=[1000]):
+#    """Compute Wright' generalized Bessel function as Series.
+#
+#    This uses mpmath for arbitrary precision.
+#    """
+#    with mpmath.workdps(dps):
+#        res = nsum(lambda k: z**k/mpmath.fac(k) * mpmath.rgamma(a*k+b),
+#                          [0, mpmath.inf],
+#                          tol=dps, method=method, steps=steps
+#                          )
+#
+#    return res
+
+import pytest
+import numpy as np
+from numpy.testing import assert_equal, assert_allclose
+
+import scipy.special as sc
+from scipy.special import rgamma, wright_bessel
+
+
+@pytest.mark.parametrize('a', [0, 1e-6, 0.1, 0.5, 1, 10])
+@pytest.mark.parametrize('b', [0, 1e-6, 0.1, 0.5, 1, 10])
+def test_wright_bessel_zero(a, b):
+    """Test at x = 0."""
+    assert_equal(wright_bessel(a, b, 0.), rgamma(b))
+
+
+@pytest.mark.parametrize('b', [0, 1e-6, 0.1, 0.5, 1, 10])
+@pytest.mark.parametrize('x', [0, 1e-6, 0.1, 0.5, 1])
+def test_wright_bessel_iv(b, x):
+    """Test relation of wright_bessel and modified bessel function iv.
+
+    iv(z) = (1/2*z)**v * Phi(1, v+1; 1/4*z**2).
+    See https://dlmf.nist.gov/10.46.E2
+    """
+    if x != 0:
+        v = b - 1
+        wb = wright_bessel(1, v + 1, x**2 / 4.)
+        # Note: iv(v, x) has precision of less than 1e-12 for some cases
+        # e.g v=1-1e-6 and x=1e-06)
+        assert_allclose(np.power(x / 2., v) * wb,
+                        sc.iv(v, x),
+                        rtol=1e-11, atol=1e-11)
+
+
+@pytest.mark.parametrize('a', [0, 1e-6, 0.1, 0.5, 1, 10])
+@pytest.mark.parametrize('b', [1, 1 + 1e-3, 2, 5, 10])
+@pytest.mark.parametrize('x', [0, 1e-6, 0.1, 0.5, 1, 5, 10, 100])
+def test_wright_functional(a, b, x):
+    """Test functional relation of wright_bessel.
+
+    Phi(a, b-1, z) = a*z*Phi(a, b+a, z) + (b-1)*Phi(a, b, z)
+
+    Note that d/dx Phi(a, b, x) = Phi(a, b-1, x)
+    See Eq. (22) of
+    B. Stankovic, On the Function of E. M. Wright,
+    Publ. de l' Institut Mathematique, Beograd,
+    Nouvelle S`er. 10 (1970), 113-124.
+    """
+    assert_allclose(wright_bessel(a, b - 1, x),
+                    a * x * wright_bessel(a, b + a, x)
+                    + (b - 1) * wright_bessel(a, b, x),
+                    rtol=1e-8, atol=1e-8)
+
+
+# grid of rows [a, b, x, value, accuracy] that do not reach 1e-11 accuracy
+# see output of:
+# cd scipy/scipy/_precompute
+# python wright_bessel_data.py
+grid_a_b_x_value_acc = np.array([
+    [0.1, 100.0, 709.7827128933841, 8.026353022981087e+34, 2e-8],
+    [0.5, 10.0, 709.7827128933841, 2.680788404494657e+48, 9e-8],
+    [0.5, 10.0, 1000.0, 2.005901980702872e+64, 1e-8],
+    [0.5, 100.0, 1000.0, 3.4112367580445246e-117, 6e-8],
+    [1.0, 20.0, 100000.0, 1.7717158630699857e+225, 3e-11],
+    [1.0, 100.0, 100000.0, 1.0269334596230763e+22, np.nan],
+    [1.0000000000000222, 20.0, 100000.0, 1.7717158630001672e+225, 3e-11],
+    [1.0000000000000222, 100.0, 100000.0, 1.0269334595866202e+22, np.nan],
+    [1.5, 0.0, 500.0, 15648961196.432373, 3e-11],
+    [1.5, 2.220446049250313e-14, 500.0, 15648961196.431465, 3e-11],
+    [1.5, 1e-10, 500.0, 15648961192.344728, 3e-11],
+    [1.5, 1e-05, 500.0, 15648552437.334162, 3e-11],
+    [1.5, 0.1, 500.0, 12049870581.10317, 2e-11],
+    [1.5, 20.0, 100000.0, 7.81930438331405e+43, 3e-9],
+    [1.5, 100.0, 100000.0, 9.653370857459075e-130, np.nan],
+    ])
+
+
+@pytest.mark.xfail
+@pytest.mark.parametrize(
+    'a, b, x, phi',
+    grid_a_b_x_value_acc[:, :4].tolist())
+def test_wright_data_grid_failures(a, b, x, phi):
+    """Test cases of test_data that do not reach relative accuracy of 1e-11"""
+    assert_allclose(wright_bessel(a, b, x), phi, rtol=1e-11)
+
+
+@pytest.mark.parametrize(
+    'a, b, x, phi, accuracy',
+    grid_a_b_x_value_acc.tolist())
+def test_wright_data_grid_less_accurate(a, b, x, phi, accuracy):
+    """Test cases of test_data that do not reach relative accuracy of 1e-11
+
+    Here we test for reduced accuracy or even nan.
+    """
+    if np.isnan(accuracy):
+        assert np.isnan(wright_bessel(a, b, x))
+    else:
+        assert_allclose(wright_bessel(a, b, x), phi, rtol=accuracy)

.venv/Lib/site-packages/scipy/special/tests/test_zeta.py

@@ -0,0 +1,49 @@
+import scipy.special as sc
+import numpy as np
+from numpy.testing import assert_equal, assert_allclose
+
+
+def test_zeta():
+    assert_allclose(sc.zeta(2,2), np.pi**2/6 - 1, rtol=1e-12)
+
+
+def test_zetac():
+    # Expected values in the following were computed using Wolfram
+    # Alpha's `Zeta[x] - 1`
+    x = [-2.1, 0.8, 0.9999, 9, 50, 75]
+    desired = [
+        -0.9972705002153750,
+        -5.437538415895550,
+        -10000.42279161673,
+        0.002008392826082214,
+        8.881784210930816e-16,
+        2.646977960169853e-23,
+    ]
+    assert_allclose(sc.zetac(x), desired, rtol=1e-12)
+
+
+def test_zetac_special_cases():
+    assert sc.zetac(np.inf) == 0
+    assert np.isnan(sc.zetac(-np.inf))
+    assert sc.zetac(0) == -1.5
+    assert sc.zetac(1.0) == np.inf
+
+    assert_equal(sc.zetac([-2, -50, -100]), -1)
+
+
+def test_riemann_zeta_special_cases():
+    assert np.isnan(sc.zeta(np.nan))
+    assert sc.zeta(np.inf) == 1
+    assert sc.zeta(0) == -0.5
+
+    # Riemann zeta is zero add negative even integers.
+    assert_equal(sc.zeta([-2, -4, -6, -8, -10]), 0)
+
+    assert_allclose(sc.zeta(2), np.pi**2/6, rtol=1e-12)
+    assert_allclose(sc.zeta(4), np.pi**4/90, rtol=1e-12)
+
+
+def test_riemann_zeta_avoid_overflow():
+    s = -260.00000000001
+    desired = -5.6966307844402683127e+297  # Computed with Mpmath
+    assert_allclose(sc.zeta(s), desired, atol=0, rtol=5e-14)

.venv/Lib/site-packages/scipy/stats/morestats.py

@@ -0,0 +1,34 @@
+# This file is not meant for public use and will be removed in SciPy v2.0.0.
+# Use the `scipy.stats` namespace for importing the functions
+# included below.
+
+from scipy._lib.deprecation import _sub_module_deprecation
+
+
+__all__ = [  # noqa: F822
+    'mvsdist',
+    'bayes_mvs', 'kstat', 'kstatvar', 'probplot', 'ppcc_max', 'ppcc_plot',
+    'boxcox_llf', 'boxcox', 'boxcox_normmax', 'boxcox_normplot',
+    'shapiro', 'anderson', 'ansari', 'bartlett', 'levene',
+    'fligner', 'mood', 'wilcoxon', 'median_test',
+    'circmean', 'circvar', 'circstd', 'anderson_ksamp',
+    'yeojohnson_llf', 'yeojohnson', 'yeojohnson_normmax',
+    'yeojohnson_normplot', 'annotations', 'namedtuple', 'isscalar', 'log',
+    'around', 'unique', 'arange', 'sort', 'amin', 'amax', 'atleast_1d',
+    'array', 'compress', 'exp', 'ravel', 'count_nonzero', 'arctan2',
+    'hypot', 'optimize', 'find_repeats',
+    'chi2_contingency', 'distributions', 'rv_generic', 'Mean',
+    'Variance', 'Std_dev', 'ShapiroResult', 'AndersonResult',
+    'Anderson_ksampResult', 'AnsariResult', 'BartlettResult',
+    'LeveneResult', 'FlignerResult', 'WilcoxonResult'
+]
+
+
+def __dir__():
+    return __all__
+
+
+def __getattr__(name):
+    return _sub_module_deprecation(sub_package="stats", module="morestats",
+                                   private_modules=["_morestats"], all=__all__,
+                                   attribute=name)

.venv/Lib/site-packages/scipy/stats/mstats.py

@@ -0,0 +1,140 @@
+"""
+===================================================================
+Statistical functions for masked arrays (:mod:`scipy.stats.mstats`)
+===================================================================
+
+.. currentmodule:: scipy.stats.mstats
+
+This module contains a large number of statistical functions that can
+be used with masked arrays.
+
+Most of these functions are similar to those in `scipy.stats` but might
+have small differences in the API or in the algorithm used. Since this
+is a relatively new package, some API changes are still possible.
+
+Summary statistics
+==================
+
+.. autosummary::
+   :toctree: generated/
+
+   describe
+   gmean
+   hmean
+   kurtosis
+   mode
+   mquantiles
+   hdmedian
+   hdquantiles
+   hdquantiles_sd
+   idealfourths
+   plotting_positions
+   meppf
+   moment
+   skew
+   tmean
+   tvar
+   tmin
+   tmax
+   tsem
+   variation
+   find_repeats
+   sem
+   trimmed_mean
+   trimmed_mean_ci
+   trimmed_std
+   trimmed_var
+
+Frequency statistics
+====================
+
+.. autosummary::
+   :toctree: generated/
+
+   scoreatpercentile
+
+Correlation functions
+=====================
+
+.. autosummary::
+   :toctree: generated/
+
+   f_oneway
+   pearsonr
+   spearmanr
+   pointbiserialr
+   kendalltau
+   kendalltau_seasonal
+   linregress
+   siegelslopes
+   theilslopes
+   sen_seasonal_slopes
+
+Statistical tests
+=================
+
+.. autosummary::
+   :toctree: generated/
+
+   ttest_1samp
+   ttest_onesamp
+   ttest_ind
+   ttest_rel
+   chisquare
+   kstest
+   ks_2samp
+   ks_1samp
+   ks_twosamp
+   mannwhitneyu
+   rankdata
+   kruskal
+   kruskalwallis
+   friedmanchisquare
+   brunnermunzel
+   skewtest
+   kurtosistest
+   normaltest
+
+Transformations
+===============
+
+.. autosummary::
+   :toctree: generated/
+
+   obrientransform
+   trim
+   trima
+   trimmed_stde
+   trimr
+   trimtail
+   trimboth
+   winsorize
+   zmap
+   zscore
+
+Other
+=====
+
+.. autosummary::
+   :toctree: generated/
+
+   argstoarray
+   count_tied_groups
+   msign
+   compare_medians_ms
+   median_cihs
+   mjci
+   mquantiles_cimj
+   rsh
+
+"""
+from . import _mstats_basic
+from . import _mstats_extras
+from ._mstats_basic import *  # noqa: F403
+from ._mstats_extras import *  # noqa: F403
+# Functions that support masked array input in stats but need to be kept in the
+# mstats namespace for backwards compatibility:
+from scipy.stats import gmean, hmean, zmap, zscore, chisquare
+
+__all__ = _mstats_basic.__all__ + _mstats_extras.__all__
+__all__ += ['gmean', 'hmean', 'zmap', 'zscore', 'chisquare']

.venv/Lib/site-packages/scipy/stats/mstats_basic.py

@@ -0,0 +1,50 @@
+# This file is not meant for public use and will be removed in SciPy v2.0.0.
+# Use the `scipy.stats` namespace for importing the functions
+# included below.
+
+from scipy._lib.deprecation import _sub_module_deprecation
+
+
+__all__ = [  # noqa: F822
+    'argstoarray',
+    'count_tied_groups',
+    'describe',
+    'f_oneway', 'find_repeats','friedmanchisquare',
+    'kendalltau','kendalltau_seasonal','kruskal','kruskalwallis',
+    'ks_twosamp', 'ks_2samp', 'kurtosis', 'kurtosistest',
+    'ks_1samp', 'kstest',
+    'linregress',
+    'mannwhitneyu', 'meppf','mode','moment','mquantiles','msign',
+    'normaltest',
+    'obrientransform',
+    'pearsonr','plotting_positions','pointbiserialr',
+    'rankdata',
+    'scoreatpercentile','sem',
+    'sen_seasonal_slopes','skew','skewtest','spearmanr',
+    'siegelslopes', 'theilslopes',
+    'tmax','tmean','tmin','trim','trimboth',
+    'trimtail','trima','trimr','trimmed_mean','trimmed_std',
+    'trimmed_stde','trimmed_var','tsem','ttest_1samp','ttest_onesamp',
+    'ttest_ind','ttest_rel','tvar',
+    'variation',
+    'winsorize',
+    'brunnermunzel', 'ma', 'masked', 'nomask', 'namedtuple',
+    'distributions', 'stats_linregress', 'stats_LinregressResult',
+    'stats_theilslopes', 'stats_siegelslopes', 'ModeResult',
+    'PointbiserialrResult',
+    'Ttest_1sampResult', 'Ttest_indResult', 'Ttest_relResult',
+    'MannwhitneyuResult', 'KruskalResult', 'trimdoc', 'trim1',
+    'DescribeResult', 'stde_median', 'SkewtestResult', 'KurtosistestResult',
+    'NormaltestResult', 'F_onewayResult', 'FriedmanchisquareResult',
+    'BrunnerMunzelResult'
+]
+
+
+def __dir__():
+    return __all__
+
+
+def __getattr__(name):
+    return _sub_module_deprecation(sub_package="stats", module="mstats_basic",
+                                   private_modules=["_mstats_basic"], all=__all__,
+                                   attribute=name, correct_module="mstats")

.venv/Lib/site-packages/scipy/stats/mstats_extras.py

@@ -0,0 +1,26 @@
+# This file is not meant for public use and will be removed in SciPy v2.0.0.
+# Use the `scipy.stats` namespace for importing the functions
+# included below.
+
+from scipy._lib.deprecation import _sub_module_deprecation
+
+
+__all__ = [  # noqa: F822
+    'compare_medians_ms',
+    'hdquantiles', 'hdmedian', 'hdquantiles_sd',
+    'idealfourths',
+    'median_cihs','mjci','mquantiles_cimj',
+    'rsh',
+    'trimmed_mean_ci', 'ma', 'MaskedArray', 'mstats',
+    'norm', 'beta', 't', 'binom'
+]
+
+
+def __dir__():
+    return __all__
+
+
+def __getattr__(name):
+    return _sub_module_deprecation(sub_package="stats", module="mstats_extras",
+                                   private_modules=["_mstats_extras"], all=__all__,
+                                   attribute=name, correct_module="mstats")

.venv/Lib/site-packages/scipy/stats/tests/test_axis_nan_policy.py

@@ -0,0 +1,1188 @@
+# Many scipy.stats functions support `axis` and `nan_policy` parameters.
+# When the two are combined, it can be tricky to get all the behavior just
+# right. This file contains a suite of common tests for scipy.stats functions
+# that support `axis` and `nan_policy` and additional tests for some associated
+# functions in stats._util.
+
+from itertools import product, combinations_with_replacement, permutations
+import re
+import pickle
+import pytest
+
+import numpy as np
+from numpy.testing import assert_allclose, assert_equal, suppress_warnings
+from scipy import stats
+from scipy.stats import norm  # type: ignore[attr-defined]
+from scipy.stats._axis_nan_policy import _masked_arrays_2_sentinel_arrays
+from scipy._lib._util import AxisError
+
+
+def unpack_ttest_result(res):
+    low, high = res.confidence_interval()
+    return (res.statistic, res.pvalue, res.df, res._standard_error,
+            res._estimate, low, high)
+
+
+def _get_ttest_ci(ttest):
+    # get a function that returns the CI bounds of provided `ttest`
+    def ttest_ci(*args, **kwargs):
+        res = ttest(*args, **kwargs)
+        return res.confidence_interval()
+    return ttest_ci
+
+
+axis_nan_policy_cases = [
+    # function, args, kwds, number of samples, number of outputs,
+    # ... paired, unpacker function
+    # args, kwds typically aren't needed; just showing that they work
+    (stats.kruskal, tuple(), dict(), 3, 2, False, None),  # 4 samples is slow
+    (stats.ranksums, ('less',), dict(), 2, 2, False, None),
+    (stats.mannwhitneyu, tuple(), {'method': 'asymptotic'}, 2, 2, False, None),
+    (stats.wilcoxon, ('pratt',), {'mode': 'auto'}, 2, 2, True,
+     lambda res: (res.statistic, res.pvalue)),
+    (stats.wilcoxon, tuple(), dict(), 1, 2, True,
+     lambda res: (res.statistic, res.pvalue)),
+    (stats.wilcoxon, tuple(), {'mode': 'approx'}, 1, 3, True,
+     lambda res: (res.statistic, res.pvalue, res.zstatistic)),
+    (stats.gmean, tuple(), dict(), 1, 1, False, lambda x: (x,)),
+    (stats.hmean, tuple(), dict(), 1, 1, False, lambda x: (x,)),
+    (stats.pmean, (1.42,), dict(), 1, 1, False, lambda x: (x,)),
+    (stats.sem, tuple(), dict(), 1, 1, False, lambda x: (x,)),
+    (stats.iqr, tuple(), dict(), 1, 1, False, lambda x: (x,)),
+    (stats.kurtosis, tuple(), dict(), 1, 1, False, lambda x: (x,)),
+    (stats.skew, tuple(), dict(), 1, 1, False, lambda x: (x,)),
+    (stats.kstat, tuple(), dict(), 1, 1, False, lambda x: (x,)),
+    (stats.kstatvar, tuple(), dict(), 1, 1, False, lambda x: (x,)),
+    (stats.moment, tuple(), dict(), 1, 1, False, lambda x: (x,)),
+    (stats.moment, tuple(), dict(order=[1, 2]), 1, 2, False, None),
+    (stats.jarque_bera, tuple(), dict(), 1, 2, False, None),
+    (stats.ttest_1samp, (np.array([0]),), dict(), 1, 7, False,
+     unpack_ttest_result),
+    (stats.ttest_rel, tuple(), dict(), 2, 7, True, unpack_ttest_result),
+    (stats.ttest_ind, tuple(), dict(), 2, 7, False, unpack_ttest_result),
+    (_get_ttest_ci(stats.ttest_1samp), (0,), dict(), 1, 2, False, None),
+    (_get_ttest_ci(stats.ttest_rel), tuple(), dict(), 2, 2, True, None),
+    (_get_ttest_ci(stats.ttest_ind), tuple(), dict(), 2, 2, False, None),
+    (stats.mode, tuple(), dict(), 1, 2, True, lambda x: (x.mode, x.count)),
+    (stats.differential_entropy, tuple(), dict(), 1, 1, False, lambda x: (x,)),
+    (stats.variation, tuple(), dict(), 1, 1, False, lambda x: (x,)),
+    (stats.friedmanchisquare, tuple(), dict(), 3, 2, True, None),
+    (stats.brunnermunzel, tuple(), dict(), 2, 2, False, None),
+    (stats.mood, tuple(), {}, 2, 2, False, None),
+    (stats.shapiro, tuple(), {}, 1, 2, False, None),
+    (stats.ks_1samp, (norm().cdf,), dict(), 1, 4, False,
+     lambda res: (*res, res.statistic_location, res.statistic_sign)),
+    (stats.ks_2samp, tuple(), dict(), 2, 4, False,
+     lambda res: (*res, res.statistic_location, res.statistic_sign)),
+    (stats.kstest, (norm().cdf,), dict(), 1, 4, False,
+     lambda res: (*res, res.statistic_location, res.statistic_sign)),
+    (stats.kstest, tuple(), dict(), 2, 4, False,
+     lambda res: (*res, res.statistic_location, res.statistic_sign)),
+    (stats.levene, tuple(), {}, 2, 2, False, None),
+    (stats.fligner, tuple(), {'center': 'trimmed', 'proportiontocut': 0.01},
+     2, 2, False, None),
+    (stats.ansari, tuple(), {}, 2, 2, False, None),
+    (stats.entropy, tuple(), dict(), 1, 1, False, lambda x: (x,)),
+    (stats.entropy, tuple(), dict(), 2, 1, True, lambda x: (x,)),
+    (stats.skewtest, tuple(), dict(), 1, 2, False, None),
+    (stats.kurtosistest, tuple(), dict(), 1, 2, False, None),
+    (stats.normaltest, tuple(), dict(), 1, 2, False, None),
+    (stats.cramervonmises, ("norm",), dict(), 1, 2, False,
+     lambda res: (res.statistic, res.pvalue)),
+    (stats.cramervonmises_2samp, tuple(), dict(), 2, 2, False,
+     lambda res: (res.statistic, res.pvalue)),
+    (stats.epps_singleton_2samp, tuple(), dict(), 2, 2, False, None),
+    (stats.bartlett, tuple(), {}, 2, 2, False, None),
+    (stats.tmean, tuple(), {}, 1, 1, False, lambda x: (x,)),
+    (stats.tvar, tuple(), {}, 1, 1, False, lambda x: (x,)),
+    (stats.tmin, tuple(), {}, 1, 1, False, lambda x: (x,)),
+    (stats.tmax, tuple(), {}, 1, 1, False, lambda x: (x,)),
+    (stats.tstd, tuple(), {}, 1, 1, False, lambda x: (x,)),
+    (stats.tsem, tuple(), {}, 1, 1, False, lambda x: (x,)),
+    (stats.circmean, tuple(), dict(), 1, 1, False, lambda x: (x,)),
+    (stats.circvar, tuple(), dict(), 1, 1, False, lambda x: (x,)),
+    (stats.circstd, tuple(), dict(), 1, 1, False, lambda x: (x,)),
+    (stats.f_oneway, tuple(), {}, 2, 2, False, None),
+    (stats.alexandergovern, tuple(), {}, 2, 2, False,
+     lambda res: (res.statistic, res.pvalue)),
+    (stats.combine_pvalues, tuple(), {}, 1, 2, False, None),
+]
+
+# If the message is one of those expected, put nans in
+# appropriate places of `statistics` and `pvalues`
+too_small_messages = {"The input contains nan",  # for nan_policy="raise"
+                      "Degrees of freedom <= 0 for slice",
+                      "x and y should have at least 5 elements",
+                      "Data must be at least length 3",
+                      "The sample must contain at least two",
+                      "x and y must contain at least two",
+                      "division by zero",
+                      "Mean of empty slice",
+                      "Data passed to ks_2samp must not be empty",
+                      "Not enough test observations",
+                      "Not enough other observations",
+                      "Not enough observations.",
+                      "At least one observation is required",
+                      "zero-size array to reduction operation maximum",
+                      "`x` and `y` must be of nonzero size.",
+                      "The exact distribution of the Wilcoxon test",
+                      "Data input must not be empty",
+                      "Window length (0) must be positive and less",
+                      "Window length (1) must be positive and less",
+                      "Window length (2) must be positive and less",
+                      "skewtest is not valid with less than",
+                      "kurtosistest requires at least 5",
+                      "attempt to get argmax of an empty sequence",
+                      "No array values within given limits",
+                      "Input sample size must be greater than one.",}
+
+# If the message is one of these, results of the function may be inaccurate,
+# but NaNs are not to be placed
+inaccuracy_messages = {"Precision loss occurred in moment calculation",
+                       "Sample size too small for normal approximation."}
+
+# For some functions, nan_policy='propagate' should not just return NaNs
+override_propagate_funcs = {stats.mode}
+
+# For some functions, empty arrays produce non-NaN results
+empty_special_case_funcs = {stats.entropy}
+
+def _mixed_data_generator(n_samples, n_repetitions, axis, rng,
+                          paired=False):
+    # generate random samples to check the response of hypothesis tests to
+    # samples with different (but broadcastable) shapes and various
+    # nan patterns (e.g. all nans, some nans, no nans) along axis-slices
+
+    data = []
+    for i in range(n_samples):
+        n_patterns = 6  # number of distinct nan patterns
+        n_obs = 20 if paired else 20 + i  # observations per axis-slice
+        x = np.ones((n_repetitions, n_patterns, n_obs)) * np.nan
+
+        for j in range(n_repetitions):
+            samples = x[j, :, :]
+
+            # case 0: axis-slice with all nans (0 reals)
+            # cases 1-3: axis-slice with 1-3 reals (the rest nans)
+            # case 4: axis-slice with mostly (all but two) reals
+            # case 5: axis slice with all reals
+            for k, n_reals in enumerate([0, 1, 2, 3, n_obs-2, n_obs]):
+                # for cases 1-3, need paired nansw  to be in the same place
+                indices = rng.permutation(n_obs)[:n_reals]
+                samples[k, indices] = rng.random(size=n_reals)
+
+            # permute the axis-slices just to show that order doesn't matter
+            samples[:] = rng.permutation(samples, axis=0)
+
+        # For multi-sample tests, we want to test broadcasting and check
+        # that nan policy works correctly for each nan pattern for each input.
+        # This takes care of both simultaneously.
+        new_shape = [n_repetitions] + [1]*n_samples + [n_obs]
+        new_shape[1 + i] = 6
+        x = x.reshape(new_shape)
+
+        x = np.moveaxis(x, -1, axis)
+        data.append(x)
+    return data
+
+
+def _homogeneous_data_generator(n_samples, n_repetitions, axis, rng,
+                                paired=False, all_nans=True):
+    # generate random samples to check the response of hypothesis tests to
+    # samples with different (but broadcastable) shapes and homogeneous
+    # data (all nans or all finite)
+    data = []
+    for i in range(n_samples):
+        n_obs = 20 if paired else 20 + i  # observations per axis-slice
+        shape = [n_repetitions] + [1]*n_samples + [n_obs]
+        shape[1 + i] = 2
+        x = np.ones(shape) * np.nan if all_nans else rng.random(shape)
+        x = np.moveaxis(x, -1, axis)
+        data.append(x)
+    return data
+
+
+def nan_policy_1d(hypotest, data1d, unpacker, *args, n_outputs=2,
+                  nan_policy='raise', paired=False, _no_deco=True, **kwds):
+    # Reference implementation for how `nan_policy` should work for 1d samples
+
+    if nan_policy == 'raise':
+        for sample in data1d:
+            if np.any(np.isnan(sample)):
+                raise ValueError("The input contains nan values")
+
+    elif (nan_policy == 'propagate'
+          and hypotest not in override_propagate_funcs):
+        # For all hypothesis tests tested, returning nans is the right thing.
+        # But many hypothesis tests don't propagate correctly (e.g. they treat
+        # np.nan the same as np.inf, which doesn't make sense when ranks are
+        # involved) so override that behavior here.
+        for sample in data1d:
+            if np.any(np.isnan(sample)):
+                return np.full(n_outputs, np.nan)
+
+    elif nan_policy == 'omit':
+        # manually omit nans (or pairs in which at least one element is nan)
+        if not paired:
+            data1d = [sample[~np.isnan(sample)] for sample in data1d]
+        else:
+            nan_mask = np.isnan(data1d[0])
+            for sample in data1d[1:]:
+                nan_mask = np.logical_or(nan_mask, np.isnan(sample))
+            data1d = [sample[~nan_mask] for sample in data1d]
+
+    return unpacker(hypotest(*data1d, *args, _no_deco=_no_deco, **kwds))
+
+
+@pytest.mark.filterwarnings('ignore::RuntimeWarning')
+@pytest.mark.filterwarnings('ignore::UserWarning')
+@pytest.mark.parametrize(("hypotest", "args", "kwds", "n_samples", "n_outputs",
+                          "paired", "unpacker"), axis_nan_policy_cases)
+@pytest.mark.parametrize(("nan_policy"), ("propagate", "omit", "raise"))
+@pytest.mark.parametrize(("axis"), (1,))
+@pytest.mark.parametrize(("data_generator"), ("mixed",))
+def test_axis_nan_policy_fast(hypotest, args, kwds, n_samples, n_outputs,
+                              paired, unpacker, nan_policy, axis,
+                              data_generator):
+    _axis_nan_policy_test(hypotest, args, kwds, n_samples, n_outputs, paired,
+                          unpacker, nan_policy, axis, data_generator)
+
+
+@pytest.mark.slow
+@pytest.mark.filterwarnings('ignore::RuntimeWarning')
+@pytest.mark.filterwarnings('ignore::UserWarning')
+@pytest.mark.parametrize(("hypotest", "args", "kwds", "n_samples", "n_outputs",
+                          "paired", "unpacker"), axis_nan_policy_cases)
+@pytest.mark.parametrize(("nan_policy"), ("propagate", "omit", "raise"))
+@pytest.mark.parametrize(("axis"), range(-3, 3))
+@pytest.mark.parametrize(("data_generator"),
+                         ("all_nans", "all_finite", "mixed"))
+def test_axis_nan_policy_full(hypotest, args, kwds, n_samples, n_outputs,
+                              paired, unpacker, nan_policy, axis,
+                              data_generator):
+    _axis_nan_policy_test(hypotest, args, kwds, n_samples, n_outputs, paired,
+                          unpacker, nan_policy, axis, data_generator)
+
+
+def _axis_nan_policy_test(hypotest, args, kwds, n_samples, n_outputs, paired,
+                          unpacker, nan_policy, axis, data_generator):
+    # Tests the 1D and vectorized behavior of hypothesis tests against a
+    # reference implementation (nan_policy_1d with np.ndenumerate)
+
+    # Some hypothesis tests return a non-iterable that needs an `unpacker` to
+    # extract the statistic and p-value. For those that don't:
+    if not unpacker:
+        def unpacker(res):
+            return res
+
+    rng = np.random.default_rng(0)
+
+    # Generate multi-dimensional test data with all important combinations
+    # of patterns of nans along `axis`
+    n_repetitions = 3  # number of repetitions of each pattern
+    data_gen_kwds = {'n_samples': n_samples, 'n_repetitions': n_repetitions,
+                     'axis': axis, 'rng': rng, 'paired': paired}
+    if data_generator == 'mixed':
+        inherent_size = 6  # number of distinct types of patterns
+        data = _mixed_data_generator(**data_gen_kwds)
+    elif data_generator == 'all_nans':
+        inherent_size = 2  # hard-coded in _homogeneous_data_generator
+        data_gen_kwds['all_nans'] = True
+        data = _homogeneous_data_generator(**data_gen_kwds)
+    elif data_generator == 'all_finite':
+        inherent_size = 2  # hard-coded in _homogeneous_data_generator
+        data_gen_kwds['all_nans'] = False
+        data = _homogeneous_data_generator(**data_gen_kwds)
+
+    output_shape = [n_repetitions] + [inherent_size]*n_samples
+
+    # To generate reference behavior to compare against, loop over the axis-
+    # slices in data. Make indexing easier by moving `axis` to the end and
+    # broadcasting all samples to the same shape.
+    data_b = [np.moveaxis(sample, axis, -1) for sample in data]
+    data_b = [np.broadcast_to(sample, output_shape + [sample.shape[-1]])
+              for sample in data_b]
+    statistics = np.zeros(output_shape)
+    pvalues = np.zeros(output_shape)
+
+    for i, _ in np.ndenumerate(statistics):
+        data1d = [sample[i] for sample in data_b]
+        with np.errstate(divide='ignore', invalid='ignore'):
+            try:
+                res1d = nan_policy_1d(hypotest, data1d, unpacker, *args,
+                                      n_outputs=n_outputs,
+                                      nan_policy=nan_policy,
+                                      paired=paired, _no_deco=True, **kwds)
+
+                # Eventually we'll check the results of a single, vectorized
+                # call of `hypotest` against the arrays `statistics` and
+                # `pvalues` populated using the reference `nan_policy_1d`.
+                # But while we're at it, check the results of a 1D call to
+                # `hypotest` against the reference `nan_policy_1d`.
+                res1db = unpacker(hypotest(*data1d, *args,
+                                           nan_policy=nan_policy, **kwds))
+                assert_equal(res1db[0], res1d[0])
+                if len(res1db) == 2:
+                    assert_equal(res1db[1], res1d[1])
+
+            # When there is not enough data in 1D samples, many existing
+            # hypothesis tests raise errors instead of returning nans .
+            # For vectorized calls, we put nans in the corresponding elements
+            # of the output.
+            except (RuntimeWarning, UserWarning, ValueError,
+                    ZeroDivisionError) as e:
+
+                # whatever it is, make sure same error is raised by both
+                # `nan_policy_1d` and `hypotest`
+                with pytest.raises(type(e), match=re.escape(str(e))):
+                    nan_policy_1d(hypotest, data1d, unpacker, *args,
+                                  n_outputs=n_outputs, nan_policy=nan_policy,
+                                  paired=paired, _no_deco=True, **kwds)
+                with pytest.raises(type(e), match=re.escape(str(e))):
+                    hypotest(*data1d, *args, nan_policy=nan_policy, **kwds)
+
+                if any([str(e).startswith(message)
+                        for message in too_small_messages]):
+                    res1d = np.full(n_outputs, np.nan)
+                elif any([str(e).startswith(message)
+                          for message in inaccuracy_messages]):
+                    with suppress_warnings() as sup:
+                        sup.filter(RuntimeWarning)
+                        sup.filter(UserWarning)
+                        res1d = nan_policy_1d(hypotest, data1d, unpacker,
+                                              *args, n_outputs=n_outputs,
+                                              nan_policy=nan_policy,
+                                              paired=paired, _no_deco=True,
+                                              **kwds)
+                else:
+                    raise e
+        statistics[i] = res1d[0]
+        if len(res1d) == 2:
+            pvalues[i] = res1d[1]
+
+    # Perform a vectorized call to the hypothesis test.
+    # If `nan_policy == 'raise'`, check that it raises the appropriate error.
+    # If not, compare against the output against `statistics` and `pvalues`
+    if nan_policy == 'raise' and not data_generator == "all_finite":
+        message = 'The input contains nan values'
+        with pytest.raises(ValueError, match=message):
+            hypotest(*data, axis=axis, nan_policy=nan_policy, *args, **kwds)
+
+    else:
+        with suppress_warnings() as sup, \
+             np.errstate(divide='ignore', invalid='ignore'):
+            sup.filter(RuntimeWarning, "Precision loss occurred in moment")
+            sup.filter(UserWarning, "Sample size too small for normal "
+                                    "approximation.")
+            res = unpacker(hypotest(*data, axis=axis, nan_policy=nan_policy,
+                                    *args, **kwds))
+        assert_allclose(res[0], statistics, rtol=1e-15)
+        assert_equal(res[0].dtype, statistics.dtype)
+
+        if len(res) == 2:
+            assert_allclose(res[1], pvalues, rtol=1e-15)
+            assert_equal(res[1].dtype, pvalues.dtype)
+
+
+@pytest.mark.filterwarnings('ignore::RuntimeWarning')
+@pytest.mark.parametrize(("hypotest", "args", "kwds", "n_samples", "n_outputs",
+                          "paired", "unpacker"), axis_nan_policy_cases)
+@pytest.mark.parametrize(("nan_policy"), ("propagate", "omit", "raise"))
+@pytest.mark.parametrize(("data_generator"),
+                         ("all_nans", "all_finite", "mixed", "empty"))
+def test_axis_nan_policy_axis_is_None(hypotest, args, kwds, n_samples,
+                                      n_outputs, paired, unpacker, nan_policy,
+                                      data_generator):
+    # check for correct behavior when `axis=None`
+
+    if not unpacker:
+        def unpacker(res):
+            return res
+
+    rng = np.random.default_rng(0)
+
+    if data_generator == "empty":
+        data = [rng.random((2, 0)) for i in range(n_samples)]
+    else:
+        data = [rng.random((2, 20)) for i in range(n_samples)]
+
+    if data_generator == "mixed":
+        masks = [rng.random((2, 20)) > 0.9 for i in range(n_samples)]
+        for sample, mask in zip(data, masks):
+            sample[mask] = np.nan
+    elif data_generator == "all_nans":
+        data = [sample * np.nan for sample in data]
+
+    data_raveled = [sample.ravel() for sample in data]
+
+    if nan_policy == 'raise' and data_generator not in {"all_finite", "empty"}:
+        message = 'The input contains nan values'
+
+        # check for correct behavior whether or not data is 1d to begin with
+        with pytest.raises(ValueError, match=message):
+            hypotest(*data, axis=None, nan_policy=nan_policy,
+                     *args, **kwds)
+        with pytest.raises(ValueError, match=message):
+            hypotest(*data_raveled, axis=None, nan_policy=nan_policy,
+                     *args, **kwds)
+
+    else:
+        # behavior of reference implementation with 1d input, hypotest with 1d
+        # input, and hypotest with Nd input should match, whether that means
+        # that outputs are equal or they raise the same exception
+
+        ea_str, eb_str, ec_str = None, None, None
+        with np.errstate(divide='ignore', invalid='ignore'):
+            try:
+                res1da = nan_policy_1d(hypotest, data_raveled, unpacker, *args,
+                                       n_outputs=n_outputs,
+                                       nan_policy=nan_policy, paired=paired,
+                                       _no_deco=True, **kwds)
+            except (RuntimeWarning, ValueError, ZeroDivisionError) as ea:
+                ea_str = str(ea)
+
+            try:
+                res1db = unpacker(hypotest(*data_raveled, *args,
+                                           nan_policy=nan_policy, **kwds))
+            except (RuntimeWarning, ValueError, ZeroDivisionError) as eb:
+                eb_str = str(eb)
+
+            try:
+                res1dc = unpacker(hypotest(*data, *args, axis=None,
+                                           nan_policy=nan_policy, **kwds))
+            except (RuntimeWarning, ValueError, ZeroDivisionError) as ec:
+                ec_str = str(ec)
+
+            if ea_str or eb_str or ec_str:
+                assert any([str(ea_str).startswith(message)
+                            for message in too_small_messages])
+                assert ea_str == eb_str == ec_str
+            else:
+                assert_equal(res1db, res1da)
+                assert_equal(res1dc, res1da)
+                for item in list(res1da) + list(res1db) + list(res1dc):
+                    # Most functions naturally return NumPy numbers, which
+                    # are drop-in replacements for the Python versions but with
+                    # desirable attributes. Make sure this is consistent.
+                    assert np.issubdtype(item.dtype, np.number)
+
+# Test keepdims for:
+#     - single-output and multi-output functions (gmean and mannwhitneyu)
+#     - Axis negative, positive, None, and tuple
+#     - 1D with no NaNs
+#     - 1D with NaN propagation
+#     - Zero-sized output
+@pytest.mark.parametrize("nan_policy", ("omit", "propagate"))
+@pytest.mark.parametrize(
+    ("hypotest", "args", "kwds", "n_samples", "unpacker"),
+    ((stats.gmean, tuple(), dict(), 1, lambda x: (x,)),
+     (stats.mannwhitneyu, tuple(), {'method': 'asymptotic'}, 2, None))
+)
+@pytest.mark.parametrize(
+    ("sample_shape", "axis_cases"),
+    (((2, 3, 3, 4), (None, 0, -1, (0, 2), (1, -1), (3, 1, 2, 0))),
+     ((10, ), (0, -1)),
+     ((20, 0), (0, 1)))
+)
+def test_keepdims(hypotest, args, kwds, n_samples, unpacker,
+                  sample_shape, axis_cases, nan_policy):
+    # test if keepdims parameter works correctly
+    if not unpacker:
+        def unpacker(res):
+            return res
+    rng = np.random.default_rng(0)
+    data = [rng.random(sample_shape) for _ in range(n_samples)]
+    nan_data = [sample.copy() for sample in data]
+    nan_mask = [rng.random(sample_shape) < 0.2 for _ in range(n_samples)]
+    for sample, mask in zip(nan_data, nan_mask):
+        sample[mask] = np.nan
+    for axis in axis_cases:
+        expected_shape = list(sample_shape)
+        if axis is None:
+            expected_shape = np.ones(len(sample_shape))
+        else:
+            if isinstance(axis, int):
+                expected_shape[axis] = 1
+            else:
+                for ax in axis:
+                    expected_shape[ax] = 1
+        expected_shape = tuple(expected_shape)
+        res = unpacker(hypotest(*data, *args, axis=axis, keepdims=True,
+                                **kwds))
+        res_base = unpacker(hypotest(*data, *args, axis=axis, keepdims=False,
+                                     **kwds))
+        nan_res = unpacker(hypotest(*nan_data, *args, axis=axis,
+                                    keepdims=True, nan_policy=nan_policy,
+                                    **kwds))
+        nan_res_base = unpacker(hypotest(*nan_data, *args, axis=axis,
+                                         keepdims=False,
+                                         nan_policy=nan_policy, **kwds))
+        for r, r_base, rn, rn_base in zip(res, res_base, nan_res,
+                                          nan_res_base):
+            assert r.shape == expected_shape
+            r = np.squeeze(r, axis=axis)
+            assert_equal(r, r_base)
+            assert rn.shape == expected_shape
+            rn = np.squeeze(rn, axis=axis)
+            assert_equal(rn, rn_base)
+
+
+@pytest.mark.parametrize(("fun", "nsamp"),
+                         [(stats.kstat, 1),
+                          (stats.kstatvar, 1)])
+def test_hypotest_back_compat_no_axis(fun, nsamp):
+    m, n = 8, 9
+
+    rng = np.random.default_rng(0)
+    x = rng.random((nsamp, m, n))
+    res = fun(*x)
+    res2 = fun(*x, _no_deco=True)
+    res3 = fun([xi.ravel() for xi in x])
+    assert_equal(res, res2)
+    assert_equal(res, res3)
+
+
+@pytest.mark.parametrize(("axis"), (0, 1, 2))
+def test_axis_nan_policy_decorated_positional_axis(axis):
+    # Test for correct behavior of function decorated with
+    # _axis_nan_policy_decorator whether `axis` is provided as positional or
+    # keyword argument
+
+    shape = (8, 9, 10)
+    rng = np.random.default_rng(0)
+    x = rng.random(shape)
+    y = rng.random(shape)
+    res1 = stats.mannwhitneyu(x, y, True, 'two-sided', axis)
+    res2 = stats.mannwhitneyu(x, y, True, 'two-sided', axis=axis)
+    assert_equal(res1, res2)
+
+    message = "mannwhitneyu() got multiple values for argument 'axis'"
+    with pytest.raises(TypeError, match=re.escape(message)):
+        stats.mannwhitneyu(x, y, True, 'two-sided', axis, axis=axis)
+
+
+def test_axis_nan_policy_decorated_positional_args():
+    # Test for correct behavior of function decorated with
+    # _axis_nan_policy_decorator when function accepts *args
+
+    shape = (3, 8, 9, 10)
+    rng = np.random.default_rng(0)
+    x = rng.random(shape)
+    x[0, 0, 0, 0] = np.nan
+    stats.kruskal(*x)
+
+    message = "kruskal() got an unexpected keyword argument 'samples'"
+    with pytest.raises(TypeError, match=re.escape(message)):
+        stats.kruskal(samples=x)
+
+    with pytest.raises(TypeError, match=re.escape(message)):
+        stats.kruskal(*x, samples=x)
+
+
+def test_axis_nan_policy_decorated_keyword_samples():
+    # Test for correct behavior of function decorated with
+    # _axis_nan_policy_decorator whether samples are provided as positional or
+    # keyword arguments
+
+    shape = (2, 8, 9, 10)
+    rng = np.random.default_rng(0)
+    x = rng.random(shape)
+    x[0, 0, 0, 0] = np.nan
+    res1 = stats.mannwhitneyu(*x)
+    res2 = stats.mannwhitneyu(x=x[0], y=x[1])
+    assert_equal(res1, res2)
+
+    message = "mannwhitneyu() got multiple values for argument"
+    with pytest.raises(TypeError, match=re.escape(message)):
+        stats.mannwhitneyu(*x, x=x[0], y=x[1])
+
+
+@pytest.mark.parametrize(("hypotest", "args", "kwds", "n_samples", "n_outputs",
+                          "paired", "unpacker"), axis_nan_policy_cases)
+def test_axis_nan_policy_decorated_pickled(hypotest, args, kwds, n_samples,
+                                           n_outputs, paired, unpacker):
+    if "ttest_ci" in hypotest.__name__:
+        pytest.skip("Can't pickle functions defined within functions.")
+
+    rng = np.random.default_rng(0)
+
+    # Some hypothesis tests return a non-iterable that needs an `unpacker` to
+    # extract the statistic and p-value. For those that don't:
+    if not unpacker:
+        def unpacker(res):
+            return res
+
+    data = rng.uniform(size=(n_samples, 2, 30))
+    pickled_hypotest = pickle.dumps(hypotest)
+    unpickled_hypotest = pickle.loads(pickled_hypotest)
+    res1 = unpacker(hypotest(*data, *args, axis=-1, **kwds))
+    res2 = unpacker(unpickled_hypotest(*data, *args, axis=-1, **kwds))
+    assert_allclose(res1, res2, rtol=1e-12)
+
+
+def test_check_empty_inputs():
+    # Test that _check_empty_inputs is doing its job, at least for single-
+    # sample inputs. (Multi-sample functionality is tested below.)
+    # If the input sample is not empty, it should return None.
+    # If the input sample is empty, it should return an array of NaNs or an
+    # empty array of appropriate shape. np.mean is used as a reference for the
+    # output because, like the statistics calculated by these functions,
+    # it works along and "consumes" `axis` but preserves the other axes.
+    for i in range(5):
+        for combo in combinations_with_replacement([0, 1, 2], i):
+            for axis in range(len(combo)):
+                samples = (np.zeros(combo),)
+                output = stats._axis_nan_policy._check_empty_inputs(samples,
+                                                                    axis)
+                if output is not None:
+                    with np.testing.suppress_warnings() as sup:
+                        sup.filter(RuntimeWarning, "Mean of empty slice.")
+                        sup.filter(RuntimeWarning, "invalid value encountered")
+                        reference = samples[0].mean(axis=axis)
+                    np.testing.assert_equal(output, reference)
+
+
+def _check_arrays_broadcastable(arrays, axis):
+    # https://numpy.org/doc/stable/user/basics.broadcasting.html
+    # "When operating on two arrays, NumPy compares their shapes element-wise.
+    # It starts with the trailing (i.e. rightmost) dimensions and works its
+    # way left.
+    # Two dimensions are compatible when
+    # 1. they are equal, or
+    # 2. one of them is 1
+    # ...
+    # Arrays do not need to have the same number of dimensions."
+    # (Clarification: if the arrays are compatible according to the criteria
+    #  above and an array runs out of dimensions, it is still compatible.)
+    # Below, we follow the rules above except ignoring `axis`
+
+    n_dims = max([arr.ndim for arr in arrays])
+    if axis is not None:
+        # convert to negative axis
+        axis = (-n_dims + axis) if axis >= 0 else axis
+
+    for dim in range(1, n_dims+1):  # we'll index from -1 to -n_dims, inclusive
+        if -dim == axis:
+            continue  # ignore lengths along `axis`
+
+        dim_lengths = set()
+        for arr in arrays:
+            if dim <= arr.ndim and arr.shape[-dim] != 1:
+                dim_lengths.add(arr.shape[-dim])
+
+        if len(dim_lengths) > 1:
+            return False
+    return True
+
+
+@pytest.mark.slow
+@pytest.mark.parametrize(("hypotest", "args", "kwds", "n_samples", "n_outputs",
+                          "paired", "unpacker"), axis_nan_policy_cases)
+def test_empty(hypotest, args, kwds, n_samples, n_outputs, paired, unpacker):
+    # test for correct output shape when at least one input is empty
+
+    if hypotest in override_propagate_funcs:
+        reason = "Doesn't follow the usual pattern. Tested separately."
+        pytest.skip(reason=reason)
+
+    if unpacker is None:
+        unpacker = lambda res: (res[0], res[1])  # noqa: E731
+
+    def small_data_generator(n_samples, n_dims):
+
+        def small_sample_generator(n_dims):
+            # return all possible "small" arrays in up to n_dim dimensions
+            for i in n_dims:
+                # "small" means with size along dimension either 0 or 1
+                for combo in combinations_with_replacement([0, 1, 2], i):
+                    yield np.zeros(combo)
+
+        # yield all possible combinations of small samples
+        gens = [small_sample_generator(n_dims) for i in range(n_samples)]
+        yield from product(*gens)
+
+    n_dims = [2, 3]
+    for samples in small_data_generator(n_samples, n_dims):
+
+        # this test is only for arrays of zero size
+        if not any(sample.size == 0 for sample in samples):
+            continue
+
+        max_axis = max(sample.ndim for sample in samples)
+
+        # need to test for all valid values of `axis` parameter, too
+        for axis in range(-max_axis, max_axis):
+
+            try:
+                # After broadcasting, all arrays are the same shape, so
+                # the shape of the output should be the same as a single-
+                # sample statistic. Use np.mean as a reference.
+                concat = stats._stats_py._broadcast_concatenate(samples, axis)
+                with np.testing.suppress_warnings() as sup:
+                    sup.filter(RuntimeWarning, "Mean of empty slice.")
+                    sup.filter(RuntimeWarning, "invalid value encountered")
+                    expected = np.mean(concat, axis=axis) * np.nan
+
+                if hypotest in empty_special_case_funcs:
+                    empty_val = hypotest(*([[]]*len(samples)), *args, **kwds)
+                    mask = np.isnan(expected)
+                    expected[mask] = empty_val
+
+                with np.testing.suppress_warnings() as sup:
+                    # generated by f_oneway for too_small inputs
+                    sup.filter(stats.DegenerateDataWarning)
+                    res = hypotest(*samples, *args, axis=axis, **kwds)
+                res = unpacker(res)
+
+                for i in range(n_outputs):
+                    assert_equal(res[i], expected)
+
+            except ValueError:
+                # confirm that the arrays truly are not broadcastable
+                assert not _check_arrays_broadcastable(samples,
+                                                       None if paired else axis)
+
+                # confirm that _both_ `_broadcast_concatenate` and `hypotest`
+                # produce this information.
+                message = "Array shapes are incompatible for broadcasting."
+                with pytest.raises(ValueError, match=message):
+                    stats._stats_py._broadcast_concatenate(samples, axis, paired)
+                with pytest.raises(ValueError, match=message):
+                    hypotest(*samples, *args, axis=axis, **kwds)
+
+
+def test_masked_array_2_sentinel_array():
+    # prepare arrays
+    np.random.seed(0)
+    A = np.random.rand(10, 11, 12)
+    B = np.random.rand(12)
+    mask = A < 0.5
+    A = np.ma.masked_array(A, mask)
+
+    # set arbitrary elements to special values
+    # (these values might have been considered for use as sentinel values)
+    max_float = np.finfo(np.float64).max
+    max_float2 = np.nextafter(max_float, -np.inf)
+    max_float3 = np.nextafter(max_float2, -np.inf)
+    A[3, 4, 1] = np.nan
+    A[4, 5, 2] = np.inf
+    A[5, 6, 3] = max_float
+    B[8] = np.nan
+    B[7] = np.inf
+    B[6] = max_float2
+
+    # convert masked A to array with sentinel value, don't modify B
+    out_arrays, sentinel = _masked_arrays_2_sentinel_arrays([A, B])
+    A_out, B_out = out_arrays
+
+    # check that good sentinel value was chosen (according to intended logic)
+    assert (sentinel != max_float) and (sentinel != max_float2)
+    assert sentinel == max_float3
+
+    # check that output arrays are as intended
+    A_reference = A.data
+    A_reference[A.mask] = sentinel
+    np.testing.assert_array_equal(A_out, A_reference)
+    assert B_out is B
+
+
+def test_masked_dtype():
+    # When _masked_arrays_2_sentinel_arrays was first added, it always
+    # upcast the arrays to np.float64. After gh16662, check expected promotion
+    # and that the expected sentinel is found.
+
+    # these are important because the max of the promoted dtype is the first
+    # candidate to be the sentinel value
+    max16 = np.iinfo(np.int16).max
+    max128c = np.finfo(np.complex128).max
+
+    # a is a regular array, b has masked elements, and c has no masked elements
+    a = np.array([1, 2, max16], dtype=np.int16)
+    b = np.ma.array([1, 2, 1], dtype=np.int8, mask=[0, 1, 0])
+    c = np.ma.array([1, 2, 1], dtype=np.complex128, mask=[0, 0, 0])
+
+    # check integer masked -> sentinel conversion
+    out_arrays, sentinel = _masked_arrays_2_sentinel_arrays([a, b])
+    a_out, b_out = out_arrays
+    assert sentinel == max16-1  # not max16 because max16 was in the data
+    assert b_out.dtype == np.int16  # check expected promotion
+    assert_allclose(b_out, [b[0], sentinel, b[-1]])  # check sentinel placement
+    assert a_out is a  # not a masked array, so left untouched
+    assert not isinstance(b_out, np.ma.MaskedArray)  # b became regular array
+
+    # similarly with complex
+    out_arrays, sentinel = _masked_arrays_2_sentinel_arrays([b, c])
+    b_out, c_out = out_arrays
+    assert sentinel == max128c  # max128c was not in the data
+    assert b_out.dtype == np.complex128  # b got promoted
+    assert_allclose(b_out, [b[0], sentinel, b[-1]])  # check sentinel placement
+    assert not isinstance(b_out, np.ma.MaskedArray)  # b became regular array
+    assert not isinstance(c_out, np.ma.MaskedArray)  # c became regular array
+
+    # Also, check edge case when a sentinel value cannot be found in the data
+    min8, max8 = np.iinfo(np.int8).min, np.iinfo(np.int8).max
+    a = np.arange(min8, max8+1, dtype=np.int8)  # use all possible values
+    mask1 = np.zeros_like(a, dtype=bool)
+    mask0 = np.zeros_like(a, dtype=bool)
+
+    # a masked value can be used as the sentinel
+    mask1[1] = True
+    a1 = np.ma.array(a, mask=mask1)
+    out_arrays, sentinel = _masked_arrays_2_sentinel_arrays([a1])
+    assert sentinel == min8+1
+
+    # unless it's the smallest possible; skipped for simiplicity (see code)
+    mask0[0] = True
+    a0 = np.ma.array(a, mask=mask0)
+    message = "This function replaces masked elements with sentinel..."
+    with pytest.raises(ValueError, match=message):
+        _masked_arrays_2_sentinel_arrays([a0])
+
+    # test that dtype is preserved in functions
+    a = np.ma.array([1, 2, 3], mask=[0, 1, 0], dtype=np.float32)
+    assert stats.gmean(a).dtype == np.float32
+
+
+def test_masked_stat_1d():
+    # basic test of _axis_nan_policy_factory with 1D masked sample
+    males = [19, 22, 16, 29, 24]
+    females = [20, 11, 17, 12]
+    res = stats.mannwhitneyu(males, females)
+
+    # same result when extra nan is omitted
+    females2 = [20, 11, 17, np.nan, 12]
+    res2 = stats.mannwhitneyu(males, females2, nan_policy='omit')
+    np.testing.assert_array_equal(res2, res)
+
+    # same result when extra element is masked
+    females3 = [20, 11, 17, 1000, 12]
+    mask3 = [False, False, False, True, False]
+    females3 = np.ma.masked_array(females3, mask=mask3)
+    res3 = stats.mannwhitneyu(males, females3)
+    np.testing.assert_array_equal(res3, res)
+
+    # same result when extra nan is omitted and additional element is masked
+    females4 = [20, 11, 17, np.nan, 1000, 12]
+    mask4 = [False, False, False, False, True, False]
+    females4 = np.ma.masked_array(females4, mask=mask4)
+    res4 = stats.mannwhitneyu(males, females4, nan_policy='omit')
+    np.testing.assert_array_equal(res4, res)
+
+    # same result when extra elements, including nan, are masked
+    females5 = [20, 11, 17, np.nan, 1000, 12]
+    mask5 = [False, False, False, True, True, False]
+    females5 = np.ma.masked_array(females5, mask=mask5)
+    res5 = stats.mannwhitneyu(males, females5, nan_policy='propagate')
+    res6 = stats.mannwhitneyu(males, females5, nan_policy='raise')
+    np.testing.assert_array_equal(res5, res)
+    np.testing.assert_array_equal(res6, res)
+
+
+@pytest.mark.parametrize(("axis"), range(-3, 3))
+def test_masked_stat_3d(axis):
+    # basic test of _axis_nan_policy_factory with 3D masked sample
+    np.random.seed(0)
+    a = np.random.rand(3, 4, 5)
+    b = np.random.rand(4, 5)
+    c = np.random.rand(4, 1)
+
+    mask_a = a < 0.1
+    mask_c = [False, False, False, True]
+    a_masked = np.ma.masked_array(a, mask=mask_a)
+    c_masked = np.ma.masked_array(c, mask=mask_c)
+
+    a_nans = a.copy()
+    a_nans[mask_a] = np.nan
+    c_nans = c.copy()
+    c_nans[mask_c] = np.nan
+
+    res = stats.kruskal(a_nans, b, c_nans, nan_policy='omit', axis=axis)
+    res2 = stats.kruskal(a_masked, b, c_masked, axis=axis)
+    np.testing.assert_array_equal(res, res2)
+
+
+def test_mixed_mask_nan_1():
+    # targeted test of _axis_nan_policy_factory with 2D masked sample:
+    # omitting samples with masks and nan_policy='omit' are equivalent
+    # also checks paired-sample sentinel value removal
+    m, n = 3, 20
+    axis = -1
+
+    np.random.seed(0)
+    a = np.random.rand(m, n)
+    b = np.random.rand(m, n)
+    mask_a1 = np.random.rand(m, n) < 0.2
+    mask_a2 = np.random.rand(m, n) < 0.1
+    mask_b1 = np.random.rand(m, n) < 0.15
+    mask_b2 = np.random.rand(m, n) < 0.15
+    mask_a1[2, :] = True
+
+    a_nans = a.copy()
+    b_nans = b.copy()
+    a_nans[mask_a1 | mask_a2] = np.nan
+    b_nans[mask_b1 | mask_b2] = np.nan
+
+    a_masked1 = np.ma.masked_array(a, mask=mask_a1)
+    b_masked1 = np.ma.masked_array(b, mask=mask_b1)
+    a_masked1[mask_a2] = np.nan
+    b_masked1[mask_b2] = np.nan
+
+    a_masked2 = np.ma.masked_array(a, mask=mask_a2)
+    b_masked2 = np.ma.masked_array(b, mask=mask_b2)
+    a_masked2[mask_a1] = np.nan
+    b_masked2[mask_b1] = np.nan
+
+    a_masked3 = np.ma.masked_array(a, mask=(mask_a1 | mask_a2))
+    b_masked3 = np.ma.masked_array(b, mask=(mask_b1 | mask_b2))
+
+    res = stats.wilcoxon(a_nans, b_nans, nan_policy='omit', axis=axis)
+    res1 = stats.wilcoxon(a_masked1, b_masked1, nan_policy='omit', axis=axis)
+    res2 = stats.wilcoxon(a_masked2, b_masked2, nan_policy='omit', axis=axis)
+    res3 = stats.wilcoxon(a_masked3, b_masked3, nan_policy='raise', axis=axis)
+    res4 = stats.wilcoxon(a_masked3, b_masked3,
+                          nan_policy='propagate', axis=axis)
+
+    np.testing.assert_array_equal(res1, res)
+    np.testing.assert_array_equal(res2, res)
+    np.testing.assert_array_equal(res3, res)
+    np.testing.assert_array_equal(res4, res)
+
+
+def test_mixed_mask_nan_2():
+    # targeted test of _axis_nan_policy_factory with 2D masked sample:
+    # check for expected interaction between masks and nans
+
+    # Cases here are
+    # [mixed nan/mask, all nans, all masked,
+    # unmasked nan, masked nan, unmasked non-nan]
+    a = [[1, np.nan, 2], [np.nan, np.nan, np.nan], [1, 2, 3],
+         [1, np.nan, 3], [1, np.nan, 3], [1, 2, 3]]
+    mask = [[1, 0, 1], [0, 0, 0], [1, 1, 1],
+            [0, 0, 0], [0, 1, 0], [0, 0, 0]]
+    a_masked = np.ma.masked_array(a, mask=mask)
+    b = [[4, 5, 6]]
+    ref1 = stats.ranksums([1, 3], [4, 5, 6])
+    ref2 = stats.ranksums([1, 2, 3], [4, 5, 6])
+
+    # nan_policy = 'omit'
+    # all elements are removed from first three rows
+    # middle element is removed from fourth and fifth rows
+    # no elements removed from last row
+    res = stats.ranksums(a_masked, b, nan_policy='omit', axis=-1)
+    stat_ref = [np.nan, np.nan, np.nan,
+                ref1.statistic, ref1.statistic, ref2.statistic]
+    p_ref = [np.nan, np.nan, np.nan,
+             ref1.pvalue, ref1.pvalue, ref2.pvalue]
+    np.testing.assert_array_equal(res.statistic, stat_ref)
+    np.testing.assert_array_equal(res.pvalue, p_ref)
+
+    # nan_policy = 'propagate'
+    # nans propagate in first, second, and fourth row
+    # all elements are removed by mask from third row
+    # middle element is removed from fifth row
+    # no elements removed from last row
+    res = stats.ranksums(a_masked, b, nan_policy='propagate', axis=-1)
+    stat_ref = [np.nan, np.nan, np.nan,
+                np.nan, ref1.statistic, ref2.statistic]
+    p_ref = [np.nan, np.nan, np.nan,
+             np.nan, ref1.pvalue, ref2.pvalue]
+    np.testing.assert_array_equal(res.statistic, stat_ref)
+    np.testing.assert_array_equal(res.pvalue, p_ref)
+
+
+def test_axis_None_vs_tuple():
+    # `axis` `None` should be equivalent to tuple with all axes
+    shape = (3, 8, 9, 10)
+    rng = np.random.default_rng(0)
+    x = rng.random(shape)
+    res = stats.kruskal(*x, axis=None)
+    res2 = stats.kruskal(*x, axis=(0, 1, 2))
+    np.testing.assert_array_equal(res, res2)
+
+
+def test_axis_None_vs_tuple_with_broadcasting():
+    # `axis` `None` should be equivalent to tuple with all axes,
+    # which should be equivalent to raveling the arrays before passing them
+    rng = np.random.default_rng(0)
+    x = rng.random((5, 1))
+    y = rng.random((1, 5))
+    x2, y2 = np.broadcast_arrays(x, y)
+
+    res0 = stats.mannwhitneyu(x.ravel(), y.ravel())
+    res1 = stats.mannwhitneyu(x, y, axis=None)
+    res2 = stats.mannwhitneyu(x, y, axis=(0, 1))
+    res3 = stats.mannwhitneyu(x2.ravel(), y2.ravel())
+
+    assert res1 == res0
+    assert res2 == res0
+    assert res3 != res0
+
+
+@pytest.mark.parametrize(("axis"),
+                         list(permutations(range(-3, 3), 2)) + [(-4, 1)])
+def test_other_axis_tuples(axis):
+    # Check that _axis_nan_policy_factory treats all `axis` tuples as expected
+    rng = np.random.default_rng(0)
+    shape_x = (4, 5, 6)
+    shape_y = (1, 6)
+    x = rng.random(shape_x)
+    y = rng.random(shape_y)
+    axis_original = axis
+
+    # convert axis elements to positive
+    axis = tuple([(i if i >= 0 else 3 + i) for i in axis])
+    axis = sorted(axis)
+
+    if len(set(axis)) != len(axis):
+        message = "`axis` must contain only distinct elements"
+        with pytest.raises(AxisError, match=re.escape(message)):
+            stats.mannwhitneyu(x, y, axis=axis_original)
+        return
+
+    if axis[0] < 0 or axis[-1] > 2:
+        message = "`axis` is out of bounds for array of dimension 3"
+        with pytest.raises(AxisError, match=re.escape(message)):
+            stats.mannwhitneyu(x, y, axis=axis_original)
+        return
+
+    res = stats.mannwhitneyu(x, y, axis=axis_original)
+
+    # reference behavior
+    not_axis = {0, 1, 2} - set(axis)  # which axis is not part of `axis`
+    not_axis = next(iter(not_axis))  # take it out of the set
+
+    x2 = x
+    shape_y_broadcasted = [1, 1, 6]
+    shape_y_broadcasted[not_axis] = shape_x[not_axis]
+    y2 = np.broadcast_to(y, shape_y_broadcasted)
+
+    m = x2.shape[not_axis]
+    x2 = np.moveaxis(x2, axis, (1, 2))
+    y2 = np.moveaxis(y2, axis, (1, 2))
+    x2 = np.reshape(x2, (m, -1))
+    y2 = np.reshape(y2, (m, -1))
+    res2 = stats.mannwhitneyu(x2, y2, axis=1)
+
+    np.testing.assert_array_equal(res, res2)
+
+
+@pytest.mark.parametrize(
+    ("weighted_fun_name, unpacker"),
+    [
+        ("gmean", lambda x: x),
+        ("hmean", lambda x: x),
+        ("pmean", lambda x: x),
+        ("combine_pvalues", lambda x: (x.pvalue, x.statistic)),
+    ],
+)
+def test_mean_mixed_mask_nan_weights(weighted_fun_name, unpacker):
+    # targeted test of _axis_nan_policy_factory with 2D masked sample:
+    # omitting samples with masks and nan_policy='omit' are equivalent
+    # also checks paired-sample sentinel value removal
+
+    if weighted_fun_name == 'pmean':
+        def weighted_fun(a, **kwargs):
+            return stats.pmean(a, p=0.42, **kwargs)
+    else:
+        weighted_fun = getattr(stats, weighted_fun_name)
+        
+    def func(*args, **kwargs):
+        return unpacker(weighted_fun(*args, **kwargs))
+
+    m, n = 3, 20
+    axis = -1
+
+    rng = np.random.default_rng(6541968121)
+    a = rng.uniform(size=(m, n))
+    b = rng.uniform(size=(m, n))
+    mask_a1 = rng.uniform(size=(m, n)) < 0.2
+    mask_a2 = rng.uniform(size=(m, n)) < 0.1
+    mask_b1 = rng.uniform(size=(m, n)) < 0.15
+    mask_b2 = rng.uniform(size=(m, n)) < 0.15
+    mask_a1[2, :] = True
+
+    a_nans = a.copy()
+    b_nans = b.copy()
+    a_nans[mask_a1 | mask_a2] = np.nan
+    b_nans[mask_b1 | mask_b2] = np.nan
+
+    a_masked1 = np.ma.masked_array(a, mask=mask_a1)
+    b_masked1 = np.ma.masked_array(b, mask=mask_b1)
+    a_masked1[mask_a2] = np.nan
+    b_masked1[mask_b2] = np.nan
+
+    a_masked2 = np.ma.masked_array(a, mask=mask_a2)
+    b_masked2 = np.ma.masked_array(b, mask=mask_b2)
+    a_masked2[mask_a1] = np.nan
+    b_masked2[mask_b1] = np.nan
+
+    a_masked3 = np.ma.masked_array(a, mask=(mask_a1 | mask_a2))
+    b_masked3 = np.ma.masked_array(b, mask=(mask_b1 | mask_b2))
+
+    mask_all = (mask_a1 | mask_a2 | mask_b1 | mask_b2)
+    a_masked4 = np.ma.masked_array(a, mask=mask_all)
+    b_masked4 = np.ma.masked_array(b, mask=mask_all)
+
+    with np.testing.suppress_warnings() as sup:
+        message = 'invalid value encountered'
+        sup.filter(RuntimeWarning, message)
+        res = func(a_nans, weights=b_nans, nan_policy="omit", axis=axis)
+        res1 = func(a_masked1, weights=b_masked1, nan_policy="omit", axis=axis)
+        res2 = func(a_masked2, weights=b_masked2, nan_policy="omit", axis=axis)
+        res3 = func(a_masked3, weights=b_masked3, nan_policy="raise", axis=axis)
+        res4 = func(a_masked3, weights=b_masked3, nan_policy="propagate", axis=axis)
+        # Would test with a_masked3/b_masked3, but there is a bug in np.average
+        # that causes a bug in _no_deco mean with masked weights. Would use
+        # np.ma.average, but that causes other problems. See numpy/numpy#7330.
+        if weighted_fun_name in {"hmean"}:
+            weighted_fun_ma = getattr(stats.mstats, weighted_fun_name)
+            res5 = weighted_fun_ma(a_masked4, weights=b_masked4,
+                                   axis=axis, _no_deco=True)
+
+    np.testing.assert_array_equal(res1, res)
+    np.testing.assert_array_equal(res2, res)
+    np.testing.assert_array_equal(res3, res)
+    np.testing.assert_array_equal(res4, res)
+    if weighted_fun_name in {"hmean"}:
+        # _no_deco mean returns masked array, last element was masked
+        np.testing.assert_allclose(res5.compressed(), res[~np.isnan(res)])
+
+
+def test_raise_invalid_args_g17713():
+    # other cases are handled in:
+    # test_axis_nan_policy_decorated_positional_axis - multiple values for arg
+    # test_axis_nan_policy_decorated_positional_args - unexpected kwd arg
+    message = "got an unexpected keyword argument"
+    with pytest.raises(TypeError, match=message):
+        stats.gmean([1, 2, 3], invalid_arg=True)
+
+    message = " got multiple values for argument"
+    with pytest.raises(TypeError, match=message):
+        stats.gmean([1, 2, 3], a=True)
+
+    message = "missing 1 required positional argument"
+    with pytest.raises(TypeError, match=message):
+        stats.gmean()
+
+    message = "takes from 1 to 4 positional arguments but 5 were given"
+    with pytest.raises(TypeError, match=message):
+        stats.gmean([1, 2, 3], 0, float, [1, 1, 1], 10)
+
+
+@pytest.mark.parametrize('dtype', [np.int16, np.float32, np.complex128])
+def test_array_like_input(dtype):
+    # Check that `_axis_nan_policy`-decorated functions work with custom
+    # containers that are coercible to numeric arrays
+
+    class ArrLike:
+        def __init__(self, x, dtype):
+            self._x = x
+            self._dtype = dtype
+
+        def __array__(self, dtype=None, copy=None):
+            return np.asarray(x, dtype=self._dtype)
+
+    x = [1]*2 + [3, 4, 5]
+    res = stats.mode(ArrLike(x, dtype=dtype))
+    assert res.mode == 1
+    assert res.count == 2

.venv/Lib/site-packages/scipy/stats/tests/test_binned_statistic.py

@@ -0,0 +1,568 @@
+import numpy as np
+from numpy.testing import assert_allclose
+import pytest
+from pytest import raises as assert_raises
+from scipy.stats import (binned_statistic, binned_statistic_2d,
+                         binned_statistic_dd)
+from scipy._lib._util import check_random_state
+
+from .common_tests import check_named_results
+
+
+class TestBinnedStatistic:
+
+    @classmethod
+    def setup_class(cls):
+        rng = check_random_state(9865)
+        cls.x = rng.uniform(size=100)
+        cls.y = rng.uniform(size=100)
+        cls.v = rng.uniform(size=100)
+        cls.X = rng.uniform(size=(100, 3))
+        cls.w = rng.uniform(size=100)
+        cls.u = rng.uniform(size=100) + 1e6
+
+    def test_1d_count(self):
+        x = self.x
+        v = self.v
+
+        count1, edges1, bc = binned_statistic(x, v, 'count', bins=10)
+        count2, edges2 = np.histogram(x, bins=10)
+
+        assert_allclose(count1, count2)
+        assert_allclose(edges1, edges2)
+
+    def test_gh5927(self):
+        # smoke test for gh5927 - binned_statistic was using `is` for string
+        # comparison
+        x = self.x
+        v = self.v
+        statistics = ['mean', 'median', 'count', 'sum']
+        for statistic in statistics:
+            binned_statistic(x, v, statistic, bins=10)
+
+    def test_big_number_std(self):
+        # tests for numerical stability of std calculation
+        # see issue gh-10126 for more
+        x = self.x
+        u = self.u
+        stat1, edges1, bc = binned_statistic(x, u, 'std', bins=10)
+        stat2, edges2, bc = binned_statistic(x, u, np.std, bins=10)
+
+        assert_allclose(stat1, stat2)
+
+    def test_empty_bins_std(self):
+        # tests that std returns gives nan for empty bins
+        x = self.x
+        u = self.u
+        print(binned_statistic(x, u, 'count', bins=1000))
+        stat1, edges1, bc = binned_statistic(x, u, 'std', bins=1000)
+        stat2, edges2, bc = binned_statistic(x, u, np.std, bins=1000)
+
+        assert_allclose(stat1, stat2)
+
+    def test_non_finite_inputs_and_int_bins(self):
+        # if either `values` or `sample` contain np.inf or np.nan throw
+        # see issue gh-9010 for more
+        x = self.x
+        u = self.u
+        orig = u[0]
+        u[0] = np.inf
+        assert_raises(ValueError, binned_statistic, u, x, 'std', bins=10)
+        # need to test for non-python specific ints, e.g. np.int8, np.int64
+        assert_raises(ValueError, binned_statistic, u, x, 'std',
+                      bins=np.int64(10))
+        u[0] = np.nan
+        assert_raises(ValueError, binned_statistic, u, x, 'count', bins=10)
+        # replace original value, u belongs the class
+        u[0] = orig
+
+    def test_1d_result_attributes(self):
+        x = self.x
+        v = self.v
+
+        res = binned_statistic(x, v, 'count', bins=10)
+        attributes = ('statistic', 'bin_edges', 'binnumber')
+        check_named_results(res, attributes)
+
+    def test_1d_sum(self):
+        x = self.x
+        v = self.v
+
+        sum1, edges1, bc = binned_statistic(x, v, 'sum', bins=10)
+        sum2, edges2 = np.histogram(x, bins=10, weights=v)
+
+        assert_allclose(sum1, sum2)
+        assert_allclose(edges1, edges2)
+
+    def test_1d_mean(self):
+        x = self.x
+        v = self.v
+
+        stat1, edges1, bc = binned_statistic(x, v, 'mean', bins=10)
+        stat2, edges2, bc = binned_statistic(x, v, np.mean, bins=10)
+
+        assert_allclose(stat1, stat2)
+        assert_allclose(edges1, edges2)
+
+    def test_1d_std(self):
+        x = self.x
+        v = self.v
+
+        stat1, edges1, bc = binned_statistic(x, v, 'std', bins=10)
+        stat2, edges2, bc = binned_statistic(x, v, np.std, bins=10)
+
+        assert_allclose(stat1, stat2)
+        assert_allclose(edges1, edges2)
+
+    def test_1d_min(self):
+        x = self.x
+        v = self.v
+
+        stat1, edges1, bc = binned_statistic(x, v, 'min', bins=10)
+        stat2, edges2, bc = binned_statistic(x, v, np.min, bins=10)
+
+        assert_allclose(stat1, stat2)
+        assert_allclose(edges1, edges2)
+
+    def test_1d_max(self):
+        x = self.x
+        v = self.v
+
+        stat1, edges1, bc = binned_statistic(x, v, 'max', bins=10)
+        stat2, edges2, bc = binned_statistic(x, v, np.max, bins=10)
+
+        assert_allclose(stat1, stat2)
+        assert_allclose(edges1, edges2)
+
+    def test_1d_median(self):
+        x = self.x
+        v = self.v
+
+        stat1, edges1, bc = binned_statistic(x, v, 'median', bins=10)
+        stat2, edges2, bc = binned_statistic(x, v, np.median, bins=10)
+
+        assert_allclose(stat1, stat2)
+        assert_allclose(edges1, edges2)
+
+    def test_1d_bincode(self):
+        x = self.x[:20]
+        v = self.v[:20]
+
+        count1, edges1, bc = binned_statistic(x, v, 'count', bins=3)
+        bc2 = np.array([3, 2, 1, 3, 2, 3, 3, 3, 3, 1, 1, 3, 3, 1, 2, 3, 1,
+                        1, 2, 1])
+
+        bcount = [(bc == i).sum() for i in np.unique(bc)]
+
+        assert_allclose(bc, bc2)
+        assert_allclose(bcount, count1)
+
+    def test_1d_range_keyword(self):
+        # Regression test for gh-3063, range can be (min, max) or [(min, max)]
+        np.random.seed(9865)
+        x = np.arange(30)
+        data = np.random.random(30)
+
+        mean, bins, _ = binned_statistic(x[:15], data[:15])
+        mean_range, bins_range, _ = binned_statistic(x, data, range=[(0, 14)])
+        mean_range2, bins_range2, _ = binned_statistic(x, data, range=(0, 14))
+
+        assert_allclose(mean, mean_range)
+        assert_allclose(bins, bins_range)
+        assert_allclose(mean, mean_range2)
+        assert_allclose(bins, bins_range2)
+
+    def test_1d_multi_values(self):
+        x = self.x
+        v = self.v
+        w = self.w
+
+        stat1v, edges1v, bc1v = binned_statistic(x, v, 'mean', bins=10)
+        stat1w, edges1w, bc1w = binned_statistic(x, w, 'mean', bins=10)
+        stat2, edges2, bc2 = binned_statistic(x, [v, w], 'mean', bins=10)
+
+        assert_allclose(stat2[0], stat1v)
+        assert_allclose(stat2[1], stat1w)
+        assert_allclose(edges1v, edges2)
+        assert_allclose(bc1v, bc2)
+
+    def test_2d_count(self):
+        x = self.x
+        y = self.y
+        v = self.v
+
+        count1, binx1, biny1, bc = binned_statistic_2d(
+            x, y, v, 'count', bins=5)
+        count2, binx2, biny2 = np.histogram2d(x, y, bins=5)
+
+        assert_allclose(count1, count2)
+        assert_allclose(binx1, binx2)
+        assert_allclose(biny1, biny2)
+
+    def test_2d_result_attributes(self):
+        x = self.x
+        y = self.y
+        v = self.v
+
+        res = binned_statistic_2d(x, y, v, 'count', bins=5)
+        attributes = ('statistic', 'x_edge', 'y_edge', 'binnumber')
+        check_named_results(res, attributes)
+
+    def test_2d_sum(self):
+        x = self.x
+        y = self.y
+        v = self.v
+
+        sum1, binx1, biny1, bc = binned_statistic_2d(x, y, v, 'sum', bins=5)
+        sum2, binx2, biny2 = np.histogram2d(x, y, bins=5, weights=v)
+
+        assert_allclose(sum1, sum2)
+        assert_allclose(binx1, binx2)
+        assert_allclose(biny1, biny2)
+
+    def test_2d_mean(self):
+        x = self.x
+        y = self.y
+        v = self.v
+
+        stat1, binx1, biny1, bc = binned_statistic_2d(x, y, v, 'mean', bins=5)
+        stat2, binx2, biny2, bc = binned_statistic_2d(x, y, v, np.mean, bins=5)
+
+        assert_allclose(stat1, stat2)
+        assert_allclose(binx1, binx2)
+        assert_allclose(biny1, biny2)
+
+    def test_2d_mean_unicode(self):
+        x = self.x
+        y = self.y
+        v = self.v
+        stat1, binx1, biny1, bc = binned_statistic_2d(
+            x, y, v, 'mean', bins=5)
+        stat2, binx2, biny2, bc = binned_statistic_2d(x, y, v, np.mean, bins=5)
+        assert_allclose(stat1, stat2)
+        assert_allclose(binx1, binx2)
+        assert_allclose(biny1, biny2)
+
+    def test_2d_std(self):
+        x = self.x
+        y = self.y
+        v = self.v
+
+        stat1, binx1, biny1, bc = binned_statistic_2d(x, y, v, 'std', bins=5)
+        stat2, binx2, biny2, bc = binned_statistic_2d(x, y, v, np.std, bins=5)
+
+        assert_allclose(stat1, stat2)
+        assert_allclose(binx1, binx2)
+        assert_allclose(biny1, biny2)
+
+    def test_2d_min(self):
+        x = self.x
+        y = self.y
+        v = self.v
+
+        stat1, binx1, biny1, bc = binned_statistic_2d(x, y, v, 'min', bins=5)
+        stat2, binx2, biny2, bc = binned_statistic_2d(x, y, v, np.min, bins=5)
+
+        assert_allclose(stat1, stat2)
+        assert_allclose(binx1, binx2)
+        assert_allclose(biny1, biny2)
+
+    def test_2d_max(self):
+        x = self.x
+        y = self.y
+        v = self.v
+
+        stat1, binx1, biny1, bc = binned_statistic_2d(x, y, v, 'max', bins=5)
+        stat2, binx2, biny2, bc = binned_statistic_2d(x, y, v, np.max, bins=5)
+
+        assert_allclose(stat1, stat2)
+        assert_allclose(binx1, binx2)
+        assert_allclose(biny1, biny2)
+
+    def test_2d_median(self):
+        x = self.x
+        y = self.y
+        v = self.v
+
+        stat1, binx1, biny1, bc = binned_statistic_2d(
+            x, y, v, 'median', bins=5)
+        stat2, binx2, biny2, bc = binned_statistic_2d(
+            x, y, v, np.median, bins=5)
+
+        assert_allclose(stat1, stat2)
+        assert_allclose(binx1, binx2)
+        assert_allclose(biny1, biny2)
+
+    def test_2d_bincode(self):
+        x = self.x[:20]
+        y = self.y[:20]
+        v = self.v[:20]
+
+        count1, binx1, biny1, bc = binned_statistic_2d(
+            x, y, v, 'count', bins=3)
+        bc2 = np.array([17, 11, 6, 16, 11, 17, 18, 17, 17, 7, 6, 18, 16,
+                        6, 11, 16, 6, 6, 11, 8])
+
+        bcount = [(bc == i).sum() for i in np.unique(bc)]
+
+        assert_allclose(bc, bc2)
+        count1adj = count1[count1.nonzero()]
+        assert_allclose(bcount, count1adj)
+
+    def test_2d_multi_values(self):
+        x = self.x
+        y = self.y
+        v = self.v
+        w = self.w
+
+        stat1v, binx1v, biny1v, bc1v = binned_statistic_2d(
+            x, y, v, 'mean', bins=8)
+        stat1w, binx1w, biny1w, bc1w = binned_statistic_2d(
+            x, y, w, 'mean', bins=8)
+        stat2, binx2, biny2, bc2 = binned_statistic_2d(
+            x, y, [v, w], 'mean', bins=8)
+
+        assert_allclose(stat2[0], stat1v)
+        assert_allclose(stat2[1], stat1w)
+        assert_allclose(binx1v, binx2)
+        assert_allclose(biny1w, biny2)
+        assert_allclose(bc1v, bc2)
+
+    def test_2d_binnumbers_unraveled(self):
+        x = self.x
+        y = self.y
+        v = self.v
+
+        stat, edgesx, bcx = binned_statistic(x, v, 'mean', bins=20)
+        stat, edgesy, bcy = binned_statistic(y, v, 'mean', bins=10)
+
+        stat2, edgesx2, edgesy2, bc2 = binned_statistic_2d(
+            x, y, v, 'mean', bins=(20, 10), expand_binnumbers=True)
+
+        bcx3 = np.searchsorted(edgesx, x, side='right')
+        bcy3 = np.searchsorted(edgesy, y, side='right')
+
+        # `numpy.searchsorted` is non-inclusive on right-edge, compensate
+        bcx3[x == x.max()] -= 1
+        bcy3[y == y.max()] -= 1
+
+        assert_allclose(bcx, bc2[0])
+        assert_allclose(bcy, bc2[1])
+        assert_allclose(bcx3, bc2[0])
+        assert_allclose(bcy3, bc2[1])
+
+    def test_dd_count(self):
+        X = self.X
+        v = self.v
+
+        count1, edges1, bc = binned_statistic_dd(X, v, 'count', bins=3)
+        count2, edges2 = np.histogramdd(X, bins=3)
+
+        assert_allclose(count1, count2)
+        assert_allclose(edges1, edges2)
+
+    def test_dd_result_attributes(self):
+        X = self.X
+        v = self.v
+
+        res = binned_statistic_dd(X, v, 'count', bins=3)
+        attributes = ('statistic', 'bin_edges', 'binnumber')
+        check_named_results(res, attributes)
+
+    def test_dd_sum(self):
+        X = self.X
+        v = self.v
+
+        sum1, edges1, bc = binned_statistic_dd(X, v, 'sum', bins=3)
+        sum2, edges2 = np.histogramdd(X, bins=3, weights=v)
+        sum3, edges3, bc = binned_statistic_dd(X, v, np.sum, bins=3)
+
+        assert_allclose(sum1, sum2)
+        assert_allclose(edges1, edges2)
+        assert_allclose(sum1, sum3)
+        assert_allclose(edges1, edges3)
+
+    def test_dd_mean(self):
+        X = self.X
+        v = self.v
+
+        stat1, edges1, bc = binned_statistic_dd(X, v, 'mean', bins=3)
+        stat2, edges2, bc = binned_statistic_dd(X, v, np.mean, bins=3)
+
+        assert_allclose(stat1, stat2)
+        assert_allclose(edges1, edges2)
+
+    def test_dd_std(self):
+        X = self.X
+        v = self.v
+
+        stat1, edges1, bc = binned_statistic_dd(X, v, 'std', bins=3)
+        stat2, edges2, bc = binned_statistic_dd(X, v, np.std, bins=3)
+
+        assert_allclose(stat1, stat2)
+        assert_allclose(edges1, edges2)
+
+    def test_dd_min(self):
+        X = self.X
+        v = self.v
+
+        stat1, edges1, bc = binned_statistic_dd(X, v, 'min', bins=3)
+        stat2, edges2, bc = binned_statistic_dd(X, v, np.min, bins=3)
+
+        assert_allclose(stat1, stat2)
+        assert_allclose(edges1, edges2)
+
+    def test_dd_max(self):
+        X = self.X
+        v = self.v
+
+        stat1, edges1, bc = binned_statistic_dd(X, v, 'max', bins=3)
+        stat2, edges2, bc = binned_statistic_dd(X, v, np.max, bins=3)
+
+        assert_allclose(stat1, stat2)
+        assert_allclose(edges1, edges2)
+
+    def test_dd_median(self):
+        X = self.X
+        v = self.v
+
+        stat1, edges1, bc = binned_statistic_dd(X, v, 'median', bins=3)
+        stat2, edges2, bc = binned_statistic_dd(X, v, np.median, bins=3)
+
+        assert_allclose(stat1, stat2)
+        assert_allclose(edges1, edges2)
+
+    def test_dd_bincode(self):
+        X = self.X[:20]
+        v = self.v[:20]
+
+        count1, edges1, bc = binned_statistic_dd(X, v, 'count', bins=3)
+        bc2 = np.array([63, 33, 86, 83, 88, 67, 57, 33, 42, 41, 82, 83, 92,
+                        32, 36, 91, 43, 87, 81, 81])
+
+        bcount = [(bc == i).sum() for i in np.unique(bc)]
+
+        assert_allclose(bc, bc2)
+        count1adj = count1[count1.nonzero()]
+        assert_allclose(bcount, count1adj)
+
+    def test_dd_multi_values(self):
+        X = self.X
+        v = self.v
+        w = self.w
+
+        for stat in ["count", "sum", "mean", "std", "min", "max", "median",
+                     np.std]:
+            stat1v, edges1v, bc1v = binned_statistic_dd(X, v, stat, bins=8)
+            stat1w, edges1w, bc1w = binned_statistic_dd(X, w, stat, bins=8)
+            stat2, edges2, bc2 = binned_statistic_dd(X, [v, w], stat, bins=8)
+            assert_allclose(stat2[0], stat1v)
+            assert_allclose(stat2[1], stat1w)
+            assert_allclose(edges1v, edges2)
+            assert_allclose(edges1w, edges2)
+            assert_allclose(bc1v, bc2)
+
+    def test_dd_binnumbers_unraveled(self):
+        X = self.X
+        v = self.v
+
+        stat, edgesx, bcx = binned_statistic(X[:, 0], v, 'mean', bins=15)
+        stat, edgesy, bcy = binned_statistic(X[:, 1], v, 'mean', bins=20)
+        stat, edgesz, bcz = binned_statistic(X[:, 2], v, 'mean', bins=10)
+
+        stat2, edges2, bc2 = binned_statistic_dd(
+            X, v, 'mean', bins=(15, 20, 10), expand_binnumbers=True)
+
+        assert_allclose(bcx, bc2[0])
+        assert_allclose(bcy, bc2[1])
+        assert_allclose(bcz, bc2[2])
+
+    def test_dd_binned_statistic_result(self):
+        # NOTE: tests the reuse of bin_edges from previous call
+        x = np.random.random((10000, 3))
+        v = np.random.random(10000)
+        bins = np.linspace(0, 1, 10)
+        bins = (bins, bins, bins)
+
+        result = binned_statistic_dd(x, v, 'mean', bins=bins)
+        stat = result.statistic
+
+        result = binned_statistic_dd(x, v, 'mean',
+                                     binned_statistic_result=result)
+        stat2 = result.statistic
+
+        assert_allclose(stat, stat2)
+
+    def test_dd_zero_dedges(self):
+        x = np.random.random((10000, 3))
+        v = np.random.random(10000)
+        bins = np.linspace(0, 1, 10)
+        bins = np.append(bins, 1)
+        bins = (bins, bins, bins)
+        with assert_raises(ValueError, match='difference is numerically 0'):
+            binned_statistic_dd(x, v, 'mean', bins=bins)
+
+    def test_dd_range_errors(self):
+        # Test that descriptive exceptions are raised as appropriate for bad
+        # values of the `range` argument. (See gh-12996)
+        with assert_raises(ValueError,
+                           match='In range, start must be <= stop'):
+            binned_statistic_dd([self.y], self.v,
+                                range=[[1, 0]])
+        with assert_raises(
+                ValueError,
+                match='In dimension 1 of range, start must be <= stop'):
+            binned_statistic_dd([self.x, self.y], self.v,
+                                range=[[1, 0], [0, 1]])
+        with assert_raises(
+                ValueError,
+                match='In dimension 2 of range, start must be <= stop'):
+            binned_statistic_dd([self.x, self.y], self.v,
+                                range=[[0, 1], [1, 0]])
+        with assert_raises(
+                ValueError,
+                match='range given for 1 dimensions; 2 required'):
+            binned_statistic_dd([self.x, self.y], self.v,
+                                range=[[0, 1]])
+
+    def test_binned_statistic_float32(self):
+        X = np.array([0, 0.42358226], dtype=np.float32)
+        stat, _, _ = binned_statistic(X, None, 'count', bins=5)
+        assert_allclose(stat, np.array([1, 0, 0, 0, 1], dtype=np.float64))
+
+    def test_gh14332(self):
+        # Test the wrong output when the `sample` is close to bin edge
+        x = []
+        size = 20
+        for i in range(size):
+            x += [1-0.1**i]
+
+        bins = np.linspace(0,1,11)
+        sum1, edges1, bc = binned_statistic_dd(x, np.ones(len(x)),
+                                               bins=[bins], statistic='sum')
+        sum2, edges2 = np.histogram(x, bins=bins)
+
+        assert_allclose(sum1, sum2)
+        assert_allclose(edges1[0], edges2)
+
+    @pytest.mark.parametrize("dtype", [np.float64, np.complex128])
+    @pytest.mark.parametrize("statistic", [np.mean, np.median, np.sum, np.std,
+                                           np.min, np.max, 'count',
+                                           lambda x: (x**2).sum(),
+                                           lambda x: (x**2).sum() * 1j])
+    def test_dd_all(self, dtype, statistic):
+        def ref_statistic(x):
+            return len(x) if statistic == 'count' else statistic(x)
+
+        rng = np.random.default_rng(3704743126639371)
+        n = 10
+        x = rng.random(size=n)
+        i = x >= 0.5
+        v = rng.random(size=n)
+        if dtype is np.complex128:
+            v = v + rng.random(size=n)*1j
+
+        stat, _, _ = binned_statistic_dd(x, v, statistic, bins=2)
+        ref = np.array([ref_statistic(v[~i]), ref_statistic(v[i])])
+        assert_allclose(stat, ref)
+        assert stat.dtype == np.result_type(ref.dtype, np.float64)

.venv/Lib/site-packages/scipy/stats/tests/test_boost_ufuncs.py

@@ -0,0 +1,47 @@
+import pytest
+import numpy as np
+from numpy.testing import assert_allclose
+from scipy.stats import _boost
+
+
+type_char_to_type_tol = {'f': (np.float32, 32*np.finfo(np.float32).eps),
+                         'd': (np.float64, 32*np.finfo(np.float64).eps)}
+
+
+# Each item in this list is
+#   (func, args, expected_value)
+# All the values can be represented exactly, even with np.float32.
+#
+# This is not an exhaustive test data set of all the functions!
+# It is a spot check of several functions, primarily for
+# checking that the different data types are handled correctly.
+test_data = [
+    (_boost._beta_cdf, (0.5, 2, 3), 0.6875),
+    (_boost._beta_ppf, (0.6875, 2, 3), 0.5),
+    (_boost._beta_pdf, (0.5, 2, 3), 1.5),
+    (_boost._beta_pdf, (0, 1, 5), 5.0),
+    (_boost._beta_pdf, (1, 5, 1), 5.0),
+    (_boost._beta_sf, (0.5, 2, 1), 0.75),
+    (_boost._beta_isf, (0.75, 2, 1), 0.5),
+    (_boost._binom_cdf, (1, 3, 0.5), 0.5),
+    (_boost._binom_pdf, (1, 4, 0.5), 0.25),
+    (_boost._hypergeom_cdf, (2, 3, 5, 6), 0.5),
+    (_boost._nbinom_cdf, (1, 4, 0.25), 0.015625),
+    (_boost._ncf_mean, (10, 12, 2.5), 1.5),
+]
+
+
+@pytest.mark.parametrize('func, args, expected', test_data)
+def test_stats_boost_ufunc(func, args, expected):
+    type_sigs = func.types
+    type_chars = [sig.split('->')[-1] for sig in type_sigs]
+    for type_char in type_chars:
+        typ, rtol = type_char_to_type_tol[type_char]
+        args = [typ(arg) for arg in args]
+        # Harmless overflow warnings are a "feature" of some wrappers on some
+        # platforms. This test is about dtype and accuracy, so let's avoid false
+        # test failures cause by these warnings. See gh-17432.
+        with np.errstate(over='ignore'):
+            value = func(*args)
+        assert isinstance(value, typ)
+        assert_allclose(value, expected, rtol=rtol)

.venv/Lib/site-packages/scipy/stats/tests/test_censored_data.py

@@ -0,0 +1,152 @@
+# Tests for the CensoredData class.
+
+import pytest
+import numpy as np
+from numpy.testing import assert_equal, assert_array_equal
+from scipy.stats import CensoredData
+
+
+class TestCensoredData:
+
+    def test_basic(self):
+        uncensored = [1]
+        left = [0]
+        right = [2, 5]
+        interval = [[2, 3]]
+        data = CensoredData(uncensored, left=left, right=right,
+                            interval=interval)
+        assert_equal(data._uncensored, uncensored)
+        assert_equal(data._left, left)
+        assert_equal(data._right, right)
+        assert_equal(data._interval, interval)
+
+        udata = data._uncensor()
+        assert_equal(udata, np.concatenate((uncensored, left, right,
+                                            np.mean(interval, axis=1))))
+
+    def test_right_censored(self):
+        x = np.array([0, 3, 2.5])
+        is_censored = np.array([0, 1, 0], dtype=bool)
+        data = CensoredData.right_censored(x, is_censored)
+        assert_equal(data._uncensored, x[~is_censored])
+        assert_equal(data._right, x[is_censored])
+        assert_equal(data._left, [])
+        assert_equal(data._interval, np.empty((0, 2)))
+
+    def test_left_censored(self):
+        x = np.array([0, 3, 2.5])
+        is_censored = np.array([0, 1, 0], dtype=bool)
+        data = CensoredData.left_censored(x, is_censored)
+        assert_equal(data._uncensored, x[~is_censored])
+        assert_equal(data._left, x[is_censored])
+        assert_equal(data._right, [])
+        assert_equal(data._interval, np.empty((0, 2)))
+
+    def test_interval_censored_basic(self):
+        a = [0.5, 2.0, 3.0, 5.5]
+        b = [1.0, 2.5, 3.5, 7.0]
+        data = CensoredData.interval_censored(low=a, high=b)
+        assert_array_equal(data._interval, np.array(list(zip(a, b))))
+        assert data._uncensored.shape == (0,)
+        assert data._left.shape == (0,)
+        assert data._right.shape == (0,)
+
+    def test_interval_censored_mixed(self):
+        # This is actually a mix of uncensored, left-censored, right-censored
+        # and interval-censored data.  Check that when the `interval_censored`
+        # class method is used, the data is correctly separated into the
+        # appropriate arrays.
+        a = [0.5, -np.inf, -13.0, 2.0, 1.0, 10.0, -1.0]
+        b = [0.5, 2500.0, np.inf, 3.0, 1.0, 11.0, np.inf]
+        data = CensoredData.interval_censored(low=a, high=b)
+        assert_array_equal(data._interval, [[2.0, 3.0], [10.0, 11.0]])
+        assert_array_equal(data._uncensored, [0.5, 1.0])
+        assert_array_equal(data._left, [2500.0])
+        assert_array_equal(data._right, [-13.0, -1.0])
+
+    def test_interval_to_other_types(self):
+        # The interval parameter can represent uncensored and
+        # left- or right-censored data.  Test the conversion of such
+        # an example to the canonical form in which the different
+        # types have been split into the separate arrays.
+        interval = np.array([[0, 1],        # interval-censored
+                             [2, 2],        # not censored
+                             [3, 3],        # not censored
+                             [9, np.inf],   # right-censored
+                             [8, np.inf],   # right-censored
+                             [-np.inf, 0],  # left-censored
+                             [1, 2]])       # interval-censored
+        data = CensoredData(interval=interval)
+        assert_equal(data._uncensored, [2, 3])
+        assert_equal(data._left, [0])
+        assert_equal(data._right, [9, 8])
+        assert_equal(data._interval, [[0, 1], [1, 2]])
+
+    def test_empty_arrays(self):
+        data = CensoredData(uncensored=[], left=[], right=[], interval=[])
+        assert data._uncensored.shape == (0,)
+        assert data._left.shape == (0,)
+        assert data._right.shape == (0,)
+        assert data._interval.shape == (0, 2)
+        assert len(data) == 0
+
+    def test_invalid_constructor_args(self):
+        with pytest.raises(ValueError, match='must be a one-dimensional'):
+            CensoredData(uncensored=[[1, 2, 3]])
+        with pytest.raises(ValueError, match='must be a one-dimensional'):
+            CensoredData(left=[[1, 2, 3]])
+        with pytest.raises(ValueError, match='must be a one-dimensional'):
+            CensoredData(right=[[1, 2, 3]])
+        with pytest.raises(ValueError, match='must be a two-dimensional'):
+            CensoredData(interval=[[1, 2, 3]])
+
+        with pytest.raises(ValueError, match='must not contain nan'):
+            CensoredData(uncensored=[1, np.nan, 2])
+        with pytest.raises(ValueError, match='must not contain nan'):
+            CensoredData(left=[1, np.nan, 2])
+        with pytest.raises(ValueError, match='must not contain nan'):
+            CensoredData(right=[1, np.nan, 2])
+        with pytest.raises(ValueError, match='must not contain nan'):
+            CensoredData(interval=[[1, np.nan], [2, 3]])
+
+        with pytest.raises(ValueError,
+                           match='both values must not be infinite'):
+            CensoredData(interval=[[1, 3], [2, 9], [np.inf, np.inf]])
+
+        with pytest.raises(ValueError,
+                           match='left value must not exceed the right'):
+            CensoredData(interval=[[1, 0], [2, 2]])
+
+    @pytest.mark.parametrize('func', [CensoredData.left_censored,
+                                      CensoredData.right_censored])
+    def test_invalid_left_right_censored_args(self, func):
+        with pytest.raises(ValueError,
+                           match='`x` must be one-dimensional'):
+            func([[1, 2, 3]], [0, 1, 1])
+        with pytest.raises(ValueError,
+                           match='`censored` must be one-dimensional'):
+            func([1, 2, 3], [[0, 1, 1]])
+        with pytest.raises(ValueError, match='`x` must not contain'):
+            func([1, 2, np.nan], [0, 1, 1])
+        with pytest.raises(ValueError, match='must have the same length'):
+            func([1, 2, 3], [0, 0, 1, 1])
+
+    def test_invalid_censored_args(self):
+        with pytest.raises(ValueError,
+                           match='`low` must be a one-dimensional'):
+            CensoredData.interval_censored(low=[[3]], high=[4, 5])
+        with pytest.raises(ValueError,
+                           match='`high` must be a one-dimensional'):
+            CensoredData.interval_censored(low=[3], high=[[4, 5]])
+        with pytest.raises(ValueError, match='`low` must not contain'):
+            CensoredData.interval_censored([1, 2, np.nan], [0, 1, 1])
+        with pytest.raises(ValueError, match='must have the same length'):
+            CensoredData.interval_censored([1, 2, 3], [0, 0, 1, 1])
+
+    def test_count_censored(self):
+        x = [1, 2, 3]
+        # data1 has no censored data.
+        data1 = CensoredData(x)
+        assert data1.num_censored() == 0
+        data2 = CensoredData(uncensored=[2.5], left=[10], interval=[[0, 1]])
+        assert data2.num_censored() == 2

.venv/Lib/site-packages/scipy/stats/tests/test_contingency.py

@@ -0,0 +1,241 @@
+import numpy as np
+from numpy.testing import (assert_equal, assert_array_equal,
+                           assert_array_almost_equal, assert_approx_equal,
+                           assert_allclose)
+import pytest
+from pytest import raises as assert_raises
+from scipy.special import xlogy
+from scipy.stats.contingency import (margins, expected_freq,
+                                     chi2_contingency, association)
+
+
+def test_margins():
+    a = np.array([1])
+    m = margins(a)
+    assert_equal(len(m), 1)
+    m0 = m[0]
+    assert_array_equal(m0, np.array([1]))
+
+    a = np.array([[1]])
+    m0, m1 = margins(a)
+    expected0 = np.array([[1]])
+    expected1 = np.array([[1]])
+    assert_array_equal(m0, expected0)
+    assert_array_equal(m1, expected1)
+
+    a = np.arange(12).reshape(2, 6)
+    m0, m1 = margins(a)
+    expected0 = np.array([[15], [51]])
+    expected1 = np.array([[6, 8, 10, 12, 14, 16]])
+    assert_array_equal(m0, expected0)
+    assert_array_equal(m1, expected1)
+
+    a = np.arange(24).reshape(2, 3, 4)
+    m0, m1, m2 = margins(a)
+    expected0 = np.array([[[66]], [[210]]])
+    expected1 = np.array([[[60], [92], [124]]])
+    expected2 = np.array([[[60, 66, 72, 78]]])
+    assert_array_equal(m0, expected0)
+    assert_array_equal(m1, expected1)
+    assert_array_equal(m2, expected2)
+
+
+def test_expected_freq():
+    assert_array_equal(expected_freq([1]), np.array([1.0]))
+
+    observed = np.array([[[2, 0], [0, 2]], [[0, 2], [2, 0]], [[1, 1], [1, 1]]])
+    e = expected_freq(observed)
+    assert_array_equal(e, np.ones_like(observed))
+
+    observed = np.array([[10, 10, 20], [20, 20, 20]])
+    e = expected_freq(observed)
+    correct = np.array([[12., 12., 16.], [18., 18., 24.]])
+    assert_array_almost_equal(e, correct)
+
+
+def test_chi2_contingency_trivial():
+    # Some very simple tests for chi2_contingency.
+
+    # A trivial case
+    obs = np.array([[1, 2], [1, 2]])
+    chi2, p, dof, expected = chi2_contingency(obs, correction=False)
+    assert_equal(chi2, 0.0)
+    assert_equal(p, 1.0)
+    assert_equal(dof, 1)
+    assert_array_equal(obs, expected)
+
+    # A *really* trivial case: 1-D data.
+    obs = np.array([1, 2, 3])
+    chi2, p, dof, expected = chi2_contingency(obs, correction=False)
+    assert_equal(chi2, 0.0)
+    assert_equal(p, 1.0)
+    assert_equal(dof, 0)
+    assert_array_equal(obs, expected)
+
+
+def test_chi2_contingency_R():
+    # Some test cases that were computed independently, using R.
+
+    # Rcode = \
+    # """
+    # # Data vector.
+    # data <- c(
+    #   12, 34, 23,     4,  47,  11,
+    #   35, 31, 11,    34,  10,  18,
+    #   12, 32,  9,    18,  13,  19,
+    #   12, 12, 14,     9,  33,  25
+    #   )
+    #
+    # # Create factor tags:r=rows, c=columns, t=tiers
+    # r <- factor(gl(4, 2*3, 2*3*4, labels=c("r1", "r2", "r3", "r4")))
+    # c <- factor(gl(3, 1,   2*3*4, labels=c("c1", "c2", "c3")))
+    # t <- factor(gl(2, 3,   2*3*4, labels=c("t1", "t2")))
+    #
+    # # 3-way Chi squared test of independence
+    # s = summary(xtabs(data~r+c+t))
+    # print(s)
+    # """
+    # Routput = \
+    # """
+    # Call: xtabs(formula = data ~ r + c + t)
+    # Number of cases in table: 478
+    # Number of factors: 3
+    # Test for independence of all factors:
+    #         Chisq = 102.17, df = 17, p-value = 3.514e-14
+    # """
+    obs = np.array(
+        [[[12, 34, 23],
+          [35, 31, 11],
+          [12, 32, 9],
+          [12, 12, 14]],
+         [[4, 47, 11],
+          [34, 10, 18],
+          [18, 13, 19],
+          [9, 33, 25]]])
+    chi2, p, dof, expected = chi2_contingency(obs)
+    assert_approx_equal(chi2, 102.17, significant=5)
+    assert_approx_equal(p, 3.514e-14, significant=4)
+    assert_equal(dof, 17)
+
+    # Rcode = \
+    # """
+    # # Data vector.
+    # data <- c(
+    #     #
+    #     12, 17,
+    #     11, 16,
+    #     #
+    #     11, 12,
+    #     15, 16,
+    #     #
+    #     23, 15,
+    #     30, 22,
+    #     #
+    #     14, 17,
+    #     15, 16
+    #     )
+    #
+    # # Create factor tags:r=rows, c=columns, d=depths(?), t=tiers
+    # r <- factor(gl(2, 2,  2*2*2*2, labels=c("r1", "r2")))
+    # c <- factor(gl(2, 1,  2*2*2*2, labels=c("c1", "c2")))
+    # d <- factor(gl(2, 4,  2*2*2*2, labels=c("d1", "d2")))
+    # t <- factor(gl(2, 8,  2*2*2*2, labels=c("t1", "t2")))
+    #
+    # # 4-way Chi squared test of independence
+    # s = summary(xtabs(data~r+c+d+t))
+    # print(s)
+    # """
+    # Routput = \
+    # """
+    # Call: xtabs(formula = data ~ r + c + d + t)
+    # Number of cases in table: 262
+    # Number of factors: 4
+    # Test for independence of all factors:
+    #         Chisq = 8.758, df = 11, p-value = 0.6442
+    # """
+    obs = np.array(
+        [[[[12, 17],
+           [11, 16]],
+          [[11, 12],
+           [15, 16]]],
+         [[[23, 15],
+           [30, 22]],
+          [[14, 17],
+           [15, 16]]]])
+    chi2, p, dof, expected = chi2_contingency(obs)
+    assert_approx_equal(chi2, 8.758, significant=4)
+    assert_approx_equal(p, 0.6442, significant=4)
+    assert_equal(dof, 11)
+
+
+def test_chi2_contingency_g():
+    c = np.array([[15, 60], [15, 90]])
+    g, p, dof, e = chi2_contingency(c, lambda_='log-likelihood',
+                                    correction=False)
+    assert_allclose(g, 2*xlogy(c, c/e).sum())
+
+    g, p, dof, e = chi2_contingency(c, lambda_='log-likelihood',
+                                    correction=True)
+    c_corr = c + np.array([[-0.5, 0.5], [0.5, -0.5]])
+    assert_allclose(g, 2*xlogy(c_corr, c_corr/e).sum())
+
+    c = np.array([[10, 12, 10], [12, 10, 10]])
+    g, p, dof, e = chi2_contingency(c, lambda_='log-likelihood')
+    assert_allclose(g, 2*xlogy(c, c/e).sum())
+
+
+def test_chi2_contingency_bad_args():
+    # Test that "bad" inputs raise a ValueError.
+
+    # Negative value in the array of observed frequencies.
+    obs = np.array([[-1, 10], [1, 2]])
+    assert_raises(ValueError, chi2_contingency, obs)
+
+    # The zeros in this will result in zeros in the array
+    # of expected frequencies.
+    obs = np.array([[0, 1], [0, 1]])
+    assert_raises(ValueError, chi2_contingency, obs)
+
+    # A degenerate case: `observed` has size 0.
+    obs = np.empty((0, 8))
+    assert_raises(ValueError, chi2_contingency, obs)
+
+
+def test_chi2_contingency_yates_gh13875():
+    # Magnitude of Yates' continuity correction should not exceed difference
+    # between expected and observed value of the statistic; see gh-13875
+    observed = np.array([[1573, 3], [4, 0]])
+    p = chi2_contingency(observed)[1]
+    assert_allclose(p, 1, rtol=1e-12)
+
+
+@pytest.mark.parametrize("correction", [False, True])
+def test_result(correction):
+    obs = np.array([[1, 2], [1, 2]])
+    res = chi2_contingency(obs, correction=correction)
+    assert_equal((res.statistic, res.pvalue, res.dof, res.expected_freq), res)
+
+
+def test_bad_association_args():
+    # Invalid Test Statistic
+    assert_raises(ValueError, association, [[1, 2], [3, 4]], "X")
+    # Invalid array shape
+    assert_raises(ValueError, association, [[[1, 2]], [[3, 4]]], "cramer")
+    # chi2_contingency exception
+    assert_raises(ValueError, association, [[-1, 10], [1, 2]], 'cramer')
+    # Invalid Array Item Data Type
+    assert_raises(ValueError, association,
+                  np.array([[1, 2], ["dd", 4]], dtype=object), 'cramer')
+
+
+@pytest.mark.parametrize('stat, expected',
+                         [('cramer', 0.09222412010290792),
+                          ('tschuprow', 0.0775509319944633),
+                          ('pearson', 0.12932925727138758)])
+def test_assoc(stat, expected):
+    # 2d Array
+    obs1 = np.array([[12, 13, 14, 15, 16],
+                     [17, 16, 18, 19, 11],
+                     [9, 15, 14, 12, 11]])
+    a = association(observed=obs1, method=stat)
+    assert_allclose(a, expected)

.venv/Lib/site-packages/scipy/stats/tests/test_continuous_basic.py

@@ -0,0 +1,1016 @@
+import sys
+import numpy as np
+import numpy.testing as npt
+import pytest
+from pytest import raises as assert_raises
+from scipy.integrate import IntegrationWarning
+import itertools
+
+from scipy import stats
+from .common_tests import (check_normalization, check_moment,
+                           check_mean_expect,
+                           check_var_expect, check_skew_expect,
+                           check_kurt_expect, check_entropy,
+                           check_private_entropy, check_entropy_vect_scale,
+                           check_edge_support, check_named_args,
+                           check_random_state_property,
+                           check_meth_dtype, check_ppf_dtype,
+                           check_cmplx_deriv,
+                           check_pickling, check_rvs_broadcast,
+                           check_freezing, check_munp_expect,)
+from scipy.stats._distr_params import distcont
+from scipy.stats._distn_infrastructure import rv_continuous_frozen
+
+"""
+Test all continuous distributions.
+
+Parameters were chosen for those distributions that pass the
+Kolmogorov-Smirnov test.  This provides safe parameters for each
+distributions so that we can perform further testing of class methods.
+
+These tests currently check only/mostly for serious errors and exceptions,
+not for numerically exact results.
+"""
+
+# Note that you need to add new distributions you want tested
+# to _distr_params
+
+DECIMAL = 5  # specify the precision of the tests  # increased from 0 to 5
+_IS_32BIT = (sys.maxsize < 2**32)
+
+# For skipping test_cont_basic
+distslow = ['recipinvgauss', 'vonmises', 'kappa4', 'vonmises_line',
+            'gausshyper', 'norminvgauss', 'geninvgauss', 'genhyperbolic',
+            'truncnorm', 'truncweibull_min']
+
+# distxslow are sorted by speed (very slow to slow)
+distxslow = ['studentized_range', 'kstwo', 'ksone', 'wrapcauchy', 'genexpon']
+
+# For skipping test_moments, which is already marked slow
+distxslow_test_moments = ['studentized_range', 'vonmises', 'vonmises_line',
+                          'ksone', 'kstwo', 'recipinvgauss', 'genexpon']
+
+# skip check_fit_args (test is slow)
+skip_fit_test_mle = ['exponpow', 'exponweib', 'gausshyper', 'genexpon',
+                     'halfgennorm', 'gompertz', 'johnsonsb', 'johnsonsu',
+                     'kappa4', 'ksone', 'kstwo', 'kstwobign', 'mielke', 'ncf',
+                     'nct', 'powerlognorm', 'powernorm', 'recipinvgauss',
+                     'trapezoid', 'vonmises', 'vonmises_line', 'levy_stable',
+                     'rv_histogram_instance', 'studentized_range']
+
+# these were really slow in `test_fit`.py.
+# note that this list is used to skip both fit_test and fit_fix tests
+slow_fit_test_mm = ['argus', 'exponpow', 'exponweib', 'gausshyper', 'genexpon',
+                    'genhalflogistic', 'halfgennorm', 'gompertz', 'johnsonsb',
+                    'kappa4', 'kstwobign', 'recipinvgauss',
+                    'trapezoid', 'truncexpon', 'vonmises', 'vonmises_line',
+                    'studentized_range']
+# pearson3 fails due to something weird
+# the first list fails due to non-finite distribution moments encountered
+# most of the rest fail due to integration warnings
+# pearson3 is overridden as not implemented due to gh-11746
+fail_fit_test_mm = (['alpha', 'betaprime', 'bradford', 'burr', 'burr12',
+                     'cauchy', 'crystalball', 'f', 'fisk', 'foldcauchy',
+                     'genextreme', 'genpareto', 'halfcauchy', 'invgamma',
+                     'jf_skew_t', 'kappa3', 'levy', 'levy_l', 'loglaplace',
+                     'lomax', 'mielke', 'nakagami', 'ncf', 'skewcauchy', 't',
+                     'tukeylambda', 'invweibull', 'rel_breitwigner']
+                     + ['genhyperbolic', 'johnsonsu', 'ksone', 'kstwo',
+                        'nct', 'pareto', 'powernorm', 'powerlognorm']
+                     + ['pearson3'])
+
+skip_fit_test = {"MLE": skip_fit_test_mle,
+                 "MM": slow_fit_test_mm + fail_fit_test_mm}
+
+# skip check_fit_args_fix (test is slow)
+skip_fit_fix_test_mle = ['burr', 'exponpow', 'exponweib', 'gausshyper',
+                         'genexpon', 'halfgennorm', 'gompertz', 'johnsonsb',
+                         'johnsonsu', 'kappa4', 'ksone', 'kstwo', 'kstwobign',
+                         'levy_stable', 'mielke', 'ncf', 'ncx2',
+                         'powerlognorm', 'powernorm', 'rdist', 'recipinvgauss',
+                         'trapezoid', 'truncpareto', 'vonmises', 'vonmises_line',
+                         'studentized_range']
+# the first list fails due to non-finite distribution moments encountered
+# most of the rest fail due to integration warnings
+# pearson3 is overridden as not implemented due to gh-11746
+fail_fit_fix_test_mm = (['alpha', 'betaprime', 'burr', 'burr12', 'cauchy',
+                         'crystalball', 'f', 'fisk', 'foldcauchy',
+                         'genextreme', 'genpareto', 'halfcauchy', 'invgamma',
+                         'jf_skew_t', 'kappa3', 'levy', 'levy_l', 'loglaplace',
+                         'lomax', 'mielke', 'nakagami', 'ncf', 'nct',
+                         'skewcauchy', 't', 'truncpareto', 'invweibull']
+                        + ['genhyperbolic', 'johnsonsu', 'ksone', 'kstwo',
+                           'pareto', 'powernorm', 'powerlognorm']
+                        + ['pearson3'])
+skip_fit_fix_test = {"MLE": skip_fit_fix_test_mle,
+                     "MM": slow_fit_test_mm + fail_fit_fix_test_mm}
+
+# These distributions fail the complex derivative test below.
+# Here 'fail' mean produce wrong results and/or raise exceptions, depending
+# on the implementation details of corresponding special functions.
+# cf https://github.com/scipy/scipy/pull/4979 for a discussion.
+fails_cmplx = {'argus', 'beta', 'betaprime', 'chi', 'chi2', 'cosine',
+               'dgamma', 'dweibull', 'erlang', 'f', 'foldcauchy', 'gamma',
+               'gausshyper', 'gengamma', 'genhyperbolic',
+               'geninvgauss', 'gennorm', 'genpareto',
+               'halfcauchy', 'halfgennorm', 'invgamma', 'jf_skew_t',
+               'ksone', 'kstwo', 'kstwobign', 'levy_l', 'loggamma',
+               'logistic', 'loguniform', 'maxwell', 'nakagami',
+               'ncf', 'nct', 'ncx2', 'norminvgauss', 'pearson3',
+               'powerlaw', 'rdist', 'reciprocal', 'rice',
+               'skewnorm', 't', 'truncweibull_min',
+               'tukeylambda', 'vonmises', 'vonmises_line',
+               'rv_histogram_instance', 'truncnorm', 'studentized_range',
+               'johnsonsb', 'halflogistic', 'rel_breitwigner'}
+
+
+# rv_histogram instances, with uniform and non-uniform bins;
+# stored as (dist, arg) tuples for cases_test_cont_basic
+# and cases_test_moments.
+histogram_test_instances = []
+case1 = {'a': [1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6,
+               6, 6, 6, 7, 7, 7, 8, 8, 9], 'bins': 8}  # equal width bins
+case2 = {'a': [1, 1], 'bins': [0, 1, 10]}  # unequal width bins
+for case, density in itertools.product([case1, case2], [True, False]):
+    _hist = np.histogram(**case, density=density)
+    _rv_hist = stats.rv_histogram(_hist, density=density)
+    histogram_test_instances.append((_rv_hist, tuple()))
+
+
+def cases_test_cont_basic():
+    for distname, arg in distcont[:] + histogram_test_instances:
+        if distname == 'levy_stable':
+            continue
+        elif distname in distslow:
+            yield pytest.param(distname, arg, marks=pytest.mark.slow)
+        elif distname in distxslow:
+            yield pytest.param(distname, arg, marks=pytest.mark.xslow)
+        else:
+            yield distname, arg
+
+
+@pytest.mark.parametrize('distname,arg', cases_test_cont_basic())
+@pytest.mark.parametrize('sn, n_fit_samples', [(500, 200)])
+def test_cont_basic(distname, arg, sn, n_fit_samples):
+    # this test skips slow distributions
+
+    try:
+        distfn = getattr(stats, distname)
+    except TypeError:
+        distfn = distname
+        distname = 'rv_histogram_instance'
+
+    rng = np.random.RandomState(765456)
+    rvs = distfn.rvs(size=sn, *arg, random_state=rng)
+    m, v = distfn.stats(*arg)
+
+    if distname not in {'laplace_asymmetric'}:
+        check_sample_meanvar_(m, v, rvs)
+    check_cdf_ppf(distfn, arg, distname)
+    check_sf_isf(distfn, arg, distname)
+    check_cdf_sf(distfn, arg, distname)
+    check_ppf_isf(distfn, arg, distname)
+    check_pdf(distfn, arg, distname)
+    check_pdf_logpdf(distfn, arg, distname)
+    check_pdf_logpdf_at_endpoints(distfn, arg, distname)
+    check_cdf_logcdf(distfn, arg, distname)
+    check_sf_logsf(distfn, arg, distname)
+    check_ppf_broadcast(distfn, arg, distname)
+
+    alpha = 0.01
+    if distname == 'rv_histogram_instance':
+        check_distribution_rvs(distfn.cdf, arg, alpha, rvs)
+    elif distname != 'geninvgauss':
+        # skip kstest for geninvgauss since cdf is too slow; see test for
+        # rv generation in TestGenInvGauss in test_distributions.py
+        check_distribution_rvs(distname, arg, alpha, rvs)
+
+    locscale_defaults = (0, 1)
+    meths = [distfn.pdf, distfn.logpdf, distfn.cdf, distfn.logcdf,
+             distfn.logsf]
+    # make sure arguments are within support
+    spec_x = {'weibull_max': -0.5, 'levy_l': -0.5,
+              'pareto': 1.5, 'truncpareto': 3.2, 'tukeylambda': 0.3,
+              'rv_histogram_instance': 5.0}
+    x = spec_x.get(distname, 0.5)
+    if distname == 'invweibull':
+        arg = (1,)
+    elif distname == 'ksone':
+        arg = (3,)
+
+    check_named_args(distfn, x, arg, locscale_defaults, meths)
+    check_random_state_property(distfn, arg)
+
+    if distname in ['rel_breitwigner'] and _IS_32BIT:
+        # gh18414
+        pytest.skip("fails on Linux 32-bit")
+    else:
+        check_pickling(distfn, arg)
+    check_freezing(distfn, arg)
+
+    # Entropy
+    if distname not in ['kstwobign', 'kstwo', 'ncf']:
+        check_entropy(distfn, arg, distname)
+
+    if distfn.numargs == 0:
+        check_vecentropy(distfn, arg)
+
+    if (distfn.__class__._entropy != stats.rv_continuous._entropy
+            and distname != 'vonmises'):
+        check_private_entropy(distfn, arg, stats.rv_continuous)
+
+    with npt.suppress_warnings() as sup:
+        sup.filter(IntegrationWarning, "The occurrence of roundoff error")
+        sup.filter(IntegrationWarning, "Extremely bad integrand")
+        sup.filter(RuntimeWarning, "invalid value")
+        check_entropy_vect_scale(distfn, arg)
+
+    check_retrieving_support(distfn, arg)
+    check_edge_support(distfn, arg)
+
+    check_meth_dtype(distfn, arg, meths)
+    check_ppf_dtype(distfn, arg)
+
+    if distname not in fails_cmplx:
+        check_cmplx_deriv(distfn, arg)
+
+    if distname != 'truncnorm':
+        check_ppf_private(distfn, arg, distname)
+
+    for method in ["MLE", "MM"]:
+        if distname not in skip_fit_test[method]:
+            check_fit_args(distfn, arg, rvs[:n_fit_samples], method)
+
+        if distname not in skip_fit_fix_test[method]:
+            check_fit_args_fix(distfn, arg, rvs[:n_fit_samples], method)
+
+
+@pytest.mark.parametrize('distname,arg', cases_test_cont_basic())
+def test_rvs_scalar(distname, arg):
+    # rvs should return a scalar when given scalar arguments (gh-12428)
+    try:
+        distfn = getattr(stats, distname)
+    except TypeError:
+        distfn = distname
+        distname = 'rv_histogram_instance'
+
+    assert np.isscalar(distfn.rvs(*arg))
+    assert np.isscalar(distfn.rvs(*arg, size=()))
+    assert np.isscalar(distfn.rvs(*arg, size=None))
+
+
+def test_levy_stable_random_state_property():
+    # levy_stable only implements rvs(), so it is skipped in the
+    # main loop in test_cont_basic(). Here we apply just the test
+    # check_random_state_property to levy_stable.
+    check_random_state_property(stats.levy_stable, (0.5, 0.1))
+
+
+def cases_test_moments():
+    fail_normalization = set()
+    fail_higher = {'ncf'}
+    fail_moment = {'johnsonsu'}  # generic `munp` is inaccurate for johnsonsu
+
+    for distname, arg in distcont[:] + histogram_test_instances:
+        if distname == 'levy_stable':
+            continue
+
+        if distname in distxslow_test_moments:
+            yield pytest.param(distname, arg, True, True, True, True,
+                               marks=pytest.mark.xslow(reason="too slow"))
+            continue
+
+        cond1 = distname not in fail_normalization
+        cond2 = distname not in fail_higher
+        cond3 = distname not in fail_moment
+
+        marks = list()
+        # Currently unused, `marks` can be used to add a timeout to a test of
+        # a specific distribution.  For example, this shows how a timeout could
+        # be added for the 'skewnorm' distribution:
+        #
+        #     marks = list()
+        #     if distname == 'skewnorm':
+        #         marks.append(pytest.mark.timeout(300))
+
+        yield pytest.param(distname, arg, cond1, cond2, cond3,
+                           False, marks=marks)
+
+        if not cond1 or not cond2 or not cond3:
+            # Run the distributions that have issues twice, once skipping the
+            # not_ok parts, once with the not_ok parts but marked as knownfail
+            yield pytest.param(distname, arg, True, True, True, True,
+                               marks=[pytest.mark.xfail] + marks)
+
+
+@pytest.mark.slow
+@pytest.mark.parametrize('distname,arg,normalization_ok,higher_ok,moment_ok,'
+                         'is_xfailing',
+                         cases_test_moments())
+def test_moments(distname, arg, normalization_ok, higher_ok, moment_ok,
+                 is_xfailing):
+    try:
+        distfn = getattr(stats, distname)
+    except TypeError:
+        distfn = distname
+        distname = 'rv_histogram_instance'
+
+    with npt.suppress_warnings() as sup:
+        sup.filter(IntegrationWarning,
+                   "The integral is probably divergent, or slowly convergent.")
+        sup.filter(IntegrationWarning,
+                   "The maximum number of subdivisions.")
+        sup.filter(IntegrationWarning,
+                   "The algorithm does not converge.")
+
+        if is_xfailing:
+            sup.filter(IntegrationWarning)
+
+        m, v, s, k = distfn.stats(*arg, moments='mvsk')
+
+        with np.errstate(all="ignore"):
+            if normalization_ok:
+                check_normalization(distfn, arg, distname)
+
+            if higher_ok:
+                check_mean_expect(distfn, arg, m, distname)
+                check_skew_expect(distfn, arg, m, v, s, distname)
+                check_var_expect(distfn, arg, m, v, distname)
+                check_kurt_expect(distfn, arg, m, v, k, distname)
+                check_munp_expect(distfn, arg, distname)
+
+        check_loc_scale(distfn, arg, m, v, distname)
+
+        if moment_ok:
+            check_moment(distfn, arg, m, v, distname)
+
+
+@pytest.mark.parametrize('dist,shape_args', distcont)
+def test_rvs_broadcast(dist, shape_args):
+    if dist in ['gausshyper', 'studentized_range']:
+        pytest.skip("too slow")
+
+    if dist in ['rel_breitwigner'] and _IS_32BIT:
+        # gh18414
+        pytest.skip("fails on Linux 32-bit")
+
+    # If shape_only is True, it means the _rvs method of the
+    # distribution uses more than one random number to generate a random
+    # variate.  That means the result of using rvs with broadcasting or
+    # with a nontrivial size will not necessarily be the same as using the
+    # numpy.vectorize'd version of rvs(), so we can only compare the shapes
+    # of the results, not the values.
+    # Whether or not a distribution is in the following list is an
+    # implementation detail of the distribution, not a requirement.  If
+    # the implementation the rvs() method of a distribution changes, this
+    # test might also have to be changed.
+    shape_only = dist in ['argus', 'betaprime', 'dgamma', 'dweibull',
+                          'exponnorm', 'genhyperbolic', 'geninvgauss',
+                          'levy_stable', 'nct', 'norminvgauss', 'rice',
+                          'skewnorm', 'semicircular', 'gennorm', 'loggamma']
+
+    distfunc = getattr(stats, dist)
+    loc = np.zeros(2)
+    scale = np.ones((3, 1))
+    nargs = distfunc.numargs
+    allargs = []
+    bshape = [3, 2]
+    # Generate shape parameter arguments...
+    for k in range(nargs):
+        shp = (k + 4,) + (1,)*(k + 2)
+        allargs.append(shape_args[k]*np.ones(shp))
+        bshape.insert(0, k + 4)
+    allargs.extend([loc, scale])
+    # bshape holds the expected shape when loc, scale, and the shape
+    # parameters are all broadcast together.
+
+    check_rvs_broadcast(distfunc, dist, allargs, bshape, shape_only, 'd')
+
+
+# Expected values of the SF, CDF, PDF were computed using
+# mpmath with mpmath.mp.dps = 50 and output at 20:
+#
+# def ks(x, n):
+#     x = mpmath.mpf(x)
+#     logp = -mpmath.power(6.0*n*x+1.0, 2)/18.0/n
+#     sf, cdf = mpmath.exp(logp), -mpmath.expm1(logp)
+#     pdf = (6.0*n*x+1.0) * 2 * sf/3
+#     print(mpmath.nstr(sf, 20), mpmath.nstr(cdf, 20), mpmath.nstr(pdf, 20))
+#
+# Tests use 1/n < x < 1-1/n and n > 1e6 to use the asymptotic computation.
+# Larger x has a smaller sf.
+@pytest.mark.parametrize('x,n,sf,cdf,pdf,rtol',
+                         [(2.0e-5, 1000000000,
+                           0.44932297307934442379, 0.55067702692065557621,
+                           35946.137394996276407, 5e-15),
+                          (2.0e-9, 1000000000,
+                           0.99999999061111115519, 9.3888888448132728224e-9,
+                           8.6666665852962971765, 5e-14),
+                          (5.0e-4, 1000000000,
+                           7.1222019433090374624e-218, 1.0,
+                           1.4244408634752704094e-211, 5e-14)])
+def test_gh17775_regression(x, n, sf, cdf, pdf, rtol):
+    # Regression test for gh-17775. In scipy 1.9.3 and earlier,
+    # these test would fail.
+    #
+    # KS one asymptotic sf ~ e^(-(6nx+1)^2 / 18n)
+    # Given a large 32-bit integer n, 6n will overflow in the c implementation.
+    # Example of broken behaviour:
+    # ksone.sf(2.0e-5, 1000000000) == 0.9374359693473666
+    ks = stats.ksone
+    vals = np.array([ks.sf(x, n), ks.cdf(x, n), ks.pdf(x, n)])
+    expected = np.array([sf, cdf, pdf])
+    npt.assert_allclose(vals, expected, rtol=rtol)
+    # The sf+cdf must sum to 1.0.
+    npt.assert_equal(vals[0] + vals[1], 1.0)
+    # Check inverting the (potentially very small) sf (uses a lower tolerance)
+    npt.assert_allclose([ks.isf(sf, n)], [x], rtol=1e-8)
+
+
+def test_rvs_gh2069_regression():
+    # Regression tests for gh-2069.  In scipy 0.17 and earlier,
+    # these tests would fail.
+    #
+    # A typical example of the broken behavior:
+    # >>> norm.rvs(loc=np.zeros(5), scale=np.ones(5))
+    # array([-2.49613705, -2.49613705, -2.49613705, -2.49613705, -2.49613705])
+    rng = np.random.RandomState(123)
+    vals = stats.norm.rvs(loc=np.zeros(5), scale=1, random_state=rng)
+    d = np.diff(vals)
+    npt.assert_(np.all(d != 0), "All the values are equal, but they shouldn't be!")
+    vals = stats.norm.rvs(loc=0, scale=np.ones(5), random_state=rng)
+    d = np.diff(vals)
+    npt.assert_(np.all(d != 0), "All the values are equal, but they shouldn't be!")
+    vals = stats.norm.rvs(loc=np.zeros(5), scale=np.ones(5), random_state=rng)
+    d = np.diff(vals)
+    npt.assert_(np.all(d != 0), "All the values are equal, but they shouldn't be!")
+    vals = stats.norm.rvs(loc=np.array([[0], [0]]), scale=np.ones(5),
+                          random_state=rng)
+    d = np.diff(vals.ravel())
+    npt.assert_(np.all(d != 0), "All the values are equal, but they shouldn't be!")
+
+    assert_raises(ValueError, stats.norm.rvs, [[0, 0], [0, 0]],
+                  [[1, 1], [1, 1]], 1)
+    assert_raises(ValueError, stats.gamma.rvs, [2, 3, 4, 5], 0, 1, (2, 2))
+    assert_raises(ValueError, stats.gamma.rvs, [1, 1, 1, 1], [0, 0, 0, 0],
+                  [[1], [2]], (4,))
+
+
+def test_nomodify_gh9900_regression():
+    # Regression test for gh-9990
+    # Prior to gh-9990, calls to stats.truncnorm._cdf() use what ever was
+    # set inside the stats.truncnorm instance during stats.truncnorm.cdf().
+    # This could cause issues with multi-threaded code.
+    # Since then, the calls to cdf() are not permitted to modify the global
+    # stats.truncnorm instance.
+    tn = stats.truncnorm
+    # Use the right-half truncated normal
+    # Check that the cdf and _cdf return the same result.
+    npt.assert_almost_equal(tn.cdf(1, 0, np.inf),
+                            0.6826894921370859)
+    npt.assert_almost_equal(tn._cdf([1], [0], [np.inf]),
+                            0.6826894921370859)
+
+    # Now use the left-half truncated normal
+    npt.assert_almost_equal(tn.cdf(-1, -np.inf, 0),
+                            0.31731050786291415)
+    npt.assert_almost_equal(tn._cdf([-1], [-np.inf], [0]),
+                            0.31731050786291415)
+
+    # Check that the right-half truncated normal _cdf hasn't changed
+    npt.assert_almost_equal(tn._cdf([1], [0], [np.inf]),
+                            0.6826894921370859)  # Not 1.6826894921370859
+    npt.assert_almost_equal(tn.cdf(1, 0, np.inf),
+                            0.6826894921370859)
+
+    # Check that the left-half truncated normal _cdf hasn't changed
+    npt.assert_almost_equal(tn._cdf([-1], [-np.inf], [0]),
+                            0.31731050786291415)  # Not -0.6826894921370859
+    npt.assert_almost_equal(tn.cdf(1, -np.inf, 0),
+                            1)  # Not 1.6826894921370859
+    npt.assert_almost_equal(tn.cdf(-1, -np.inf, 0),
+                            0.31731050786291415)  # Not -0.6826894921370859
+
+
+def test_broadcast_gh9990_regression():
+    # Regression test for gh-9990
+    # The x-value 7 only lies within the support of 4 of the supplied
+    # distributions.  Prior to 9990, one array passed to
+    # stats.reciprocal._cdf would have 4 elements, but an array
+    # previously stored by stats.reciprocal_argcheck() would have 6, leading
+    # to a broadcast error.
+    a = np.array([1, 2, 3, 4, 5, 6])
+    b = np.array([8, 16, 1, 32, 1, 48])
+    ans = [stats.reciprocal.cdf(7, _a, _b) for _a, _b in zip(a,b)]
+    npt.assert_array_almost_equal(stats.reciprocal.cdf(7, a, b), ans)
+
+    ans = [stats.reciprocal.cdf(1, _a, _b) for _a, _b in zip(a,b)]
+    npt.assert_array_almost_equal(stats.reciprocal.cdf(1, a, b), ans)
+
+    ans = [stats.reciprocal.cdf(_a, _a, _b) for _a, _b in zip(a,b)]
+    npt.assert_array_almost_equal(stats.reciprocal.cdf(a, a, b), ans)
+
+    ans = [stats.reciprocal.cdf(_b, _a, _b) for _a, _b in zip(a,b)]
+    npt.assert_array_almost_equal(stats.reciprocal.cdf(b, a, b), ans)
+
+
+def test_broadcast_gh7933_regression():
+    # Check broadcast works
+    stats.truncnorm.logpdf(
+        np.array([3.0, 2.0, 1.0]),
+        a=(1.5 - np.array([6.0, 5.0, 4.0])) / 3.0,
+        b=np.inf,
+        loc=np.array([6.0, 5.0, 4.0]),
+        scale=3.0
+    )
+
+
+def test_gh2002_regression():
+    # Add a check that broadcast works in situations where only some
+    # x-values are compatible with some of the shape arguments.
+    x = np.r_[-2:2:101j]
+    a = np.r_[-np.ones(50), np.ones(51)]
+    expected = [stats.truncnorm.pdf(_x, _a, np.inf) for _x, _a in zip(x, a)]
+    ans = stats.truncnorm.pdf(x, a, np.inf)
+    npt.assert_array_almost_equal(ans, expected)
+
+
+def test_gh1320_regression():
+    # Check that the first example from gh-1320 now works.
+    c = 2.62
+    stats.genextreme.ppf(0.5, np.array([[c], [c + 0.5]]))
+    # The other examples in gh-1320 appear to have stopped working
+    # some time ago.
+    # ans = stats.genextreme.moment(2, np.array([c, c + 0.5]))
+    # expected = np.array([25.50105963, 115.11191437])
+    # stats.genextreme.moment(5, np.array([[c], [c + 0.5]]))
+    # stats.genextreme.moment(5, np.array([c, c + 0.5]))
+
+
+def test_method_of_moments():
+    # example from https://en.wikipedia.org/wiki/Method_of_moments_(statistics)
+    np.random.seed(1234)
+    x = [0, 0, 0, 0, 1]
+    a = 1/5 - 2*np.sqrt(3)/5
+    b = 1/5 + 2*np.sqrt(3)/5
+    # force use of method of moments (uniform.fit is overridden)
+    loc, scale = super(type(stats.uniform), stats.uniform).fit(x, method="MM")
+    npt.assert_almost_equal(loc, a, decimal=4)
+    npt.assert_almost_equal(loc+scale, b, decimal=4)
+
+
+def check_sample_meanvar_(popmean, popvar, sample):
+    if np.isfinite(popmean):
+        check_sample_mean(sample, popmean)
+    if np.isfinite(popvar):
+        check_sample_var(sample, popvar)
+
+
+def check_sample_mean(sample, popmean):
+    # Checks for unlikely difference between sample mean and population mean
+    prob = stats.ttest_1samp(sample, popmean).pvalue
+    assert prob > 0.01
+
+
+def check_sample_var(sample, popvar):
+    # check that population mean lies within the CI bootstrapped from the
+    # sample. This used to be a chi-squared test for variance, but there were
+    # too many false positives
+    res = stats.bootstrap(
+        (sample,),
+        lambda x, axis: x.var(ddof=1, axis=axis),
+        confidence_level=0.995,
+    )
+    conf = res.confidence_interval
+    low, high = conf.low, conf.high
+    assert low <= popvar <= high
+
+
+def check_cdf_ppf(distfn, arg, msg):
+    values = [0.001, 0.5, 0.999]
+    npt.assert_almost_equal(distfn.cdf(distfn.ppf(values, *arg), *arg),
+                            values, decimal=DECIMAL, err_msg=msg +
+                            ' - cdf-ppf roundtrip')
+
+
+def check_sf_isf(distfn, arg, msg):
+    npt.assert_almost_equal(distfn.sf(distfn.isf([0.1, 0.5, 0.9], *arg), *arg),
+                            [0.1, 0.5, 0.9], decimal=DECIMAL, err_msg=msg +
+                            ' - sf-isf roundtrip')
+
+
+def check_cdf_sf(distfn, arg, msg):
+    npt.assert_almost_equal(distfn.cdf([0.1, 0.9], *arg),
+                            1.0 - distfn.sf([0.1, 0.9], *arg),
+                            decimal=DECIMAL, err_msg=msg +
+                            ' - cdf-sf relationship')
+
+
+def check_ppf_isf(distfn, arg, msg):
+    p = np.array([0.1, 0.9])
+    npt.assert_almost_equal(distfn.isf(p, *arg), distfn.ppf(1-p, *arg),
+                            decimal=DECIMAL, err_msg=msg +
+                            ' - ppf-isf relationship')
+
+
+def check_pdf(distfn, arg, msg):
+    # compares pdf at median with numerical derivative of cdf
+    median = distfn.ppf(0.5, *arg)
+    eps = 1e-6
+    pdfv = distfn.pdf(median, *arg)
+    if (pdfv < 1e-4) or (pdfv > 1e4):
+        # avoid checking a case where pdf is close to zero or
+        # huge (singularity)
+        median = median + 0.1
+        pdfv = distfn.pdf(median, *arg)
+    cdfdiff = (distfn.cdf(median + eps, *arg) -
+               distfn.cdf(median - eps, *arg))/eps/2.0
+    # replace with better diff and better test (more points),
+    # actually, this works pretty well
+    msg += ' - cdf-pdf relationship'
+    npt.assert_almost_equal(pdfv, cdfdiff, decimal=DECIMAL, err_msg=msg)
+
+
+def check_pdf_logpdf(distfn, args, msg):
+    # compares pdf at several points with the log of the pdf
+    points = np.array([0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8])
+    vals = distfn.ppf(points, *args)
+    vals = vals[np.isfinite(vals)]
+    pdf = distfn.pdf(vals, *args)
+    logpdf = distfn.logpdf(vals, *args)
+    pdf = pdf[(pdf != 0) & np.isfinite(pdf)]
+    logpdf = logpdf[np.isfinite(logpdf)]
+    msg += " - logpdf-log(pdf) relationship"
+    npt.assert_almost_equal(np.log(pdf), logpdf, decimal=7, err_msg=msg)
+
+
+def check_pdf_logpdf_at_endpoints(distfn, args, msg):
+    # compares pdf with the log of the pdf at the (finite) end points
+    points = np.array([0, 1])
+    vals = distfn.ppf(points, *args)
+    vals = vals[np.isfinite(vals)]
+    pdf = distfn.pdf(vals, *args)
+    logpdf = distfn.logpdf(vals, *args)
+    pdf = pdf[(pdf != 0) & np.isfinite(pdf)]
+    logpdf = logpdf[np.isfinite(logpdf)]
+    msg += " - logpdf-log(pdf) relationship"
+    npt.assert_almost_equal(np.log(pdf), logpdf, decimal=7, err_msg=msg)
+
+
+def check_sf_logsf(distfn, args, msg):
+    # compares sf at several points with the log of the sf
+    points = np.array([0.0, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 1.0])
+    vals = distfn.ppf(points, *args)
+    vals = vals[np.isfinite(vals)]
+    sf = distfn.sf(vals, *args)
+    logsf = distfn.logsf(vals, *args)
+    sf = sf[sf != 0]
+    logsf = logsf[np.isfinite(logsf)]
+    msg += " - logsf-log(sf) relationship"
+    npt.assert_almost_equal(np.log(sf), logsf, decimal=7, err_msg=msg)
+
+
+def check_cdf_logcdf(distfn, args, msg):
+    # compares cdf at several points with the log of the cdf
+    points = np.array([0, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 1.0])
+    vals = distfn.ppf(points, *args)
+    vals = vals[np.isfinite(vals)]
+    cdf = distfn.cdf(vals, *args)
+    logcdf = distfn.logcdf(vals, *args)
+    cdf = cdf[cdf != 0]
+    logcdf = logcdf[np.isfinite(logcdf)]
+    msg += " - logcdf-log(cdf) relationship"
+    npt.assert_almost_equal(np.log(cdf), logcdf, decimal=7, err_msg=msg)
+
+
+def check_ppf_broadcast(distfn, arg, msg):
+    # compares ppf for multiple argsets.
+    num_repeats = 5
+    args = [] * num_repeats
+    if arg:
+        args = [np.array([_] * num_repeats) for _ in arg]
+
+    median = distfn.ppf(0.5, *arg)
+    medians = distfn.ppf(0.5, *args)
+    msg += " - ppf multiple"
+    npt.assert_almost_equal(medians, [median] * num_repeats, decimal=7, err_msg=msg)
+
+
+def check_distribution_rvs(dist, args, alpha, rvs):
+    # dist is either a cdf function or name of a distribution in scipy.stats.
+    # args are the args for scipy.stats.dist(*args)
+    # alpha is a significance level, ~0.01
+    # rvs is array_like of random variables
+    # test from scipy.stats.tests
+    # this version reuses existing random variables
+    D, pval = stats.kstest(rvs, dist, args=args, N=1000)
+    if (pval < alpha):
+        # The rvs passed in failed the K-S test, which _could_ happen
+        # but is unlikely if alpha is small enough.
+        # Repeat the test with a new sample of rvs.
+        # Generate 1000 rvs, perform a K-S test that the new sample of rvs
+        # are distributed according to the distribution.
+        D, pval = stats.kstest(dist, dist, args=args, N=1000)
+        npt.assert_(pval > alpha, "D = " + str(D) + "; pval = " + str(pval) +
+                    "; alpha = " + str(alpha) + "\nargs = " + str(args))
+
+
+def check_vecentropy(distfn, args):
+    npt.assert_equal(distfn.vecentropy(*args), distfn._entropy(*args))
+
+
+def check_loc_scale(distfn, arg, m, v, msg):
+    # Make `loc` and `scale` arrays to catch bugs like gh-13580 where
+    # `loc` and `scale` arrays improperly broadcast with shapes.
+    loc, scale = np.array([10.0, 20.0]), np.array([10.0, 20.0])
+    mt, vt = distfn.stats(*arg, loc=loc, scale=scale)
+    npt.assert_allclose(m*scale + loc, mt)
+    npt.assert_allclose(v*scale*scale, vt)
+
+
+def check_ppf_private(distfn, arg, msg):
+    # fails by design for truncnorm self.nb not defined
+    ppfs = distfn._ppf(np.array([0.1, 0.5, 0.9]), *arg)
+    npt.assert_(not np.any(np.isnan(ppfs)), msg + 'ppf private is nan')
+
+
+def check_retrieving_support(distfn, args):
+    loc, scale = 1, 2
+    supp = distfn.support(*args)
+    supp_loc_scale = distfn.support(*args, loc=loc, scale=scale)
+    npt.assert_almost_equal(np.array(supp)*scale + loc,
+                            np.array(supp_loc_scale))
+
+
+def check_fit_args(distfn, arg, rvs, method):
+    with np.errstate(all='ignore'), npt.suppress_warnings() as sup:
+        sup.filter(category=RuntimeWarning,
+                   message="The shape parameter of the erlang")
+        sup.filter(category=RuntimeWarning,
+                   message="floating point number truncated")
+        vals = distfn.fit(rvs, method=method)
+        vals2 = distfn.fit(rvs, optimizer='powell', method=method)
+    # Only check the length of the return; accuracy tested in test_fit.py
+    npt.assert_(len(vals) == 2+len(arg))
+    npt.assert_(len(vals2) == 2+len(arg))
+
+
+def check_fit_args_fix(distfn, arg, rvs, method):
+    with np.errstate(all='ignore'), npt.suppress_warnings() as sup:
+        sup.filter(category=RuntimeWarning,
+                   message="The shape parameter of the erlang")
+
+        vals = distfn.fit(rvs, floc=0, method=method)
+        vals2 = distfn.fit(rvs, fscale=1, method=method)
+        npt.assert_(len(vals) == 2+len(arg))
+        npt.assert_(vals[-2] == 0)
+        npt.assert_(vals2[-1] == 1)
+        npt.assert_(len(vals2) == 2+len(arg))
+        if len(arg) > 0:
+            vals3 = distfn.fit(rvs, f0=arg[0], method=method)
+            npt.assert_(len(vals3) == 2+len(arg))
+            npt.assert_(vals3[0] == arg[0])
+        if len(arg) > 1:
+            vals4 = distfn.fit(rvs, f1=arg[1], method=method)
+            npt.assert_(len(vals4) == 2+len(arg))
+            npt.assert_(vals4[1] == arg[1])
+        if len(arg) > 2:
+            vals5 = distfn.fit(rvs, f2=arg[2], method=method)
+            npt.assert_(len(vals5) == 2+len(arg))
+            npt.assert_(vals5[2] == arg[2])
+
+
+@pytest.mark.parametrize('method', ['pdf', 'logpdf', 'cdf', 'logcdf',
+                                    'sf', 'logsf', 'ppf', 'isf'])
+@pytest.mark.parametrize('distname, args', distcont)
+def test_methods_with_lists(method, distname, args):
+    # Test that the continuous distributions can accept Python lists
+    # as arguments.
+    dist = getattr(stats, distname)
+    f = getattr(dist, method)
+    if distname == 'invweibull' and method.startswith('log'):
+        x = [1.5, 2]
+    else:
+        x = [0.1, 0.2]
+
+    shape2 = [[a]*2 for a in args]
+    loc = [0, 0.1]
+    scale = [1, 1.01]
+    result = f(x, *shape2, loc=loc, scale=scale)
+    npt.assert_allclose(result,
+                        [f(*v) for v in zip(x, *shape2, loc, scale)],
+                        rtol=1e-14, atol=5e-14)
+
+
+def test_burr_fisk_moment_gh13234_regression():
+    vals0 = stats.burr.moment(1, 5, 4)
+    assert isinstance(vals0, float)
+
+    vals1 = stats.fisk.moment(1, 8)
+    assert isinstance(vals1, float)
+
+
+def test_moments_with_array_gh12192_regression():
+    # array loc and scalar scale
+    vals0 = stats.norm.moment(order=1, loc=np.array([1, 2, 3]), scale=1)
+    expected0 = np.array([1., 2., 3.])
+    npt.assert_equal(vals0, expected0)
+
+    # array loc and invalid scalar scale
+    vals1 = stats.norm.moment(order=1, loc=np.array([1, 2, 3]), scale=-1)
+    expected1 = np.array([np.nan, np.nan, np.nan])
+    npt.assert_equal(vals1, expected1)
+
+    # array loc and array scale with invalid entries
+    vals2 = stats.norm.moment(order=1, loc=np.array([1, 2, 3]),
+                              scale=[-3, 1, 0])
+    expected2 = np.array([np.nan, 2., np.nan])
+    npt.assert_equal(vals2, expected2)
+
+    # (loc == 0) & (scale < 0)
+    vals3 = stats.norm.moment(order=2, loc=0, scale=-4)
+    expected3 = np.nan
+    npt.assert_equal(vals3, expected3)
+    assert isinstance(vals3, expected3.__class__)
+
+    # array loc with 0 entries and scale with invalid entries
+    vals4 = stats.norm.moment(order=2, loc=[1, 0, 2], scale=[3, -4, -5])
+    expected4 = np.array([10., np.nan, np.nan])
+    npt.assert_equal(vals4, expected4)
+
+    # all(loc == 0) & (array scale with invalid entries)
+    vals5 = stats.norm.moment(order=2, loc=[0, 0, 0], scale=[5., -2, 100.])
+    expected5 = np.array([25., np.nan, 10000.])
+    npt.assert_equal(vals5, expected5)
+
+    # all( (loc == 0) & (scale < 0) )
+    vals6 = stats.norm.moment(order=2, loc=[0, 0, 0], scale=[-5., -2, -100.])
+    expected6 = np.array([np.nan, np.nan, np.nan])
+    npt.assert_equal(vals6, expected6)
+
+    # scalar args, loc, and scale
+    vals7 = stats.chi.moment(order=2, df=1, loc=0, scale=0)
+    expected7 = np.nan
+    npt.assert_equal(vals7, expected7)
+    assert isinstance(vals7, expected7.__class__)
+
+    # array args, scalar loc, and scalar scale
+    vals8 = stats.chi.moment(order=2, df=[1, 2, 3], loc=0, scale=0)
+    expected8 = np.array([np.nan, np.nan, np.nan])
+    npt.assert_equal(vals8, expected8)
+
+    # array args, array loc, and array scale
+    vals9 = stats.chi.moment(order=2, df=[1, 2, 3], loc=[1., 0., 2.],
+                             scale=[1., -3., 0.])
+    expected9 = np.array([3.59576912, np.nan, np.nan])
+    npt.assert_allclose(vals9, expected9, rtol=1e-8)
+
+    # (n > 4), all(loc != 0), and all(scale != 0)
+    vals10 = stats.norm.moment(5, [1., 2.], [1., 2.])
+    expected10 = np.array([26., 832.])
+    npt.assert_allclose(vals10, expected10, rtol=1e-13)
+
+    # test broadcasting and more
+    a = [-1.1, 0, 1, 2.2, np.pi]
+    b = [-1.1, 0, 1, 2.2, np.pi]
+    loc = [-1.1, 0, np.sqrt(2)]
+    scale = [-2.1, 0, 1, 2.2, np.pi]
+
+    a = np.array(a).reshape((-1, 1, 1, 1))
+    b = np.array(b).reshape((-1, 1, 1))
+    loc = np.array(loc).reshape((-1, 1))
+    scale = np.array(scale)
+
+    vals11 = stats.beta.moment(order=2, a=a, b=b, loc=loc, scale=scale)
+
+    a, b, loc, scale = np.broadcast_arrays(a, b, loc, scale)
+
+    for i in np.ndenumerate(a):
+        with np.errstate(invalid='ignore', divide='ignore'):
+            i = i[0]  # just get the index
+            # check against same function with scalar input
+            expected = stats.beta.moment(order=2, a=a[i], b=b[i],
+                                         loc=loc[i], scale=scale[i])
+            np.testing.assert_equal(vals11[i], expected)
+
+
+def test_broadcasting_in_moments_gh12192_regression():
+    vals0 = stats.norm.moment(order=1, loc=np.array([1, 2, 3]), scale=[[1]])
+    expected0 = np.array([[1., 2., 3.]])
+    npt.assert_equal(vals0, expected0)
+    assert vals0.shape == expected0.shape
+
+    vals1 = stats.norm.moment(order=1, loc=np.array([[1], [2], [3]]),
+                              scale=[1, 2, 3])
+    expected1 = np.array([[1., 1., 1.], [2., 2., 2.], [3., 3., 3.]])
+    npt.assert_equal(vals1, expected1)
+    assert vals1.shape == expected1.shape
+
+    vals2 = stats.chi.moment(order=1, df=[1., 2., 3.], loc=0., scale=1.)
+    expected2 = np.array([0.79788456, 1.25331414, 1.59576912])
+    npt.assert_allclose(vals2, expected2, rtol=1e-8)
+    assert vals2.shape == expected2.shape
+
+    vals3 = stats.chi.moment(order=1, df=[[1.], [2.], [3.]], loc=[0., 1., 2.],
+                             scale=[-1., 0., 3.])
+    expected3 = np.array([[np.nan, np.nan, 4.39365368],
+                          [np.nan, np.nan, 5.75994241],
+                          [np.nan, np.nan, 6.78730736]])
+    npt.assert_allclose(vals3, expected3, rtol=1e-8)
+    assert vals3.shape == expected3.shape
+
+
+def test_kappa3_array_gh13582():
+    # https://github.com/scipy/scipy/pull/15140#issuecomment-994958241
+    shapes = [0.5, 1.5, 2.5, 3.5, 4.5]
+    moments = 'mvsk'
+    res = np.array([[stats.kappa3.stats(shape, moments=moment)
+                   for shape in shapes] for moment in moments])
+    res2 = np.array(stats.kappa3.stats(shapes, moments=moments))
+    npt.assert_allclose(res, res2)
+
+
+@pytest.mark.xslow
+def test_kappa4_array_gh13582():
+    h = np.array([-0.5, 2.5, 3.5, 4.5, -3])
+    k = np.array([-0.5, 1, -1.5, 0, 3.5])
+    moments = 'mvsk'
+    res = np.array([[stats.kappa4.stats(h[i], k[i], moments=moment)
+                   for i in range(5)] for moment in moments])
+    res2 = np.array(stats.kappa4.stats(h, k, moments=moments))
+    npt.assert_allclose(res, res2)
+
+    # https://github.com/scipy/scipy/pull/15250#discussion_r775112913
+    h = np.array([-1, -1/4, -1/4, 1, -1, 0])
+    k = np.array([1, 1, 1/2, -1/3, -1, 0])
+    res = np.array([[stats.kappa4.stats(h[i], k[i], moments=moment)
+                   for i in range(6)] for moment in moments])
+    res2 = np.array(stats.kappa4.stats(h, k, moments=moments))
+    npt.assert_allclose(res, res2)
+
+    # https://github.com/scipy/scipy/pull/15250#discussion_r775115021
+    h = np.array([-1, -0.5, 1])
+    k = np.array([-1, -0.5, 0, 1])[:, None]
+    res2 = np.array(stats.kappa4.stats(h, k, moments=moments))
+    assert res2.shape == (4, 4, 3)
+
+
+def test_frozen_attributes():
+    # gh-14827 reported that all frozen distributions had both pmf and pdf
+    # attributes; continuous should have pdf and discrete should have pmf.
+    message = "'rv_continuous_frozen' object has no attribute"
+    with pytest.raises(AttributeError, match=message):
+        stats.norm().pmf
+    with pytest.raises(AttributeError, match=message):
+        stats.norm().logpmf
+    stats.norm.pmf = "herring"
+    frozen_norm = stats.norm()
+    assert isinstance(frozen_norm, rv_continuous_frozen)
+    delattr(stats.norm, 'pmf')
+
+
+def test_skewnorm_pdf_gh16038():
+    rng = np.random.default_rng(0)
+    x, a = -np.inf, 0
+    npt.assert_equal(stats.skewnorm.pdf(x, a), stats.norm.pdf(x))
+    x, a = rng.random(size=(3, 3)), rng.random(size=(3, 3))
+    mask = rng.random(size=(3, 3)) < 0.5
+    a[mask] = 0
+    x_norm = x[mask]
+    res = stats.skewnorm.pdf(x, a)
+    npt.assert_equal(res[mask], stats.norm.pdf(x_norm))
+    npt.assert_equal(res[~mask], stats.skewnorm.pdf(x[~mask], a[~mask]))
+
+
+# for scalar input, these functions should return scalar output
+scalar_out = [['rvs', []], ['pdf', [0]], ['logpdf', [0]], ['cdf', [0]],
+              ['logcdf', [0]], ['sf', [0]], ['logsf', [0]], ['ppf', [0]],
+              ['isf', [0]], ['moment', [1]], ['entropy', []], ['expect', []],
+              ['median', []], ['mean', []], ['std', []], ['var', []]]
+scalars_out = [['interval', [0.95]], ['support', []], ['stats', ['mv']]]
+
+
+@pytest.mark.parametrize('case', scalar_out + scalars_out)
+def test_scalar_for_scalar(case):
+    # Some rv_continuous functions returned 0d array instead of NumPy scalar
+    # Guard against regression
+    method_name, args = case
+    method = getattr(stats.norm(), method_name)
+    res = method(*args)
+    if case in scalar_out:
+        assert isinstance(res, np.number)
+    else:
+        assert isinstance(res[0], np.number)
+        assert isinstance(res[1], np.number)
+
+
+def test_scalar_for_scalar2():
+    # test methods that are not attributes of frozen distributions
+    res = stats.norm.fit([1, 2, 3])
+    assert isinstance(res[0], np.number)
+    assert isinstance(res[1], np.number)
+    res = stats.norm.fit_loc_scale([1, 2, 3])
+    assert isinstance(res[0], np.number)
+    assert isinstance(res[1], np.number)
+    res = stats.norm.nnlf((0, 1), [1, 2, 3])
+    assert isinstance(res, np.number)

.venv/Lib/site-packages/scipy/stats/tests/test_continuous_fit_censored.py

@@ -0,0 +1,683 @@
+# Tests for fitting specific distributions to censored data.
+
+import numpy as np
+from numpy.testing import assert_allclose
+
+from scipy.optimize import fmin
+from scipy.stats import (CensoredData, beta, cauchy, chi2, expon, gamma,
+                         gumbel_l, gumbel_r, invgauss, invweibull, laplace,
+                         logistic, lognorm, nct, ncx2, norm, weibull_max,
+                         weibull_min)
+
+
+# In some tests, we'll use this optimizer for improved accuracy.
+def optimizer(func, x0, args=(), disp=0):
+    return fmin(func, x0, args=args, disp=disp, xtol=1e-12, ftol=1e-12)
+
+
+def test_beta():
+    """
+    Test fitting beta shape parameters to interval-censored data.
+
+    Calculation in R:
+
+    > library(fitdistrplus)
+    > data <- data.frame(left=c(0.10, 0.50, 0.75, 0.80),
+    +                    right=c(0.20, 0.55, 0.90, 0.95))
+    > result = fitdistcens(data, 'beta', control=list(reltol=1e-14))
+
+    > result
+    Fitting of the distribution ' beta ' on censored data by maximum likelihood
+    Parameters:
+           estimate
+    shape1 1.419941
+    shape2 1.027066
+    > result$sd
+       shape1    shape2
+    0.9914177 0.6866565
+    """
+    data = CensoredData(interval=[[0.10, 0.20],
+                                  [0.50, 0.55],
+                                  [0.75, 0.90],
+                                  [0.80, 0.95]])
+
+    # For this test, fit only the shape parameters; loc and scale are fixed.
+    a, b, loc, scale = beta.fit(data, floc=0, fscale=1, optimizer=optimizer)
+
+    assert_allclose(a, 1.419941, rtol=5e-6)
+    assert_allclose(b, 1.027066, rtol=5e-6)
+    assert loc == 0
+    assert scale == 1
+
+
+def test_cauchy_right_censored():
+    """
+    Test fitting the Cauchy distribution to right-censored data.
+
+    Calculation in R, with two values not censored [1, 10] and
+    one right-censored value [30].
+
+    > library(fitdistrplus)
+    > data <- data.frame(left=c(1, 10, 30), right=c(1, 10, NA))
+    > result = fitdistcens(data, 'cauchy', control=list(reltol=1e-14))
+    > result
+    Fitting of the distribution ' cauchy ' on censored data by maximum
+    likelihood
+    Parameters:
+             estimate
+    location 7.100001
+    scale    7.455866
+    """
+    data = CensoredData(uncensored=[1, 10], right=[30])
+    loc, scale = cauchy.fit(data, optimizer=optimizer)
+    assert_allclose(loc, 7.10001, rtol=5e-6)
+    assert_allclose(scale, 7.455866, rtol=5e-6)
+
+
+def test_cauchy_mixed():
+    """
+    Test fitting the Cauchy distribution to data with mixed censoring.
+
+    Calculation in R, with:
+    * two values not censored [1, 10],
+    * one left-censored [1],
+    * one right-censored [30], and
+    * one interval-censored [[4, 8]].
+
+    > library(fitdistrplus)
+    > data <- data.frame(left=c(NA, 1, 4, 10, 30), right=c(1, 1, 8, 10, NA))
+    > result = fitdistcens(data, 'cauchy', control=list(reltol=1e-14))
+    > result
+    Fitting of the distribution ' cauchy ' on censored data by maximum
+    likelihood
+    Parameters:
+             estimate
+    location 4.605150
+    scale    5.900852
+    """
+    data = CensoredData(uncensored=[1, 10], left=[1], right=[30],
+                        interval=[[4, 8]])
+    loc, scale = cauchy.fit(data, optimizer=optimizer)
+    assert_allclose(loc, 4.605150, rtol=5e-6)
+    assert_allclose(scale, 5.900852, rtol=5e-6)
+
+
+def test_chi2_mixed():
+    """
+    Test fitting just the shape parameter (df) of chi2 to mixed data.
+
+    Calculation in R, with:
+    * two values not censored [1, 10],
+    * one left-censored [1],
+    * one right-censored [30], and
+    * one interval-censored [[4, 8]].
+
+    > library(fitdistrplus)
+    > data <- data.frame(left=c(NA, 1, 4, 10, 30), right=c(1, 1, 8, 10, NA))
+    > result = fitdistcens(data, 'chisq', control=list(reltol=1e-14))
+    > result
+    Fitting of the distribution ' chisq ' on censored data by maximum
+    likelihood
+    Parameters:
+             estimate
+    df 5.060329
+    """
+    data = CensoredData(uncensored=[1, 10], left=[1], right=[30],
+                        interval=[[4, 8]])
+    df, loc, scale = chi2.fit(data, floc=0, fscale=1, optimizer=optimizer)
+    assert_allclose(df, 5.060329, rtol=5e-6)
+    assert loc == 0
+    assert scale == 1
+
+
+def test_expon_right_censored():
+    """
+    For the exponential distribution with loc=0, the exact solution for
+    fitting n uncensored points x[0]...x[n-1] and m right-censored points
+    x[n]..x[n+m-1] is
+
+        scale = sum(x)/n
+
+    That is, divide the sum of all the values (not censored and
+    right-censored) by the number of uncensored values.  (See, for example,
+    https://en.wikipedia.org/wiki/Censoring_(statistics)#Likelihood.)
+
+    The second derivative of the log-likelihood function is
+
+        n/scale**2 - 2*sum(x)/scale**3
+
+    from which the estimate of the standard error can be computed.
+
+    -----
+
+    Calculation in R, for reference only. The R results are not
+    used in the test.
+
+    > library(fitdistrplus)
+    > dexps <- function(x, scale) {
+    +     return(dexp(x, 1/scale))
+    + }
+    > pexps <- function(q, scale) {
+    +     return(pexp(q, 1/scale))
+    + }
+    > left <- c(1, 2.5, 3, 6, 7.5, 10, 12, 12, 14.5, 15,
+    +                                     16, 16, 20, 20, 21, 22)
+    > right <- c(1, 2.5, 3, 6, 7.5, 10, 12, 12, 14.5, 15,
+    +                                     NA, NA, NA, NA, NA, NA)
+    > result = fitdistcens(data, 'exps', start=list(scale=mean(data$left)),
+    +                      control=list(reltol=1e-14))
+    > result
+    Fitting of the distribution ' exps ' on censored data by maximum likelihood
+    Parameters:
+          estimate
+    scale    19.85
+    > result$sd
+       scale
+    6.277119
+    """
+    # This data has 10 uncensored values and 6 right-censored values.
+    obs = [1, 2.5, 3, 6, 7.5, 10, 12, 12, 14.5, 15, 16, 16, 20, 20, 21, 22]
+    cens = [False]*10 + [True]*6
+    data = CensoredData.right_censored(obs, cens)
+
+    loc, scale = expon.fit(data, floc=0, optimizer=optimizer)
+
+    assert loc == 0
+    # Use the analytical solution to compute the expected value.  This
+    # is the sum of the observed values divided by the number of uncensored
+    # values.
+    n = len(data) - data.num_censored()
+    total = data._uncensored.sum() + data._right.sum()
+    expected = total / n
+    assert_allclose(scale, expected, 1e-8)
+
+
+def test_gamma_right_censored():
+    """
+    Fit gamma shape and scale to data with one right-censored value.
+
+    Calculation in R:
+
+    > library(fitdistrplus)
+    > data <- data.frame(left=c(2.5, 2.9, 3.8, 9.1, 9.3, 12.0, 23.0, 25.0),
+    +                    right=c(2.5, 2.9, 3.8, 9.1, 9.3, 12.0, 23.0, NA))
+    > result = fitdistcens(data, 'gamma', start=list(shape=1, scale=10),
+    +                      control=list(reltol=1e-13))
+    > result
+    Fitting of the distribution ' gamma ' on censored data by maximum
+      likelihood
+    Parameters:
+          estimate
+    shape 1.447623
+    scale 8.360197
+    > result$sd
+        shape     scale
+    0.7053086 5.1016531
+    """
+    # The last value is right-censored.
+    x = CensoredData.right_censored([2.5, 2.9, 3.8, 9.1, 9.3, 12.0, 23.0,
+                                     25.0],
+                                    [0]*7 + [1])
+
+    a, loc, scale = gamma.fit(x, floc=0, optimizer=optimizer)
+
+    assert_allclose(a, 1.447623, rtol=5e-6)
+    assert loc == 0
+    assert_allclose(scale, 8.360197, rtol=5e-6)
+
+
+def test_gumbel():
+    """
+    Fit gumbel_l and gumbel_r to censored data.
+
+    This R calculation should match gumbel_r.
+
+    > library(evd)
+    > library(fitdistrplus)
+    > data = data.frame(left=c(0, 2, 3, 9, 10, 10),
+    +                   right=c(1, 2, 3, 9, NA, NA))
+    > result = fitdistcens(data, 'gumbel',
+    +                      control=list(reltol=1e-14),
+    +                      start=list(loc=4, scale=5))
+    > result
+    Fitting of the distribution ' gumbel ' on censored data by maximum
+    likelihood
+    Parameters:
+          estimate
+    loc   4.487853
+    scale 4.843640
+    """
+    # First value is interval-censored. Last two are right-censored.
+    uncensored = np.array([2, 3, 9])
+    right = np.array([10, 10])
+    interval = np.array([[0, 1]])
+    data = CensoredData(uncensored, right=right, interval=interval)
+    loc, scale = gumbel_r.fit(data, optimizer=optimizer)
+    assert_allclose(loc, 4.487853, rtol=5e-6)
+    assert_allclose(scale, 4.843640, rtol=5e-6)
+
+    # Negate the data and reverse the intervals, and test with gumbel_l.
+    data2 = CensoredData(-uncensored, left=-right,
+                         interval=-interval[:, ::-1])
+    # Fitting gumbel_l to data2 should give the same result as above, but
+    # with loc negated.
+    loc2, scale2 = gumbel_l.fit(data2, optimizer=optimizer)
+    assert_allclose(loc2, -4.487853, rtol=5e-6)
+    assert_allclose(scale2, 4.843640, rtol=5e-6)
+
+
+def test_invgauss():
+    """
+    Fit just the shape parameter of invgauss to data with one value
+    left-censored and one value right-censored.
+
+    Calculation in R; using a fixed dispersion parameter amounts to fixing
+    the scale to be 1.
+
+    > library(statmod)
+    > library(fitdistrplus)
+    > left <- c(NA, 0.4813096, 0.5571880, 0.5132463, 0.3801414, 0.5904386,
+    +           0.4822340, 0.3478597, 3, 0.7191797, 1.5810902, 0.4442299)
+    > right <- c(0.15, 0.4813096, 0.5571880, 0.5132463, 0.3801414, 0.5904386,
+    +            0.4822340, 0.3478597, NA, 0.7191797, 1.5810902, 0.4442299)
+    > data <- data.frame(left=left, right=right)
+    > result = fitdistcens(data, 'invgauss', control=list(reltol=1e-12),
+    +                      fix.arg=list(dispersion=1), start=list(mean=3))
+    > result
+    Fitting of the distribution ' invgauss ' on censored data by maximum
+      likelihood
+    Parameters:
+         estimate
+    mean 0.853469
+    Fixed parameters:
+               value
+    dispersion     1
+    > result$sd
+        mean
+    0.247636
+
+    Here's the R calculation with the dispersion as a free parameter to
+    be fit.
+
+    > result = fitdistcens(data, 'invgauss', control=list(reltol=1e-12),
+    +                      start=list(mean=3, dispersion=1))
+    > result
+    Fitting of the distribution ' invgauss ' on censored data by maximum
+    likelihood
+    Parameters:
+                estimate
+    mean       0.8699819
+    dispersion 1.2261362
+
+    The parametrization of the inverse Gaussian distribution in the
+    `statmod` package is not the same as in SciPy (see
+        https://arxiv.org/abs/1603.06687
+    for details).  The translation from R to SciPy is
+
+        scale = 1/dispersion
+        mu    = mean * dispersion
+
+    > 1/result$estimate['dispersion']  # 1/dispersion
+    dispersion
+     0.8155701
+    > result$estimate['mean'] * result$estimate['dispersion']
+        mean
+    1.066716
+
+    Those last two values are the SciPy scale and shape parameters.
+    """
+    # One point is left-censored, and one is right-censored.
+    x = [0.4813096, 0.5571880, 0.5132463, 0.3801414,
+         0.5904386, 0.4822340, 0.3478597, 0.7191797,
+         1.5810902, 0.4442299]
+    data = CensoredData(uncensored=x, left=[0.15], right=[3])
+
+    # Fit only the shape parameter.
+    mu, loc, scale = invgauss.fit(data, floc=0, fscale=1, optimizer=optimizer)
+
+    assert_allclose(mu, 0.853469, rtol=5e-5)
+    assert loc == 0
+    assert scale == 1
+
+    # Fit the shape and scale.
+    mu, loc, scale = invgauss.fit(data, floc=0, optimizer=optimizer)
+
+    assert_allclose(mu, 1.066716, rtol=5e-5)
+    assert loc == 0
+    assert_allclose(scale, 0.8155701, rtol=5e-5)
+
+
+def test_invweibull():
+    """
+    Fit invweibull to censored data.
+
+    Here is the calculation in R.  The 'frechet' distribution from the evd
+    package matches SciPy's invweibull distribution.  The `loc` parameter
+    is fixed at 0.
+
+    > library(evd)
+    > library(fitdistrplus)
+    > data = data.frame(left=c(0, 2, 3, 9, 10, 10),
+    +                   right=c(1, 2, 3, 9, NA, NA))
+    > result = fitdistcens(data, 'frechet',
+    +                      control=list(reltol=1e-14),
+    +                      start=list(loc=4, scale=5))
+    > result
+    Fitting of the distribution ' frechet ' on censored data by maximum
+    likelihood
+    Parameters:
+           estimate
+    scale 2.7902200
+    shape 0.6379845
+    Fixed parameters:
+        value
+    loc     0
+    """
+    # In the R data, the first value is interval-censored, and the last
+    # two are right-censored.  The rest are not censored.
+    data = CensoredData(uncensored=[2, 3, 9], right=[10, 10],
+                        interval=[[0, 1]])
+    c, loc, scale = invweibull.fit(data, floc=0, optimizer=optimizer)
+    assert_allclose(c, 0.6379845, rtol=5e-6)
+    assert loc == 0
+    assert_allclose(scale, 2.7902200, rtol=5e-6)
+
+
+def test_laplace():
+    """
+    Fir the Laplace distribution to left- and right-censored data.
+
+    Calculation in R:
+
+    > library(fitdistrplus)
+    > dlaplace <- function(x, location=0, scale=1) {
+    +     return(0.5*exp(-abs((x - location)/scale))/scale)
+    + }
+    > plaplace <- function(q, location=0, scale=1) {
+    +     z <- (q - location)/scale
+    +     s <- sign(z)
+    +     f <- -s*0.5*exp(-abs(z)) + (s+1)/2
+    +     return(f)
+    + }
+    > left <- c(NA, -41.564, 50.0, 15.7384, 50.0, 10.0452, -2.0684,
+    +           -19.5399, 50.0,   9.0005, 27.1227, 4.3113, -3.7372,
+    +           25.3111, 14.7987,  34.0887,  50.0, 42.8496, 18.5862,
+    +           32.8921, 9.0448, -27.4591, NA, 19.5083, -9.7199)
+    > right <- c(-50.0, -41.564,  NA, 15.7384, NA, 10.0452, -2.0684,
+    +            -19.5399, NA, 9.0005, 27.1227, 4.3113, -3.7372,
+    +            25.3111, 14.7987, 34.0887, NA,  42.8496, 18.5862,
+    +            32.8921, 9.0448, -27.4591, -50.0, 19.5083, -9.7199)
+    > data <- data.frame(left=left, right=right)
+    > result <- fitdistcens(data, 'laplace', start=list(location=10, scale=10),
+    +                       control=list(reltol=1e-13))
+    > result
+    Fitting of the distribution ' laplace ' on censored data by maximum
+      likelihood
+    Parameters:
+             estimate
+    location 14.79870
+    scale    30.93601
+    > result$sd
+         location     scale
+    0.1758864 7.0972125
+    """
+    # The value -50 is left-censored, and the value 50 is right-censored.
+    obs = np.array([-50.0, -41.564, 50.0, 15.7384, 50.0, 10.0452, -2.0684,
+                    -19.5399, 50.0, 9.0005, 27.1227, 4.3113, -3.7372,
+                    25.3111, 14.7987, 34.0887, 50.0, 42.8496, 18.5862,
+                    32.8921, 9.0448, -27.4591, -50.0, 19.5083, -9.7199])
+    x = obs[(obs != -50.0) & (obs != 50)]
+    left = obs[obs == -50.0]
+    right = obs[obs == 50.0]
+    data = CensoredData(uncensored=x, left=left, right=right)
+    loc, scale = laplace.fit(data, loc=10, scale=10, optimizer=optimizer)
+    assert_allclose(loc, 14.79870, rtol=5e-6)
+    assert_allclose(scale, 30.93601, rtol=5e-6)
+
+
+def test_logistic():
+    """
+    Fit the logistic distribution to left-censored data.
+
+    Calculation in R:
+    > library(fitdistrplus)
+    > left = c(13.5401, 37.4235, 11.906 , 13.998 ,  NA    ,  0.4023,  NA    ,
+    +          10.9044, 21.0629,  9.6985,  NA    , 12.9016, 39.164 , 34.6396,
+    +          NA    , 20.3665, 16.5889, 18.0952, 45.3818, 35.3306,  8.4949,
+    +          3.4041,  NA    ,  7.2828, 37.1265,  6.5969, 17.6868, 17.4977,
+    +          16.3391, 36.0541)
+    > right = c(13.5401, 37.4235, 11.906 , 13.998 ,  0.    ,  0.4023,  0.    ,
+    +           10.9044, 21.0629,  9.6985,  0.    , 12.9016, 39.164 , 34.6396,
+    +           0.    , 20.3665, 16.5889, 18.0952, 45.3818, 35.3306,  8.4949,
+    +           3.4041,  0.    ,  7.2828, 37.1265,  6.5969, 17.6868, 17.4977,
+    +           16.3391, 36.0541)
+    > data = data.frame(left=left, right=right)
+    > result = fitdistcens(data, 'logis', control=list(reltol=1e-14))
+    > result
+    Fitting of the distribution ' logis ' on censored data by maximum
+      likelihood
+    Parameters:
+              estimate
+    location 14.633459
+    scale     9.232736
+    > result$sd
+    location    scale
+    2.931505 1.546879
+    """
+    # Values that are zero are left-censored; the true values are less than 0.
+    x = np.array([13.5401, 37.4235, 11.906, 13.998, 0.0, 0.4023, 0.0, 10.9044,
+                  21.0629, 9.6985, 0.0, 12.9016, 39.164, 34.6396, 0.0, 20.3665,
+                  16.5889, 18.0952, 45.3818, 35.3306, 8.4949, 3.4041, 0.0,
+                  7.2828, 37.1265, 6.5969, 17.6868, 17.4977, 16.3391,
+                  36.0541])
+    data = CensoredData.left_censored(x, censored=(x == 0))
+    loc, scale = logistic.fit(data, optimizer=optimizer)
+    assert_allclose(loc, 14.633459, rtol=5e-7)
+    assert_allclose(scale, 9.232736, rtol=5e-6)
+
+
+def test_lognorm():
+    """
+    Ref: https://math.montana.edu/jobo/st528/documents/relc.pdf
+
+    The data is the locomotive control time to failure example that starts
+    on page 8.  That's the 8th page in the PDF; the page number shown in
+    the text is 270).
+    The document includes SAS output for the data.
+    """
+    # These are the uncensored measurements.  There are also 59 right-censored
+    # measurements where the lower bound is 135.
+    miles_to_fail = [22.5, 37.5, 46.0, 48.5, 51.5, 53.0, 54.5, 57.5, 66.5,
+                     68.0, 69.5, 76.5, 77.0, 78.5, 80.0, 81.5, 82.0, 83.0,
+                     84.0, 91.5, 93.5, 102.5, 107.0, 108.5, 112.5, 113.5,
+                     116.0, 117.0, 118.5, 119.0, 120.0, 122.5, 123.0, 127.5,
+                     131.0, 132.5, 134.0]
+
+    data = CensoredData.right_censored(miles_to_fail + [135]*59,
+                                       [0]*len(miles_to_fail) + [1]*59)
+    sigma, loc, scale = lognorm.fit(data, floc=0)
+
+    assert loc == 0
+    # Convert the lognorm parameters to the mu and sigma of the underlying
+    # normal distribution.
+    mu = np.log(scale)
+    # The expected results are from the 17th page of the PDF document
+    # (labeled page 279), in the SAS output on the right side of the page.
+    assert_allclose(mu, 5.1169, rtol=5e-4)
+    assert_allclose(sigma, 0.7055, rtol=5e-3)
+
+
+def test_nct():
+    """
+    Test fitting the noncentral t distribution to censored data.
+
+    Calculation in R:
+
+    > library(fitdistrplus)
+    > data <- data.frame(left=c(1, 2, 3, 5, 8, 10, 25, 25),
+    +                    right=c(1, 2, 3, 5, 8, 10, NA, NA))
+    > result = fitdistcens(data, 't', control=list(reltol=1e-14),
+    +                      start=list(df=1, ncp=2))
+    > result
+    Fitting of the distribution ' t ' on censored data by maximum likelihood
+    Parameters:
+         estimate
+    df  0.5432336
+    ncp 2.8893565
+
+    """
+    data = CensoredData.right_censored([1, 2, 3, 5, 8, 10, 25, 25],
+                                       [0, 0, 0, 0, 0, 0, 1, 1])
+    # Fit just the shape parameter df and nc; loc and scale are fixed.
+    with np.errstate(over='ignore'):  # remove context when gh-14901 is closed
+        df, nc, loc, scale = nct.fit(data, floc=0, fscale=1,
+                                     optimizer=optimizer)
+    assert_allclose(df, 0.5432336, rtol=5e-6)
+    assert_allclose(nc, 2.8893565, rtol=5e-6)
+    assert loc == 0
+    assert scale == 1
+
+
+def test_ncx2():
+    """
+    Test fitting the shape parameters (df, ncp) of ncx2 to mixed data.
+
+    Calculation in R, with
+    * 5 not censored values [2.7, 0.2, 6.5, 0.4, 0.1],
+    * 1 interval-censored value [[0.6, 1.0]], and
+    * 2 right-censored values [8, 8].
+
+    > library(fitdistrplus)
+    > data <- data.frame(left=c(2.7, 0.2, 6.5, 0.4, 0.1, 0.6, 8, 8),
+    +                    right=c(2.7, 0.2, 6.5, 0.4, 0.1, 1.0, NA, NA))
+    > result = fitdistcens(data, 'chisq', control=list(reltol=1e-14),
+    +                      start=list(df=1, ncp=2))
+    > result
+    Fitting of the distribution ' chisq ' on censored data by maximum
+    likelihood
+    Parameters:
+        estimate
+    df  1.052871
+    ncp 2.362934
+    """
+    data = CensoredData(uncensored=[2.7, 0.2, 6.5, 0.4, 0.1], right=[8, 8],
+                        interval=[[0.6, 1.0]])
+    with np.errstate(over='ignore'):  # remove context when gh-14901 is closed
+        df, ncp, loc, scale = ncx2.fit(data, floc=0, fscale=1,
+                                       optimizer=optimizer)
+    assert_allclose(df, 1.052871, rtol=5e-6)
+    assert_allclose(ncp, 2.362934, rtol=5e-6)
+    assert loc == 0
+    assert scale == 1
+
+
+def test_norm():
+    """
+    Test fitting the normal distribution to interval-censored data.
+
+    Calculation in R:
+
+    > library(fitdistrplus)
+    > data <- data.frame(left=c(0.10, 0.50, 0.75, 0.80),
+    +                    right=c(0.20, 0.55, 0.90, 0.95))
+    > result = fitdistcens(data, 'norm', control=list(reltol=1e-14))
+
+    > result
+    Fitting of the distribution ' norm ' on censored data by maximum likelihood
+    Parameters:
+          estimate
+    mean 0.5919990
+    sd   0.2868042
+    > result$sd
+         mean        sd
+    0.1444432 0.1029451
+    """
+    data = CensoredData(interval=[[0.10, 0.20],
+                                  [0.50, 0.55],
+                                  [0.75, 0.90],
+                                  [0.80, 0.95]])
+
+    loc, scale = norm.fit(data, optimizer=optimizer)
+
+    assert_allclose(loc, 0.5919990, rtol=5e-6)
+    assert_allclose(scale, 0.2868042, rtol=5e-6)
+
+
+def test_weibull_censored1():
+    # Ref: http://www.ams.sunysb.edu/~zhu/ams588/Lecture_3_likelihood.pdf
+
+    # Survival times; '*' indicates right-censored.
+    s = "3,5,6*,8,10*,11*,15,20*,22,23,27*,29,32,35,40,26,28,33*,21,24*"
+
+    times, cens = zip(*[(float(t[0]), len(t) == 2)
+                        for t in [w.split('*') for w in s.split(',')]])
+    data = CensoredData.right_censored(times, cens)
+
+    c, loc, scale = weibull_min.fit(data, floc=0)
+
+    # Expected values are from the reference.
+    assert_allclose(c, 2.149, rtol=1e-3)
+    assert loc == 0
+    assert_allclose(scale, 28.99, rtol=1e-3)
+
+    # Flip the sign of the data, and make the censored values
+    # left-censored. We should get the same parameters when we fit
+    # weibull_max to the flipped data.
+    data2 = CensoredData.left_censored(-np.array(times), cens)
+
+    c2, loc2, scale2 = weibull_max.fit(data2, floc=0)
+
+    assert_allclose(c2, 2.149, rtol=1e-3)
+    assert loc2 == 0
+    assert_allclose(scale2, 28.99, rtol=1e-3)
+
+
+def test_weibull_min_sas1():
+    # Data and SAS results from
+    #   https://support.sas.com/documentation/cdl/en/qcug/63922/HTML/default/
+    #         viewer.htm#qcug_reliability_sect004.htm
+
+    text = """
+           450 0    460 1   1150 0   1150 0   1560 1
+          1600 0   1660 1   1850 1   1850 1   1850 1
+          1850 1   1850 1   2030 1   2030 1   2030 1
+          2070 0   2070 0   2080 0   2200 1   3000 1
+          3000 1   3000 1   3000 1   3100 0   3200 1
+          3450 0   3750 1   3750 1   4150 1   4150 1
+          4150 1   4150 1   4300 1   4300 1   4300 1
+          4300 1   4600 0   4850 1   4850 1   4850 1
+          4850 1   5000 1   5000 1   5000 1   6100 1
+          6100 0   6100 1   6100 1   6300 1   6450 1
+          6450 1   6700 1   7450 1   7800 1   7800 1
+          8100 1   8100 1   8200 1   8500 1   8500 1
+          8500 1   8750 1   8750 0   8750 1   9400 1
+          9900 1  10100 1  10100 1  10100 1  11500 1
+    """
+
+    life, cens = np.array([int(w) for w in text.split()]).reshape(-1, 2).T
+    life = life/1000.0
+
+    data = CensoredData.right_censored(life, cens)
+
+    c, loc, scale = weibull_min.fit(data, floc=0, optimizer=optimizer)
+    assert_allclose(c, 1.0584, rtol=1e-4)
+    assert_allclose(scale, 26.2968, rtol=1e-5)
+    assert loc == 0
+
+
+def test_weibull_min_sas2():
+    # http://support.sas.com/documentation/cdl/en/ormpug/67517/HTML/default/
+    #      viewer.htm#ormpug_nlpsolver_examples06.htm
+
+    # The last two values are right-censored.
+    days = np.array([143, 164, 188, 188, 190, 192, 206, 209, 213, 216, 220,
+                     227, 230, 234, 246, 265, 304, 216, 244])
+
+    data = CensoredData.right_censored(days, [0]*(len(days) - 2) + [1]*2)
+
+    c, loc, scale = weibull_min.fit(data, 1, loc=100, scale=100,
+                                    optimizer=optimizer)
+
+    assert_allclose(c, 2.7112, rtol=5e-4)
+    assert_allclose(loc, 122.03, rtol=5e-4)
+    assert_allclose(scale, 108.37, rtol=5e-4)

.venv/Lib/site-packages/scipy/stats/tests/test_crosstab.py

@@ -0,0 +1,115 @@
+import pytest
+import numpy as np
+from numpy.testing import assert_array_equal, assert_equal
+from scipy.stats.contingency import crosstab
+
+
+@pytest.mark.parametrize('sparse', [False, True])
+def test_crosstab_basic(sparse):
+    a = [0, 0, 9, 9, 0, 0, 9]
+    b = [2, 1, 3, 1, 2, 3, 3]
+    expected_avals = [0, 9]
+    expected_bvals = [1, 2, 3]
+    expected_count = np.array([[1, 2, 1],
+                               [1, 0, 2]])
+    (avals, bvals), count = crosstab(a, b, sparse=sparse)
+    assert_array_equal(avals, expected_avals)
+    assert_array_equal(bvals, expected_bvals)
+    if sparse:
+        assert_array_equal(count.A, expected_count)
+    else:
+        assert_array_equal(count, expected_count)
+
+
+def test_crosstab_basic_1d():
+    # Verify that a single input sequence works as expected.
+    x = [1, 2, 3, 1, 2, 3, 3]
+    expected_xvals = [1, 2, 3]
+    expected_count = np.array([2, 2, 3])
+    (xvals,), count = crosstab(x)
+    assert_array_equal(xvals, expected_xvals)
+    assert_array_equal(count, expected_count)
+
+
+def test_crosstab_basic_3d():
+    # Verify the function for three input sequences.
+    a = 'a'
+    b = 'b'
+    x = [0, 0, 9, 9, 0, 0, 9, 9]
+    y = [a, a, a, a, b, b, b, a]
+    z = [1, 2, 3, 1, 2, 3, 3, 1]
+    expected_xvals = [0, 9]
+    expected_yvals = [a, b]
+    expected_zvals = [1, 2, 3]
+    expected_count = np.array([[[1, 1, 0],
+                                [0, 1, 1]],
+                               [[2, 0, 1],
+                                [0, 0, 1]]])
+    (xvals, yvals, zvals), count = crosstab(x, y, z)
+    assert_array_equal(xvals, expected_xvals)
+    assert_array_equal(yvals, expected_yvals)
+    assert_array_equal(zvals, expected_zvals)
+    assert_array_equal(count, expected_count)
+
+
+@pytest.mark.parametrize('sparse', [False, True])
+def test_crosstab_levels(sparse):
+    a = [0, 0, 9, 9, 0, 0, 9]
+    b = [1, 2, 3, 1, 2, 3, 3]
+    expected_avals = [0, 9]
+    expected_bvals = [0, 1, 2, 3]
+    expected_count = np.array([[0, 1, 2, 1],
+                               [0, 1, 0, 2]])
+    (avals, bvals), count = crosstab(a, b, levels=[None, [0, 1, 2, 3]],
+                                     sparse=sparse)
+    assert_array_equal(avals, expected_avals)
+    assert_array_equal(bvals, expected_bvals)
+    if sparse:
+        assert_array_equal(count.A, expected_count)
+    else:
+        assert_array_equal(count, expected_count)
+
+
+@pytest.mark.parametrize('sparse', [False, True])
+def test_crosstab_extra_levels(sparse):
+    # The pair of values (-1, 3) will be ignored, because we explicitly
+    # request the counted `a` values to be [0, 9].
+    a = [0, 0, 9, 9, 0, 0, 9, -1]
+    b = [1, 2, 3, 1, 2, 3, 3, 3]
+    expected_avals = [0, 9]
+    expected_bvals = [0, 1, 2, 3]
+    expected_count = np.array([[0, 1, 2, 1],
+                               [0, 1, 0, 2]])
+    (avals, bvals), count = crosstab(a, b, levels=[[0, 9], [0, 1, 2, 3]],
+                                     sparse=sparse)
+    assert_array_equal(avals, expected_avals)
+    assert_array_equal(bvals, expected_bvals)
+    if sparse:
+        assert_array_equal(count.A, expected_count)
+    else:
+        assert_array_equal(count, expected_count)
+
+
+def test_validation_at_least_one():
+    with pytest.raises(TypeError, match='At least one'):
+        crosstab()
+
+
+def test_validation_same_lengths():
+    with pytest.raises(ValueError, match='must have the same length'):
+        crosstab([1, 2], [1, 2, 3, 4])
+
+
+def test_validation_sparse_only_two_args():
+    with pytest.raises(ValueError, match='only two input sequences'):
+        crosstab([0, 1, 1], [8, 8, 9], [1, 3, 3], sparse=True)
+
+
+def test_validation_len_levels_matches_args():
+    with pytest.raises(ValueError, match='number of input sequences'):
+        crosstab([0, 1, 1], [8, 8, 9], levels=([0, 1, 2, 3],))
+
+
+def test_result():
+    res = crosstab([0, 1], [1, 2])
+    assert_equal((res.elements, res.count), res)

.venv/Lib/site-packages/scipy/stats/tests/test_discrete_basic.py

@@ -0,0 +1,548 @@
+import numpy.testing as npt
+from numpy.testing import assert_allclose
+
+import numpy as np
+import pytest
+
+from scipy import stats
+from .common_tests import (check_normalization, check_moment,
+                           check_mean_expect,
+                           check_var_expect, check_skew_expect,
+                           check_kurt_expect, check_entropy,
+                           check_private_entropy, check_edge_support,
+                           check_named_args, check_random_state_property,
+                           check_pickling, check_rvs_broadcast,
+                           check_freezing,)
+from scipy.stats._distr_params import distdiscrete, invdistdiscrete
+from scipy.stats._distn_infrastructure import rv_discrete_frozen
+
+vals = ([1, 2, 3, 4], [0.1, 0.2, 0.3, 0.4])
+distdiscrete += [[stats.rv_discrete(values=vals), ()]]
+
+# For these distributions, test_discrete_basic only runs with test mode full
+distslow = {'zipfian', 'nhypergeom'}
+
+
+def cases_test_discrete_basic():
+    seen = set()
+    for distname, arg in distdiscrete:
+        if distname in distslow:
+            yield pytest.param(distname, arg, distname, marks=pytest.mark.slow)
+        else:
+            yield distname, arg, distname not in seen
+        seen.add(distname)
+
+
+@pytest.mark.parametrize('distname,arg,first_case', cases_test_discrete_basic())
+def test_discrete_basic(distname, arg, first_case):
+    try:
+        distfn = getattr(stats, distname)
+    except TypeError:
+        distfn = distname
+        distname = 'sample distribution'
+    np.random.seed(9765456)
+    rvs = distfn.rvs(size=2000, *arg)
+    supp = np.unique(rvs)
+    m, v = distfn.stats(*arg)
+    check_cdf_ppf(distfn, arg, supp, distname + ' cdf_ppf')
+
+    check_pmf_cdf(distfn, arg, distname)
+    check_oth(distfn, arg, supp, distname + ' oth')
+    check_edge_support(distfn, arg)
+
+    alpha = 0.01
+    check_discrete_chisquare(distfn, arg, rvs, alpha,
+                             distname + ' chisquare')
+
+    if first_case:
+        locscale_defaults = (0,)
+        meths = [distfn.pmf, distfn.logpmf, distfn.cdf, distfn.logcdf,
+                 distfn.logsf]
+        # make sure arguments are within support
+        # for some distributions, this needs to be overridden
+        spec_k = {'randint': 11, 'hypergeom': 4, 'bernoulli': 0,
+                  'nchypergeom_wallenius': 6}
+        k = spec_k.get(distname, 1)
+        check_named_args(distfn, k, arg, locscale_defaults, meths)
+        if distname != 'sample distribution':
+            check_scale_docstring(distfn)
+        check_random_state_property(distfn, arg)
+        check_pickling(distfn, arg)
+        check_freezing(distfn, arg)
+
+        # Entropy
+        check_entropy(distfn, arg, distname)
+        if distfn.__class__._entropy != stats.rv_discrete._entropy:
+            check_private_entropy(distfn, arg, stats.rv_discrete)
+
+
+@pytest.mark.parametrize('distname,arg', distdiscrete)
+def test_moments(distname, arg):
+    try:
+        distfn = getattr(stats, distname)
+    except TypeError:
+        distfn = distname
+        distname = 'sample distribution'
+    m, v, s, k = distfn.stats(*arg, moments='mvsk')
+    check_normalization(distfn, arg, distname)
+
+    # compare `stats` and `moment` methods
+    check_moment(distfn, arg, m, v, distname)
+    check_mean_expect(distfn, arg, m, distname)
+    check_var_expect(distfn, arg, m, v, distname)
+    check_skew_expect(distfn, arg, m, v, s, distname)
+    with np.testing.suppress_warnings() as sup:
+        if distname in ['zipf', 'betanbinom']:
+            sup.filter(RuntimeWarning)
+        check_kurt_expect(distfn, arg, m, v, k, distname)
+
+    # frozen distr moments
+    check_moment_frozen(distfn, arg, m, 1)
+    check_moment_frozen(distfn, arg, v+m*m, 2)
+
+
+@pytest.mark.parametrize('dist,shape_args', distdiscrete)
+def test_rvs_broadcast(dist, shape_args):
+    # If shape_only is True, it means the _rvs method of the
+    # distribution uses more than one random number to generate a random
+    # variate.  That means the result of using rvs with broadcasting or
+    # with a nontrivial size will not necessarily be the same as using the
+    # numpy.vectorize'd version of rvs(), so we can only compare the shapes
+    # of the results, not the values.
+    # Whether or not a distribution is in the following list is an
+    # implementation detail of the distribution, not a requirement.  If
+    # the implementation the rvs() method of a distribution changes, this
+    # test might also have to be changed.
+    shape_only = dist in ['betabinom', 'betanbinom', 'skellam', 'yulesimon',
+                          'dlaplace', 'nchypergeom_fisher',
+                          'nchypergeom_wallenius']
+
+    try:
+        distfunc = getattr(stats, dist)
+    except TypeError:
+        distfunc = dist
+        dist = f'rv_discrete(values=({dist.xk!r}, {dist.pk!r}))'
+    loc = np.zeros(2)
+    nargs = distfunc.numargs
+    allargs = []
+    bshape = []
+    # Generate shape parameter arguments...
+    for k in range(nargs):
+        shp = (k + 3,) + (1,)*(k + 1)
+        param_val = shape_args[k]
+        allargs.append(np.full(shp, param_val))
+        bshape.insert(0, shp[0])
+    allargs.append(loc)
+    bshape.append(loc.size)
+    # bshape holds the expected shape when loc, scale, and the shape
+    # parameters are all broadcast together.
+    check_rvs_broadcast(
+        distfunc, dist, allargs, bshape, shape_only, [np.dtype(int)]
+    )
+
+
+@pytest.mark.parametrize('dist,args', distdiscrete)
+def test_ppf_with_loc(dist, args):
+    try:
+        distfn = getattr(stats, dist)
+    except TypeError:
+        distfn = dist
+    #check with a negative, no and positive relocation.
+    np.random.seed(1942349)
+    re_locs = [np.random.randint(-10, -1), 0, np.random.randint(1, 10)]
+    _a, _b = distfn.support(*args)
+    for loc in re_locs:
+        npt.assert_array_equal(
+            [_a-1+loc, _b+loc],
+            [distfn.ppf(0.0, *args, loc=loc), distfn.ppf(1.0, *args, loc=loc)]
+            )
+
+
+@pytest.mark.parametrize('dist, args', distdiscrete)
+def test_isf_with_loc(dist, args):
+    try:
+        distfn = getattr(stats, dist)
+    except TypeError:
+        distfn = dist
+    # check with a negative, no and positive relocation.
+    np.random.seed(1942349)
+    re_locs = [np.random.randint(-10, -1), 0, np.random.randint(1, 10)]
+    _a, _b = distfn.support(*args)
+    for loc in re_locs:
+        expected = _b + loc, _a - 1 + loc
+        res = distfn.isf(0., *args, loc=loc), distfn.isf(1., *args, loc=loc)
+        npt.assert_array_equal(expected, res)
+    # test broadcasting behaviour
+    re_locs = [np.random.randint(-10, -1, size=(5, 3)),
+               np.zeros((5, 3)),
+               np.random.randint(1, 10, size=(5, 3))]
+    _a, _b = distfn.support(*args)
+    for loc in re_locs:
+        expected = _b + loc, _a - 1 + loc
+        res = distfn.isf(0., *args, loc=loc), distfn.isf(1., *args, loc=loc)
+        npt.assert_array_equal(expected, res)
+
+
+def check_cdf_ppf(distfn, arg, supp, msg):
+    # supp is assumed to be an array of integers in the support of distfn
+    # (but not necessarily all the integers in the support).
+    # This test assumes that the PMF of any value in the support of the
+    # distribution is greater than 1e-8.
+
+    # cdf is a step function, and ppf(q) = min{k : cdf(k) >= q, k integer}
+    cdf_supp = distfn.cdf(supp, *arg)
+    # In very rare cases, the finite precision calculation of ppf(cdf(supp))
+    # can produce an array in which an element is off by one.  We nudge the
+    # CDF values down by 15 ULPs help to avoid this.
+    cdf_supp0 = cdf_supp - 15*np.spacing(cdf_supp)
+    npt.assert_array_equal(distfn.ppf(cdf_supp0, *arg),
+                           supp, msg + '-roundtrip')
+    # Repeat the same calculation, but with the CDF values decreased by 1e-8.
+    npt.assert_array_equal(distfn.ppf(distfn.cdf(supp, *arg) - 1e-8, *arg),
+                           supp, msg + '-roundtrip')
+
+    if not hasattr(distfn, 'xk'):
+        _a, _b = distfn.support(*arg)
+        supp1 = supp[supp < _b]
+        npt.assert_array_equal(distfn.ppf(distfn.cdf(supp1, *arg) + 1e-8, *arg),
+                               supp1 + distfn.inc, msg + ' ppf-cdf-next')
+
+
+def check_pmf_cdf(distfn, arg, distname):
+    if hasattr(distfn, 'xk'):
+        index = distfn.xk
+    else:
+        startind = int(distfn.ppf(0.01, *arg) - 1)
+        index = list(range(startind, startind + 10))
+    cdfs = distfn.cdf(index, *arg)
+    pmfs_cum = distfn.pmf(index, *arg).cumsum()
+
+    atol, rtol = 1e-10, 1e-10
+    if distname == 'skellam':    # ncx2 accuracy
+        atol, rtol = 1e-5, 1e-5
+    npt.assert_allclose(cdfs - cdfs[0], pmfs_cum - pmfs_cum[0],
+                        atol=atol, rtol=rtol)
+
+    # also check that pmf at non-integral k is zero
+    k = np.asarray(index)
+    k_shifted = k[:-1] + np.diff(k)/2
+    npt.assert_equal(distfn.pmf(k_shifted, *arg), 0)
+
+    # better check frozen distributions, and also when loc != 0
+    loc = 0.5
+    dist = distfn(loc=loc, *arg)
+    npt.assert_allclose(dist.pmf(k[1:] + loc), np.diff(dist.cdf(k + loc)))
+    npt.assert_equal(dist.pmf(k_shifted + loc), 0)
+
+
+def check_moment_frozen(distfn, arg, m, k):
+    npt.assert_allclose(distfn(*arg).moment(k), m,
+                        atol=1e-10, rtol=1e-10)
+
+
+def check_oth(distfn, arg, supp, msg):
+    # checking other methods of distfn
+    npt.assert_allclose(distfn.sf(supp, *arg), 1. - distfn.cdf(supp, *arg),
+                        atol=1e-10, rtol=1e-10)
+
+    q = np.linspace(0.01, 0.99, 20)
+    npt.assert_allclose(distfn.isf(q, *arg), distfn.ppf(1. - q, *arg),
+                        atol=1e-10, rtol=1e-10)
+
+    median_sf = distfn.isf(0.5, *arg)
+    npt.assert_(distfn.sf(median_sf - 1, *arg) > 0.5)
+    npt.assert_(distfn.cdf(median_sf + 1, *arg) > 0.5)
+
+
+def check_discrete_chisquare(distfn, arg, rvs, alpha, msg):
+    """Perform chisquare test for random sample of a discrete distribution
+
+    Parameters
+    ----------
+    distname : string
+        name of distribution function
+    arg : sequence
+        parameters of distribution
+    alpha : float
+        significance level, threshold for p-value
+
+    Returns
+    -------
+    result : bool
+        0 if test passes, 1 if test fails
+
+    """
+    wsupp = 0.05
+
+    # construct intervals with minimum mass `wsupp`.
+    # intervals are left-half-open as in a cdf difference
+    _a, _b = distfn.support(*arg)
+    lo = int(max(_a, -1000))
+    high = int(min(_b, 1000)) + 1
+    distsupport = range(lo, high)
+    last = 0
+    distsupp = [lo]
+    distmass = []
+    for ii in distsupport:
+        current = distfn.cdf(ii, *arg)
+        if current - last >= wsupp - 1e-14:
+            distsupp.append(ii)
+            distmass.append(current - last)
+            last = current
+            if current > (1 - wsupp):
+                break
+    if distsupp[-1] < _b:
+        distsupp.append(_b)
+        distmass.append(1 - last)
+    distsupp = np.array(distsupp)
+    distmass = np.array(distmass)
+
+    # convert intervals to right-half-open as required by histogram
+    histsupp = distsupp + 1e-8
+    histsupp[0] = _a
+
+    # find sample frequencies and perform chisquare test
+    freq, hsupp = np.histogram(rvs, histsupp)
+    chis, pval = stats.chisquare(np.array(freq), len(rvs)*distmass)
+
+    npt.assert_(
+        pval > alpha,
+        f'chisquare - test for {msg} at arg = {str(arg)} with pval = {str(pval)}'
+    )
+
+
+def check_scale_docstring(distfn):
+    if distfn.__doc__ is not None:
+        # Docstrings can be stripped if interpreter is run with -OO
+        npt.assert_('scale' not in distfn.__doc__)
+
+
+@pytest.mark.parametrize('method', ['pmf', 'logpmf', 'cdf', 'logcdf',
+                                    'sf', 'logsf', 'ppf', 'isf'])
+@pytest.mark.parametrize('distname, args', distdiscrete)
+def test_methods_with_lists(method, distname, args):
+    # Test that the discrete distributions can accept Python lists
+    # as arguments.
+    try:
+        dist = getattr(stats, distname)
+    except TypeError:
+        return
+    if method in ['ppf', 'isf']:
+        z = [0.1, 0.2]
+    else:
+        z = [0, 1]
+    p2 = [[p]*2 for p in args]
+    loc = [0, 1]
+    result = dist.pmf(z, *p2, loc=loc)
+    npt.assert_allclose(result,
+                        [dist.pmf(*v) for v in zip(z, *p2, loc)],
+                        rtol=1e-15, atol=1e-15)
+
+
+@pytest.mark.parametrize('distname, args', invdistdiscrete)
+def test_cdf_gh13280_regression(distname, args):
+    # Test for nan output when shape parameters are invalid
+    dist = getattr(stats, distname)
+    x = np.arange(-2, 15)
+    vals = dist.cdf(x, *args)
+    expected = np.nan
+    npt.assert_equal(vals, expected)
+
+
+def cases_test_discrete_integer_shapes():
+    # distributions parameters that are only allowed to be integral when
+    # fitting, but are allowed to be real as input to PDF, etc.
+    integrality_exceptions = {'nbinom': {'n'}, 'betanbinom': {'n'}}
+
+    seen = set()
+    for distname, shapes in distdiscrete:
+        if distname in seen:
+            continue
+        seen.add(distname)
+
+        try:
+            dist = getattr(stats, distname)
+        except TypeError:
+            continue
+
+        shape_info = dist._shape_info()
+
+        for i, shape in enumerate(shape_info):
+            if (shape.name in integrality_exceptions.get(distname, set()) or
+                    not shape.integrality):
+                continue
+
+            yield distname, shape.name, shapes
+
+
+@pytest.mark.parametrize('distname, shapename, shapes',
+                         cases_test_discrete_integer_shapes())
+def test_integer_shapes(distname, shapename, shapes):
+    dist = getattr(stats, distname)
+    shape_info = dist._shape_info()
+    shape_names = [shape.name for shape in shape_info]
+    i = shape_names.index(shapename)  # this element of params must be integral
+
+    shapes_copy = list(shapes)
+
+    valid_shape = shapes[i]
+    invalid_shape = valid_shape - 0.5  # arbitrary non-integral value
+    new_valid_shape = valid_shape - 1
+    shapes_copy[i] = [[valid_shape], [invalid_shape], [new_valid_shape]]
+
+    a, b = dist.support(*shapes)
+    x = np.round(np.linspace(a, b, 5))
+
+    pmf = dist.pmf(x, *shapes_copy)
+    assert not np.any(np.isnan(pmf[0, :]))
+    assert np.all(np.isnan(pmf[1, :]))
+    assert not np.any(np.isnan(pmf[2, :]))
+
+
+def test_frozen_attributes():
+    # gh-14827 reported that all frozen distributions had both pmf and pdf
+    # attributes; continuous should have pdf and discrete should have pmf.
+    message = "'rv_discrete_frozen' object has no attribute"
+    with pytest.raises(AttributeError, match=message):
+        stats.binom(10, 0.5).pdf
+    with pytest.raises(AttributeError, match=message):
+        stats.binom(10, 0.5).logpdf
+    stats.binom.pdf = "herring"
+    frozen_binom = stats.binom(10, 0.5)
+    assert isinstance(frozen_binom, rv_discrete_frozen)
+    delattr(stats.binom, 'pdf')
+
+
+@pytest.mark.parametrize('distname, shapes', distdiscrete)
+def test_interval(distname, shapes):
+    # gh-11026 reported that `interval` returns incorrect values when
+    # `confidence=1`. The values were not incorrect, but it was not intuitive
+    # that the left end of the interval should extend beyond the support of the
+    # distribution. Confirm that this is the behavior for all distributions.
+    if isinstance(distname, str):
+        dist = getattr(stats, distname)
+    else:
+        dist = distname
+    a, b = dist.support(*shapes)
+    npt.assert_equal(dist.ppf([0, 1], *shapes), (a-1, b))
+    npt.assert_equal(dist.isf([1, 0], *shapes), (a-1, b))
+    npt.assert_equal(dist.interval(1, *shapes), (a-1, b))
+
+
+@pytest.mark.xfail_on_32bit("Sensible to machine precision")
+def test_rv_sample():
+    # Thoroughly test rv_sample and check that gh-3758 is resolved
+
+    # Generate a random discrete distribution
+    rng = np.random.default_rng(98430143469)
+    xk = np.sort(rng.random(10) * 10)
+    pk = rng.random(10)
+    pk /= np.sum(pk)
+    dist = stats.rv_discrete(values=(xk, pk))
+
+    # Generate points to the left and right of xk
+    xk_left = (np.array([0] + xk[:-1].tolist()) + xk)/2
+    xk_right = (np.array(xk[1:].tolist() + [xk[-1]+1]) + xk)/2
+
+    # Generate points to the left and right of cdf
+    cdf2 = np.cumsum(pk)
+    cdf2_left = (np.array([0] + cdf2[:-1].tolist()) + cdf2)/2
+    cdf2_right = (np.array(cdf2[1:].tolist() + [1]) + cdf2)/2
+
+    # support - leftmost and rightmost xk
+    a, b = dist.support()
+    assert_allclose(a, xk[0])
+    assert_allclose(b, xk[-1])
+
+    # pmf - supported only on the xk
+    assert_allclose(dist.pmf(xk), pk)
+    assert_allclose(dist.pmf(xk_right), 0)
+    assert_allclose(dist.pmf(xk_left), 0)
+
+    # logpmf is log of the pmf; log(0) = -np.inf
+    with np.errstate(divide='ignore'):
+        assert_allclose(dist.logpmf(xk), np.log(pk))
+        assert_allclose(dist.logpmf(xk_right), -np.inf)
+        assert_allclose(dist.logpmf(xk_left), -np.inf)
+
+    # cdf - the cumulative sum of the pmf
+    assert_allclose(dist.cdf(xk), cdf2)
+    assert_allclose(dist.cdf(xk_right), cdf2)
+    assert_allclose(dist.cdf(xk_left), [0]+cdf2[:-1].tolist())
+
+    with np.errstate(divide='ignore'):
+        assert_allclose(dist.logcdf(xk), np.log(dist.cdf(xk)),
+                        atol=1e-15)
+        assert_allclose(dist.logcdf(xk_right), np.log(dist.cdf(xk_right)),
+                        atol=1e-15)
+        assert_allclose(dist.logcdf(xk_left), np.log(dist.cdf(xk_left)),
+                        atol=1e-15)
+
+    # sf is 1-cdf
+    assert_allclose(dist.sf(xk), 1-dist.cdf(xk))
+    assert_allclose(dist.sf(xk_right), 1-dist.cdf(xk_right))
+    assert_allclose(dist.sf(xk_left), 1-dist.cdf(xk_left))
+
+    with np.errstate(divide='ignore'):
+        assert_allclose(dist.logsf(xk), np.log(dist.sf(xk)),
+                        atol=1e-15)
+        assert_allclose(dist.logsf(xk_right), np.log(dist.sf(xk_right)),
+                        atol=1e-15)
+        assert_allclose(dist.logsf(xk_left), np.log(dist.sf(xk_left)),
+                        atol=1e-15)
+
+    # ppf
+    assert_allclose(dist.ppf(cdf2), xk)
+    assert_allclose(dist.ppf(cdf2_left), xk)
+    assert_allclose(dist.ppf(cdf2_right)[:-1], xk[1:])
+    assert_allclose(dist.ppf(0), a - 1)
+    assert_allclose(dist.ppf(1), b)
+
+    # isf
+    sf2 = dist.sf(xk)
+    assert_allclose(dist.isf(sf2), xk)
+    assert_allclose(dist.isf(1-cdf2_left), dist.ppf(cdf2_left))
+    assert_allclose(dist.isf(1-cdf2_right), dist.ppf(cdf2_right))
+    assert_allclose(dist.isf(0), b)
+    assert_allclose(dist.isf(1), a - 1)
+
+    # interval is (ppf(alpha/2), isf(alpha/2))
+    ps = np.linspace(0.01, 0.99, 10)
+    int2 = dist.ppf(ps/2), dist.isf(ps/2)
+    assert_allclose(dist.interval(1-ps), int2)
+    assert_allclose(dist.interval(0), dist.median())
+    assert_allclose(dist.interval(1), (a-1, b))
+
+    # median is simply ppf(0.5)
+    med2 = dist.ppf(0.5)
+    assert_allclose(dist.median(), med2)
+
+    # all four stats (mean, var, skew, and kurtosis) from the definitions
+    mean2 = np.sum(xk*pk)
+    var2 = np.sum((xk - mean2)**2 * pk)
+    skew2 = np.sum((xk - mean2)**3 * pk) / var2**(3/2)
+    kurt2 = np.sum((xk - mean2)**4 * pk) / var2**2 - 3
+    assert_allclose(dist.mean(), mean2)
+    assert_allclose(dist.std(), np.sqrt(var2))
+    assert_allclose(dist.var(), var2)
+    assert_allclose(dist.stats(moments='mvsk'), (mean2, var2, skew2, kurt2))
+
+    # noncentral moment against definition
+    mom3 = np.sum((xk**3) * pk)
+    assert_allclose(dist.moment(3), mom3)
+
+    # expect - check against moments
+    assert_allclose(dist.expect(lambda x: 1), 1)
+    assert_allclose(dist.expect(), mean2)
+    assert_allclose(dist.expect(lambda x: x**3), mom3)
+
+    # entropy is the negative of the expected value of log(p)
+    with np.errstate(divide='ignore'):
+        assert_allclose(-dist.expect(lambda x: dist.logpmf(x)), dist.entropy())
+
+    # RVS is just ppf of uniform random variates
+    rng = np.random.default_rng(98430143469)
+    rvs = dist.rvs(size=100, random_state=rng)
+    rng = np.random.default_rng(98430143469)
+    rvs0 = dist.ppf(rng.random(size=100))
+    assert_allclose(rvs, rvs0)