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

scipy/stats/_qmvnt.py

@@ -35,12 +35,10 @@
 import numpy as np
 
 from scipy.fft import fft, ifft
-from scipy.special import gammaincinv, ndtr, ndtri
+from scipy.special import ndtr as phi, ndtri as phinv
 from scipy.stats._qmc import primes_from_2_to
 
-
-phi = ndtr
-phinv = ndtri
+from ._qmvnt_cy import _qmvn_inner, _qmvt_inner
 
 
 def _factorize_int(n):
@@ -145,9 +143,6 @@ def _cbc_lattice(n_dim, n_qmc_samples):
     return q, n_qmc_samples
 
 
-# Note: this function is not currently used or tested by any SciPy code. It is
-# included in this file to facilitate the development of a parameter for users
-# to set the desired CDF accuracy, but must be reviewed and tested before use.
 def _qauto(func, covar, low, high, rng, error=1e-3, limit=10_000, **kwds):
     """Automatically rerun the integration to get the required error bound.
 
@@ -180,7 +175,7 @@ def _qauto(func, covar, low, high, rng, error=1e-3, limit=10_000, **kwds):
     n = len(covar)
     n_samples = 0
     if n == 1:
-        prob = phi(high) - phi(low)
+        prob = phi(high / covar**0.5) - phi(low / covar**0.5)
         # More or less
         est_error = 1e-15
     else:
@@ -198,9 +193,6 @@ def _qauto(func, covar, low, high, rng, error=1e-3, limit=10_000, **kwds):
     return prob, est_error, n_samples
 
 
-# Note: this function is not currently used or tested by any SciPy code. It is
-# included in this file to facilitate the resolution of gh-8367, gh-16142, and
-# possibly gh-14286, but must be reviewed and tested before use.
 def _qmvn(m, covar, low, high, rng, lattice='cbc', n_batches=10):
     """Multivariate normal integration over box bounds.
 
@@ -229,42 +221,17 @@ def _qmvn(m, covar, low, high, rng, lattice='cbc', n_batches=10):
         3 times the standard error of the batch estimates.
     """
     cho, lo, hi = _permuted_cholesky(covar, low, high)
+    if not cho.flags.c_contiguous:
+        # qmvn_inner expects contiguous buffers
+        cho = cho.copy()
+
     n = cho.shape[0]
-    ct = cho[0, 0]
-    c = phi(lo[0] / ct)
-    d = phi(hi[0] / ct)
-    ci = c
-    dci = d - ci
-    prob = 0.0
-    error_var = 0.0
     q, n_qmc_samples = _cbc_lattice(n - 1, max(m // n_batches, 1))
-    y = np.zeros((n - 1, n_qmc_samples))
-    i_samples = np.arange(n_qmc_samples) + 1
-    for j in range(n_batches):
-        c = np.full(n_qmc_samples, ci)
-        dc = np.full(n_qmc_samples, dci)
-        pv = dc.copy()
-        for i in range(1, n):
-            # Pseudorandomly-shifted lattice coordinate.
-            z = q[i - 1] * i_samples + rng.random()
-            # Fast remainder(z, 1.0)
-            z -= z.astype(int)
-            # Tent periodization transform.
-            x = abs(2 * z - 1)
-            y[i - 1, :] = phinv(c + x * dc)
-            s = cho[i, :i] @ y[:i, :]
-            ct = cho[i, i]
-            c = phi((lo[i] - s) / ct)
-            d = phi((hi[i] - s) / ct)
-            dc = d - c
-            pv = pv * dc
-        # Accumulate the mean and error variances with online formulations.
-        d = (pv.mean() - prob) / (j + 1)
-        prob += d
-        error_var = (j - 1) * error_var / (j + 1) + d * d
-    # Error bounds are 3 times the standard error of the estimates.
-    est_error = 3 * np.sqrt(error_var)
-    n_samples = n_qmc_samples * n_batches
+    rndm = rng.random(size=(n_batches, n))
+
+    prob, est_error, n_samples = _qmvn_inner(
+        q, rndm, int(n_qmc_samples), int(n_batches), cho, lo, hi
+    )
     return prob, est_error, n_samples
 
 
@@ -371,57 +338,11 @@ def _qmvt(m, nu, covar, low, high, rng, lattice='cbc', n_batches=10):
     high = np.asarray(high, dtype=np.float64)
     cho, lo, hi = _permuted_cholesky(covar, low / sn, high / sn)
     n = cho.shape[0]
-    prob = 0.0
-    error_var = 0.0
     q, n_qmc_samples = _cbc_lattice(n, max(m // n_batches, 1))
-    i_samples = np.arange(n_qmc_samples) + 1
-    for j in range(n_batches):
-        pv = np.ones(n_qmc_samples)
-        s = np.zeros((n, n_qmc_samples))
-        for i in range(n):
-            # Pseudorandomly-shifted lattice coordinate.
-            z = q[i] * i_samples + rng.random()
-            # Fast remainder(z, 1.0)
-            z -= z.astype(int)
-            # Tent periodization transform.
-            x = abs(2 * z - 1)
-            # FIXME: Lift the i==0 case out of the loop to make the logic
-            # easier to follow.
-            if i == 0:
-                # We'll use one of the QR variates to pull out the
-                # t-distribution scaling.
-                if nu > 0:
-                    r = np.sqrt(2 * gammaincinv(nu / 2, x))
-                else:
-                    r = np.ones_like(x)
-            else:
-                y = phinv(c + x * dc)  # noqa: F821
-                with np.errstate(invalid='ignore'):
-                    s[i:, :] += cho[i:, i - 1][:, np.newaxis] * y
-            si = s[i, :]
-
-            c = np.ones(n_qmc_samples)
-            d = np.ones(n_qmc_samples)
-            with np.errstate(invalid='ignore'):
-                lois = lo[i] * r - si
-                hiis = hi[i] * r - si
-            c[lois < -9] = 0.0
-            d[hiis < -9] = 0.0
-            lo_mask = abs(lois) < 9
-            hi_mask = abs(hiis) < 9
-            c[lo_mask] = phi(lois[lo_mask])
-            d[hi_mask] = phi(hiis[hi_mask])
-
-            dc = d - c
-            pv *= dc
-
-        # Accumulate the mean and error variances with online formulations.
-        d = (pv.mean() - prob) / (j + 1)
-        prob += d
-        error_var = (j - 1) * error_var / (j + 1) + d * d
-    # Error bounds are 3 times the standard error of the estimates.
-    est_error = 3 * np.sqrt(error_var)
-    n_samples = n_qmc_samples * n_batches
+    rndm = rng.random(size=(n_batches, n))
+    prob, est_error, n_samples = _qmvt_inner(
+        q, rndm, int(n_qmc_samples), int(n_batches), cho, lo, hi, float(nu)
+    )
     return prob, est_error, n_samples
 
 

scipy/stats/_quantile.py

@@ -0,0 +1,335 @@
+import numpy as np
+from scipy.special import betainc
+from scipy._lib._array_api import xp_ravel, array_namespace, xp_promote
+import scipy._lib.array_api_extra as xpx
+from scipy.stats._axis_nan_policy import _broadcast_arrays, _contains_nan
+from scipy.stats._stats_py import _length_nonmasked
+
+
+def _quantile_iv(x, p, method, axis, nan_policy, keepdims):
+    xp = array_namespace(x, p)
+
+    if not xp.isdtype(xp.asarray(x).dtype, ('integral', 'real floating')):
+        raise ValueError("`x` must have real dtype.")
+
+    if not xp.isdtype(xp.asarray(p).dtype, 'real floating'):
+        raise ValueError("`p` must have real floating dtype.")
+
+    x, p = xp_promote(x, p, force_floating=True, xp=xp)
+    dtype = x.dtype
+
+    axis_none = axis is None
+    ndim = max(x.ndim, p.ndim)
+    if axis_none:
+        x = xp_ravel(x)
+        p = xp_ravel(p)
+        axis = 0
+    elif np.iterable(axis) or int(axis) != axis:
+        message = "`axis` must be an integer or None."
+        raise ValueError(message)
+    elif (axis >= ndim) or (axis < -ndim):
+        message = "`axis` is not compatible with the shapes of the inputs."
+        raise ValueError(message)
+    axis = int(axis)
+
+    methods = {'inverted_cdf', 'averaged_inverted_cdf', 'closest_observation',
+               'hazen', 'interpolated_inverted_cdf', 'linear',
+               'median_unbiased', 'normal_unbiased', 'weibull',
+               'harrell-davis'}
+    if method not in methods:
+        message = f"`method` must be one of {methods}"
+        raise ValueError(message)
+
+    contains_nans = _contains_nan(x, nan_policy, xp_omit_okay=True, xp=xp)
+
+    if keepdims not in {None, True, False}:
+        message = "If specified, `keepdims` must be True or False."
+        raise ValueError(message)
+
+    # If data has length zero along `axis`, the result will be an array of NaNs just
+    # as if the data had length 1 along axis and were filled with NaNs. This is treated
+    # naturally below whether `nan_policy` is `'propagate'` or `'omit'`.
+    if x.shape[axis] == 0:
+        shape = list(x.shape)
+        shape[axis] = 1
+        x = xp.full(shape, xp.asarray(xp.nan, dtype=dtype))
+
+    y = xp.sort(x, axis=axis)
+    y, p = _broadcast_arrays((y, p), axis=axis)
+
+    if (keepdims is False) and (p.shape[axis] != 1):
+        message = "`keepdims` may be False only if the length of `p` along `axis` is 1."
+        raise ValueError(message)
+    keepdims = (p.shape[axis] != 1) if keepdims is None else keepdims
+
+    y = xp.moveaxis(y, axis, -1)
+    p = xp.moveaxis(p, axis, -1)
+
+    n = _length_nonmasked(y, -1, xp=xp, keepdims=True)
+    n = xp.asarray(n, dtype=dtype)
+    if contains_nans:
+        nans = xp.isnan(y)
+
+        # Note that if length along `axis` were 0 to begin with,
+        # it is now length 1 and filled with NaNs.
+        if nan_policy == 'propagate':
+            nan_out = xp.any(nans, axis=-1)
+        else:  # 'omit'
+            non_nan = xp.astype(~nans, xp.uint64)
+            n_int = xp.sum(non_nan, axis=-1, keepdims=True)
+            n = xp.astype(n_int, dtype)
+            # NaNs are produced only if slice is empty after removing NaNs
+            nan_out = xp.any(n == 0, axis=-1)
+            n = xpx.at(n, nan_out).set(y.shape[-1])  # avoids pytorch/pytorch#146211
+
+        if xp.any(nan_out):
+            y = xp.asarray(y, copy=True)  # ensure writable
+            y = xpx.at(y, nan_out).set(xp.nan)
+        elif xp.any(nans) and method == 'harrell-davis':
+            y = xp.asarray(y, copy=True)  # ensure writable
+            y = xpx.at(y, nans).set(0)  # any non-nan will prevent NaN from propagating
+
+    p_mask = (p > 1) | (p < 0) | xp.isnan(p)
+    if xp.any(p_mask):
+        p = xp.asarray(p, copy=True)
+        p = xpx.at(p, p_mask).set(0.5)  # these get NaN-ed out at the end
+
+    return y, p, method, axis, nan_policy, keepdims, n, axis_none, ndim, p_mask, xp
+
+
+def quantile(x, p, *, method='linear', axis=0, nan_policy='propagate', keepdims=None):
+    """
+    Compute the p-th quantile of the data along the specified axis.
+
+    Parameters
+    ----------
+    x : array_like of real numbers
+        Data array.
+    p : array_like of float
+        Probability or sequence of probabilities of the quantiles to compute.
+        Values must be between 0 and 1 (inclusive).
+        Must have length 1 along `axis` unless ``keepdims=True``.
+    method : str, default: 'linear'
+        The method to use for estimating the quantile.
+        The available options, numbered as they appear in [1]_, are:
+
+        1. 'inverted_cdf'
+        2. 'averaged_inverted_cdf'
+        3. 'closest_observation'
+        4. 'interpolated_inverted_cdf'
+        5. 'hazen'
+        6. 'weibull'
+        7. 'linear'  (default)
+        8. 'median_unbiased'
+        9. 'normal_unbiased'
+
+        'harrell-davis' is also available to compute the quantile estimate
+        according to [2]_.
+        See Notes for details.
+    axis : int or None, default: 0
+        Axis along which the quantiles are computed.
+        ``None`` ravels both `x` and `p` before performing the calculation,
+        without checking whether the original shapes were compatible.
+    nan_policy : str, default: 'propagate'
+        Defines how to handle NaNs in the input data `x`.
+
+        - ``propagate``: if a NaN is present in the axis slice (e.g. row) along
+          which the  statistic is computed, the corresponding slice of the output
+          will contain NaN(s).
+        - ``omit``: NaNs will be omitted when performing the calculation.
+          If insufficient data remains in the axis slice along which the
+          statistic is computed, the corresponding slice of the output will
+          contain NaN(s).
+        - ``raise``: if a NaN is present, a ``ValueError`` will be raised.
+
+        If NaNs are present in `p`, a ``ValueError`` will be raised.
+    keepdims : bool, optional
+        Consider the case in which `x` is 1-D and `p` is a scalar: the quantile
+        is a reducing statistic, and the default behavior is to return a scalar.
+        If `keepdims` is set to True, the axis will not be reduced away, and the
+        result will be a 1-D array with one element.
+
+        The general case is more subtle, since multiple quantiles may be
+        requested for each axis-slice of `x`. For instance, if both `x` and `p`
+        are 1-D and ``p.size > 1``, no axis can be reduced away; there must be an
+        axis to contain the number of quantiles given by ``p.size``. Therefore:
+
+        - By default, the axis will be reduced away if possible (i.e. if there is
+          exactly one element of `q` per axis-slice of `x`).
+        - If `keepdims` is set to True, the axis will not be reduced away.
+        - If `keepdims` is set to False, the axis will be reduced away
+          if possible, and an error will be raised otherwise.
+
+    Returns
+    -------
+    quantile : scalar or ndarray
+        The resulting quantile(s). The dtype is the result dtype of `x` and `p`.
+
+    Notes
+    -----
+    Given a sample `x` from an underlying distribution, `quantile` provides a
+    nonparametric estimate of the inverse cumulative distribution function.
+
+    By default, this is done by interpolating between adjacent elements in
+    ``y``, a sorted copy of `x`::
+
+        (1-g)*y[j] + g*y[j+1]
+
+    where the index ``j`` and coefficient ``g`` are the integral and
+    fractional components of ``p * (n-1)``, and ``n`` is the number of
+    elements in the sample.
+
+    This is a special case of Equation 1 of H&F [1]_. More generally,
+
+    - ``j = (p*n + m - 1) // 1``, and
+    - ``g = (p*n + m - 1) % 1``,
+
+    where ``m`` may be defined according to several different conventions.
+    The preferred convention may be selected using the ``method`` parameter:
+
+    =============================== =============== ===============
+    ``method``                      number in H&F   ``m``
+    =============================== =============== ===============
+    ``interpolated_inverted_cdf``   4               ``0``
+    ``hazen``                       5               ``1/2``
+    ``weibull``                     6               ``p``
+    ``linear`` (default)            7               ``1 - p``
+    ``median_unbiased``             8               ``p/3 + 1/3``
+    ``normal_unbiased``             9               ``p/4 + 3/8``
+    =============================== =============== ===============
+
+    Note that indices ``j`` and ``j + 1`` are clipped to the range ``0`` to
+    ``n - 1`` when the results of the formula would be outside the allowed
+    range of non-negative indices. When ``j`` is clipped to zero, ``g`` is
+    set to zero as well. The ``-1`` in the formulas for ``j`` and ``g``
+    accounts for Python's 0-based indexing.
+
+    The table above includes only the estimators from [1]_ that are continuous
+    functions of probability `p` (estimators 4-9). SciPy also provides the
+    three discontinuous estimators from [1]_ (estimators 1-3), where ``j`` is
+    defined as above, ``m`` is defined as follows, and ``g`` is ``0`` when
+    ``index = p*n + m - 1`` is less than ``0`` and otherwise is defined below.
+
+    1. ``inverted_cdf``: ``m = 0`` and ``g = int(index - j > 0)``
+    2. ``averaged_inverted_cdf``: ``m = 0`` and
+       ``g = (1 + int(index - j > 0)) / 2``
+    3. ``closest_observation``: ``m = -1/2`` and
+       ``g = 1 - int((index == j) & (j%2 == 1))``
+
+    A different strategy for computing quantiles from [2]_, ``method='harrell-davis'``,
+    uses a weighted combination of all elements. The weights are computed as:
+
+    .. math::
+
+        w_{n, i} = I_{i/n}(a, b) - I_{(i - 1)/n}(a, b)
+
+    where :math:`n` is the number of elements in the sample,
+    :math:`i` are the indices :math:`1, 2, ..., n-1, n` of the sorted elements,
+    :math:`a = p (n + 1)`, :math:`b = (1 - p)(n + 1)`,
+    :math:`p` is the probability of the quantile, and
+    :math:`I` is the regularized, lower incomplete beta function
+    (`scipy.special.betainc`).
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy import stats
+    >>> x = np.asarray([[10, 8, 7, 5, 4],
+    ...                 [0, 1, 2, 3, 5]])
+
+    Take the median along the last axis.
+
+    >>> stats.quantile(x, 0.5, axis=-1)
+    array([7.,  2.])
+
+    Take a different quantile along each axis.
+
+    >>> stats.quantile(x, [[0.25], [0.75]], axis=-1, keepdims=True)
+    array([[5.],
+           [3.]])
+
+    Take multiple quantiles along each axis.
+
+    >>> stats.quantile(x, [0.25, 0.75], axis=-1)
+    array([[5., 8.],
+           [1., 3.]])
+
+    References
+    ----------
+    .. [1] R. J. Hyndman and Y. Fan,
+       "Sample quantiles in statistical packages,"
+       The American Statistician, 50(4), pp. 361-365, 1996
+    .. [2] Harrell, Frank E., and C. E. Davis.
+       "A new distribution-free quantile estimator."
+       Biometrika 69.3 (1982): 635-640.
+
+    """
+    # Input validation / standardization
+
+    temp = _quantile_iv(x, p, method, axis, nan_policy, keepdims)
+    y, p, method, axis, nan_policy, keepdims, n, axis_none, ndim, p_mask, xp = temp
+
+    if method in {'inverted_cdf', 'averaged_inverted_cdf', 'closest_observation',
+                  'hazen', 'interpolated_inverted_cdf', 'linear',
+                  'median_unbiased', 'normal_unbiased', 'weibull'}:
+        res = _quantile_hf(y, p, n, method, xp)
+    elif method in {'harrell-davis'}:
+        res = _quantile_hd(y, p, n, xp)
+
+    res = xpx.at(res, p_mask).set(xp.nan)
+
+    # Reshape per axis/keepdims
+    if axis_none and keepdims:
+        shape = (1,)*(ndim - 1) + res.shape
+        res = xp.reshape(res, shape)
+        axis = -1
+
+    res = xp.moveaxis(res, -1, axis)
+
+    if not keepdims:
+        res = xp.squeeze(res, axis=axis)
+
+    return res[()] if res.ndim == 0 else res
+
+
+def _quantile_hf(y, p, n, method, xp):
+    ms = dict(inverted_cdf=0, averaged_inverted_cdf=0, closest_observation=-0.5,
+              interpolated_inverted_cdf=0, hazen=0.5, weibull=p, linear=1 - p,
+              median_unbiased=p/3 + 1/3, normal_unbiased=p/4 + 3/8)
+    m = ms[method]
+    jg = p*n + m - 1
+    j = jg // 1
+    g = jg % 1
+    if method == 'inverted_cdf':
+        g = xp.astype((g > 0), jg.dtype)
+    elif method == 'averaged_inverted_cdf':
+        g = (1 + xp.astype((g > 0), jg.dtype)) / 2
+    elif method == 'closest_observation':
+        g = (1 - xp.astype((g == 0) & (j % 2 == 1), jg.dtype))
+    if method in {'inverted_cdf', 'averaged_inverted_cdf', 'closest_observation'}:
+        g = xp.asarray(g)
+        g = xpx.at(g, jg < 0).set(0)
+
+    g[j < 0] = 0
+    j = xp.clip(j, 0., n - 1)
+    jp1 = xp.clip(j + 1, 0., n - 1)
+
+    return ((1 - g) * xp.take_along_axis(y, xp.astype(j, xp.int64), axis=-1)
+            + g * xp.take_along_axis(y, xp.astype(jp1, xp.int64), axis=-1))
+
+
+def _quantile_hd(y, p, n, xp):
+    # RE axis handling: We need to perform a reducing operation over rows of `y` for
+    # each element in the corresponding row of `p` (a la Cartesian product). Strategy:
+    # move rows of `p` to an axis at the front that is orthogonal to all the rest,
+    # perform the reducing operating over the last axis, then move the front axis back
+    # to the end.
+    p = xp.moveaxis(p, -1, 0)[..., xp.newaxis]
+    a = p * (n + 1)
+    b = (1 - p) * (n + 1)
+    i = xp.arange(y.shape[-1] + 1, dtype=y.dtype)
+    w = betainc(a, b, i / n)
+    w = w[..., 1:] - w[..., :-1]
+    w = xpx.at(w, xp.isnan(w)).set(0)
+    res = xp.vecdot(w, y, axis=-1)
+    return xp.moveaxis(res, 0, -1)

scipy/stats/_resampling.py

@@ -7,7 +7,7 @@ import inspect
 
 from scipy._lib._util import (check_random_state, _rename_parameter, rng_integers,
                               _transition_to_rng)
-from scipy._lib._array_api import array_namespace, is_numpy, xp_moveaxis_to_end
+from scipy._lib._array_api import array_namespace, is_numpy, xp_result_type
 from scipy.special import ndtr, ndtri, comb, factorial
 
 from ._common import ConfidenceInterval
@@ -183,20 +183,7 @@ def _bootstrap_iv(data, statistic, vectorized, paired, axis, confidence_level,
     if n_samples == 0:
         raise ValueError("`data` must contain at least one sample.")
 
-    message = ("Ignoring the dimension specified by `axis`, arrays in `data` do not "
-               "have the same shape. Beginning in SciPy 1.16.0, `bootstrap` will "
-               "explicitly broadcast elements of `data` to the same shape (ignoring "
-               "`axis`) before performing the calculation. To avoid this warning in "
-               "the meantime, ensure that all samples have the same shape (except "
-               "potentially along `axis`).")
-    data = [np.atleast_1d(sample) for sample in data]
-    reduced_shapes = set()
-    for sample in data:
-        reduced_shape = list(sample.shape)
-        reduced_shape.pop(axis)
-        reduced_shapes.add(tuple(reduced_shape))
-    if len(reduced_shapes) != 1:
-        warnings.warn(message, FutureWarning, stacklevel=3)
+    data = _broadcast_arrays(data, axis_int)
 
     data_iv = []
     for sample in data:
@@ -331,15 +318,6 @@ def bootstrap(data, statistic, *, n_resamples=9999, batch=None,
          Each element of `data` is a sample containing scalar observations from an
          underlying distribution. Elements of `data` must be broadcastable to the
          same shape (with the possible exception of the dimension specified by `axis`).
-
-         .. versionchanged:: 1.14.0
-             `bootstrap` will now emit a ``FutureWarning`` if the shapes of the
-             elements of `data` are not the same (with the exception of the dimension
-             specified by `axis`).
-             Beginning in SciPy 1.16.0, `bootstrap` will explicitly broadcast the
-             elements to the same shape (except along `axis`) before performing
-             the calculation.
-
     statistic : callable
         Statistic for which the confidence interval is to be calculated.
         `statistic` must be a callable that accepts ``len(data)`` samples
@@ -720,6 +698,7 @@ def _monte_carlo_test_iv(data, rvs, statistic, vectorized, n_resamples,
         vectorized = 'axis' in signature
 
     xp = array_namespace(*data)
+    dtype = xp_result_type(*data, force_floating=True, xp=xp)
 
     if not vectorized:
         if is_numpy(xp):
@@ -735,7 +714,7 @@ def _monte_carlo_test_iv(data, rvs, statistic, vectorized, n_resamples,
     data_iv = []
     for sample in data:
         sample = xp.broadcast_to(sample, (1,)) if sample.ndim == 0 else sample
-        sample = xp_moveaxis_to_end(sample, axis_int, xp=xp)
+        sample = xp.moveaxis(sample, axis_int, -1)
         data_iv.append(sample)
 
     n_resamples_int = int(n_resamples)
@@ -754,10 +733,6 @@ def _monte_carlo_test_iv(data, rvs, statistic, vectorized, n_resamples,
     if alternative not in alternatives:
         raise ValueError(f"`alternative` must be in {alternatives}")
 
-    # Infer the desired p-value dtype based on the input types
-    min_float = getattr(xp, 'float16', xp.float32)
-    dtype = xp.result_type(*data_iv, min_float)
-
     return (data_iv, rvs, statistic_vectorized, vectorized, n_resamples_int,
             batch_iv, alternative, axis_int, dtype, xp)
 

scipy/stats/_sampling.py

@@ -1028,7 +1028,7 @@ class FastGeneratorInversion:
         4.507068014335139e-07  # may vary
 
         """
-        if not isinstance(size, (numbers.Integral, np.integer)):
+        if not isinstance(size, numbers.Integral | np.integer):
             raise ValueError("size must be an integer.")
         # urng will be used to draw the samples for testing the error
         # it must not interfere with self.random_state. therefore, do not

scipy/stats/_stats_mstats_common.py

@@ -2,6 +2,7 @@ import warnings
 import numpy as np
 from . import distributions
 from .._lib._bunch import _make_tuple_bunch
+from ._axis_nan_policy import _axis_nan_policy_factory
 from ._stats_pythran import siegelslopes as siegelslopes_pythran
 
 __all__ = ['_find_repeats', 'theilslopes', 'siegelslopes']
@@ -14,6 +15,14 @@ SiegelslopesResult = _make_tuple_bunch('SiegelslopesResult',
                                        ['slope', 'intercept'])
 
 
+def _n_samples_optional_x(kwargs):
+    return 2 if kwargs.get('x', None) is not None else 1
+
+
+@_axis_nan_policy_factory(TheilslopesResult, default_axis=None, n_outputs=4,
+                          n_samples=_n_samples_optional_x,
+                          result_to_tuple=lambda x, _: tuple(x), paired=True,
+                          too_small=1)
 def theilslopes(y, x=None, alpha=0.95, method='separate'):
     r"""
     Computes the Theil-Sen estimator for a set of points (x, y).
@@ -131,7 +140,9 @@ def theilslopes(y, x=None, alpha=0.95, method='separate'):
     else:
         x = np.array(x, dtype=float, copy=True).ravel()
         if len(x) != len(y):
-            raise ValueError(f"Incompatible lengths ! ({len(y)}<>{len(x)})")
+            raise ValueError("Array shapes are incompatible for broadcasting.")
+    if len(x) < 2:
+        raise ValueError("`x` and `y` must have length at least 2.")
 
     # Compute sorted slopes only when deltax > 0
     deltax = x[:, np.newaxis] - x
@@ -192,6 +203,10 @@ def _find_repeats(arr):
     return unique[atleast2], freq[atleast2]
 
 
+@_axis_nan_policy_factory(SiegelslopesResult, default_axis=None, n_outputs=2,
+                          n_samples=_n_samples_optional_x,
+                          result_to_tuple=lambda x, _: tuple(x), paired=True,
+                          too_small=1)
 def siegelslopes(y, x=None, method="hierarchical"):
     r"""
     Computes the Siegel estimator for a set of points (x, y).
@@ -296,8 +311,12 @@ def siegelslopes(y, x=None, method="hierarchical"):
     else:
         x = np.asarray(x, dtype=float).ravel()
         if len(x) != len(y):
-            raise ValueError(f"Incompatible lengths ! ({len(y)}<>{len(x)})")
+            raise ValueError("Array shapes are incompatible for broadcasting.")
+    if len(x) < 2:
+        raise ValueError("`x` and `y` must have length at least 2.")
+
     dtype = np.result_type(x, y, np.float32)  # use at least float32
     y, x = y.astype(dtype), x.astype(dtype)
     medslope, medinter = siegelslopes_pythran(y, x, method)
+    medslope, medinter = np.asarray(medslope)[()], np.asarray(medinter)[()]
     return SiegelslopesResult(slope=medslope, intercept=medinter)