scipy 1.15.2__cp313-cp313t-musllinux_1_2_aarch64.whl → 1.16.0__cp313-cp313t-musllinux_1_2_aarch64.whl

scipy/special/_basic.py

@@ -2693,10 +2693,6 @@ def comb(N, k, *, exact=False, repetition=False):
     exact : bool, optional
         For integers, if `exact` is False, then floating point precision is
         used, otherwise the result is computed exactly.
-
-        .. deprecated:: 1.14.0
-            ``exact=True`` is deprecated for non-integer `N` and `k` and will raise an
-            error in SciPy 1.16.0
     repetition : bool, optional
         If `repetition` is True, then the number of combinations with
         repetition is computed.
@@ -2737,12 +2733,9 @@ def comb(N, k, *, exact=False, repetition=False):
         if int(N) == N and int(k) == k:
             # _comb_int casts inputs to integers, which is safe & intended here
             return _comb_int(N, k)
-        # otherwise, we disregard `exact=True`; it makes no sense for
-        # non-integral arguments
-        msg = ("`exact=True` is deprecated for non-integer `N` and `k` and will raise "
-               "an error in SciPy 1.16.0")
-        warnings.warn(msg, DeprecationWarning, stacklevel=2)
-        return comb(N, k)
+        else:
+            raise ValueError("Non-integer `N` and `k` with `exact=True` is not "
+                             "supported.")
     else:
         k, N = asarray(k), asarray(N)
         cond = (k <= N) & (N >= 0) & (k >= 0)
@@ -2796,19 +2789,17 @@ def perm(N, k, exact=False):
         N = np.squeeze(N)[()]  # for backward compatibility (accepted size 1 arrays)
         k = np.squeeze(k)[()]
         if not (isscalar(N) and isscalar(k)):
-            raise ValueError("`N` and `k` must scalar integers be with `exact=True`.")
+            raise ValueError("`N` and `k` must be scalar integers with `exact=True`.")
 
         floor_N, floor_k = int(N), int(k)
         non_integral = not (floor_N == N and floor_k == k)
-        if (k > N) or (N < 0) or (k < 0):
-            if non_integral:
-                msg = ("Non-integer `N` and `k` with `exact=True` is deprecated and "
-                       "will raise an error in SciPy 1.16.0.")
-                warnings.warn(msg, DeprecationWarning, stacklevel=2)
-            return 0
         if non_integral:
             raise ValueError("Non-integer `N` and `k` with `exact=True` is not "
                              "supported.")
+
+        if (k > N) or (N < 0) or (k < 0):
+            return 0
+
         val = 1
         for i in range(floor_N - floor_k + 1, floor_N + 1):
             val *= i
@@ -2990,14 +2981,20 @@ def _factorialx_approx_core(n, k, extend):
     # scalar case separately, unified handling would be inefficient for arrays;
     # don't use isscalar due to numpy/numpy#23574; 0-dim arrays treated below
     if not isinstance(n, np.ndarray):
-        return (
-            np.power(k, (n - n_mod_k) / k)
-            * gamma(n / k + 1) / gamma(n_mod_k / k + 1)
-            * max(n_mod_k, 1)
-        )
+        with warnings.catch_warnings():
+            # large n cause overflow warnings, but infinity is fine
+            warnings.simplefilter("ignore", RuntimeWarning)
+            return (
+                np.power(k, (n - n_mod_k) / k)
+                * gamma(n / k + 1) / gamma(n_mod_k / k + 1)
+                * max(n_mod_k, 1)
+            )
 
     # factor that's independent of the residue class (see factorialk docstring)
-    result = np.power(k, n / k) * gamma(n / k + 1)
+    with warnings.catch_warnings():
+        # large n cause overflow warnings, but infinity is fine
+        warnings.simplefilter("ignore", RuntimeWarning)
+        result = np.power(k, n / k) * gamma(n / k + 1)
     # factor dependent on residue r (for `r=0` it's 1, so we skip `r=0`
     # below and thus also avoid evaluating `max(r, 1)`)
     def corr(k, r): return np.power(k, -r / k) / gamma(r / k + 1) * r
@@ -3104,8 +3101,8 @@ def _factorialx_wrapper(fname, n, k, exact, extend):
         elif n in {0, 1}:
             return 1 if exact else np.float64(1)
         elif exact and _is_subdtype(type(n), "i"):
-            # calculate with integers
-            return _range_prod(1, n, k=k)
+            # calculate with integers; cast away other int types (like unsigned)
+            return _range_prod(1, int(n), k=k)
         elif exact:
             # only relevant for factorial
             raise ValueError(msg_exact_not_possible.format(dtype=type(n)))

scipy/special/_logsumexp.py

@@ -1,12 +1,10 @@
-import math
 import numpy as np
-from scipy._lib._util import _asarray_validated
 from scipy._lib._array_api import (
     array_namespace,
+    xp_capabilities,
+    xp_device,
     xp_size,
-    xp_broadcast_promote,
-    xp_real,
-    xp_copy,
+    xp_promote,
     xp_float_to_complex,
 )
 from scipy._lib import array_api_extra as xpx
@@ -14,6 +12,7 @@ from scipy._lib import array_api_extra as xpx
 __all__ = ["logsumexp", "softmax", "log_softmax"]
 
 
+@xp_capabilities()
 def logsumexp(a, axis=None, b=None, keepdims=False, return_sign=False):
     """Compute the log of the sum of exponentials of input elements.
 
@@ -61,7 +60,8 @@ def logsumexp(a, axis=None, b=None, keepdims=False, return_sign=False):
 
     See Also
     --------
-    numpy.logaddexp, numpy.logaddexp2
+    :data:`numpy.logaddexp`
+    :data:`numpy.logaddexp2`
 
     Notes
     -----
@@ -108,28 +108,45 @@ def logsumexp(a, axis=None, b=None, keepdims=False, return_sign=False):
 
     """
     xp = array_namespace(a, b)
-    a, b = xp_broadcast_promote(a, b, ensure_writeable=True, force_floating=True, xp=xp)
+    a, b = xp_promote(a, b, broadcast=True, force_floating=True, xp=xp)
     a = xpx.atleast_nd(a, ndim=1, xp=xp)
     b = xpx.atleast_nd(b, ndim=1, xp=xp) if b is not None else b
     axis = tuple(range(a.ndim)) if axis is None else axis
 
     if xp_size(a) != 0:
+        with np.errstate(divide='ignore', invalid='ignore', over='ignore'):
+            # Where result is infinite, we use the direct logsumexp calculation to
+            # delegate edge case handling to the behavior of `xp.log` and `xp.exp`,
+            # which should follow the C99 standard for complex values.
+            b_exp_a = xp.exp(a) if b is None else b * xp.exp(a)
+            sum_ = xp.sum(b_exp_a, axis=axis, keepdims=True)
+            sgn_inf = _sign(sum_, xp=xp) if return_sign else None
+            sum_ = xp.abs(sum_) if return_sign else sum_
+            out_inf = xp.log(sum_)
+
         with np.errstate(divide='ignore', invalid='ignore'):  # log of zero is OK
             out, sgn = _logsumexp(a, b, axis=axis, return_sign=return_sign, xp=xp)
+
+        # Replace infinite results. This probably could be done with an
+        # `apply_where`-like strategy to avoid redundant calculation, but currently
+        # `apply_where` itself is only for elementwise functions.
+        out_finite = xp.isfinite(out)
+        out = xp.where(out_finite, out, out_inf)
+        sgn = xp.where(out_finite, sgn, sgn_inf) if return_sign else sgn
     else:
         shape = np.asarray(a.shape)  # NumPy is convenient for shape manipulation
         shape[axis] = 1
-        out = xp.full(tuple(shape), -xp.inf, dtype=a.dtype)
+        out = xp.full(tuple(shape), -xp.inf, dtype=a.dtype, device=xp_device(a))
         sgn = xp.sign(out)
 
     if xp.isdtype(out.dtype, 'complex floating'):
         if return_sign:
             real = xp.real(sgn)
-            imag = xp_float_to_complex(_wrap_radians(xp.imag(sgn), xp))
+            imag = xp_float_to_complex(_wrap_radians(xp.imag(sgn), xp=xp), xp=xp)
             sgn = real + imag*1j
         else:
             real = xp.real(out)
-            imag = xp_float_to_complex(_wrap_radians(xp.imag(out), xp))
+            imag = xp_float_to_complex(_wrap_radians(xp.imag(out), xp=xp), xp=xp)
             out = real + imag*1j
 
     # Deal with shape details - reducing dimensions and convert 0-D to scalar for NumPy
@@ -141,17 +158,15 @@ def logsumexp(a, axis=None, b=None, keepdims=False, return_sign=False):
     return (out, sgn) if return_sign else out
 
 
-def _wrap_radians(x, xp=None):
-    xp = array_namespace(x) if xp is None else xp
+def _wrap_radians(x, *, xp):
     # Wrap radians to (-pi, pi] interval
-    out = -((-x + math.pi) % (2 * math.pi) - math.pi)
+    wrapped = -((-x + xp.pi) % (2 * xp.pi) - xp.pi)
     # preserve relative precision
     no_wrap = xp.abs(x) < xp.pi
-    out[no_wrap] = x[no_wrap]
-    return out
+    return xp.where(no_wrap, x, wrapped)
 
 
-def _elements_and_indices_with_max_real(a, axis=-1, xp=None):
+def _elements_and_indices_with_max_real(a, *, axis=-1, xp):
     # This is an array-API compatible `max` function that works something
     # like `np.max` for complex input. The important part is that it finds
     # the element with maximum real part. When there are multiple complex values
@@ -160,88 +175,86 @@ def _elements_and_indices_with_max_real(a, axis=-1, xp=None):
     # `take_along_axis`, and even if it did, we would have problems with axis tuples.
     # Feel free to rewrite! It's ugly, but it's not the purpose of the PR, and
     # it gets the job done.
-    xp = array_namespace(a) if xp is None else xp
 
     if xp.isdtype(a.dtype, "complex floating"):
         # select all elements with max real part.
         real_a = xp.real(a)
-        max = xp.max(real_a, axis=axis, keepdims=True)
-        mask = real_a == max
+        max_ = xp.max(real_a, axis=axis, keepdims=True)
+        mask = real_a == max_
 
         # Of those, choose one arbitrarily. This is a reasonably
         # simple, array-API compatible way of doing so that doesn't
         # have a problem with `axis` being a tuple or None.
-        i = xp.reshape(xp.arange(xp_size(a)), a.shape)
-        i[~mask] = -1
+        i = xp.reshape(xp.arange(xp_size(a), device=xp_device(a)), a.shape)
+        i = xpx.at(i, ~mask).set(-1)
         max_i = xp.max(i, axis=axis, keepdims=True)
         mask = i == max_i
-        a = xp_copy(a)
-        a[~mask] = 0
-        max = xp.sum(a, axis=axis, dtype=a.dtype, keepdims=True)
+        a = xp.where(mask, a, 0.)
+        max_ = xp.sum(a, axis=axis, dtype=a.dtype, keepdims=True)
     else:
-        max = xp.max(a, axis=axis, keepdims=True)
-        mask = a == max
-
-    return xp.asarray(max), xp.asarray(mask)
+        max_ = xp.max(a, axis=axis, keepdims=True)
+        mask = a == max_
 
+    return max_, mask
 
-def _sign(x, xp):
-    return x / xp.where(x == 0, xp.asarray(1, dtype=x.dtype), xp.abs(x))
 
+def _sign(x, *, xp):
+    return x / xp.where(x == 0, 1., xp.abs(x))
 
-def _logsumexp(a, b, axis, return_sign, xp):
 
+def _logsumexp(a, b, *, axis, return_sign, xp):
     # This has been around for about a decade, so let's consider it a feature:
     # Even if element of `a` is infinite or NaN, it adds nothing to the sum if
     # the corresponding weight is zero.
     if b is not None:
-        a[b == 0] = -xp.inf
+        a = xpx.at(a, b == 0).set(-xp.inf, copy=True)
 
     # Find element with maximum real part, since this is what affects the magnitude
     # of the exponential. Possible enhancement: include log of `b` magnitude in `a`.
     a_max, i_max = _elements_and_indices_with_max_real(a, axis=axis, xp=xp)
 
     # for precision, these terms are separated out of the main sum.
-    a[i_max] = -xp.inf
+    a = xpx.at(a, i_max).set(-xp.inf, copy=True if b is None else None)
     i_max_dt = xp.astype(i_max, a.dtype)
     # This is an inefficient way of getting `m` because it is the sum of a sparse
     # array; however, this is the simplest way I can think of to get the right shape.
-    m = (xp.sum(i_max_dt, axis=axis, keepdims=True, dtype=a.dtype) if b is None
-         else xp.sum(b * i_max_dt, axis=axis, keepdims=True, dtype=a.dtype))
-
-    # Arithmetic between infinities will introduce NaNs.
-    # `+ a_max` at the end naturally corrects for removing them here.
-    shift = xp.where(xp.isfinite(a_max), a_max, xp.asarray(0, dtype=a_max.dtype))
+    b_i_max = i_max_dt if b is None else b * i_max_dt
+    m = xp.sum(b_i_max, axis=axis, keepdims=True, dtype=a.dtype)
 
     # Shift, exponentiate, scale, and sum
-    exp = b * xp.exp(a - shift) if b is not None else xp.exp(a - shift)
+    exp = b * xp.exp(a - a_max) if b is not None else xp.exp(a - a_max)
     s = xp.sum(exp, axis=axis, keepdims=True, dtype=exp.dtype)
     s = xp.where(s == 0, s, s/m)
 
     # Separate sign/magnitude information
-    sgn = None
-    if return_sign:
-        # Use the numpy>=2.0 convention for sign.
-        # When all array libraries agree, this can become sng = xp.sign(s).
-        sgn = _sign(s + 1, xp=xp) * _sign(m, xp=xp)
-
-        if xp.isdtype(s.dtype, "real floating"):
-            # The log functions need positive arguments
-            s = xp.where(s < -1, -s - 2, s)
-            m = xp.abs(m)
-        else:
-            # `a_max` can have a sign component for complex input
-            j = xp.asarray(1j, dtype=a_max.dtype)
-            sgn = sgn * xp.exp(xp.imag(a_max) * j)
+    # Originally, this was only performed if `return_sign=True`.
+    # However, this is also needed if any elements of `m < 0` or `s < -1`.
+    # An improvement would be to perform the calculations only on these entries.
+
+    # Use the numpy>=2.0 convention for sign.
+    # When all array libraries agree, this can become sng = xp.sign(s).
+    sgn = _sign(s + 1, xp=xp) * _sign(m, xp=xp)
+
+    if xp.isdtype(s.dtype, "real floating"):
+        # The log functions need positive arguments
+        s = xp.where(s < -1, -s - 2, s)
+        m = xp.abs(m)
+    else:
+        # `a_max` can have a sign component for complex input
+        sgn = sgn * xp.exp(xp.imag(a_max) * 1.0j)
 
     # Take log and undo shift
     out = xp.log1p(s) + xp.log(m) + a_max
 
-    out = xp_real(out) if return_sign else out
+    if return_sign:
+        out = xp.real(out)
+    elif xp.isdtype(out.dtype, 'real floating'):
+        out = xpx.at(out)[sgn < 0].set(xp.nan)
 
     return out, sgn
 
 
+@xp_capabilities()
 def softmax(x, axis=None):
     r"""Compute the softmax function.
 
@@ -333,12 +346,14 @@ def softmax(x, axis=None):
     array([ 1.,  1.,  1.])
 
     """
-    x = _asarray_validated(x, check_finite=False)
-    x_max = np.amax(x, axis=axis, keepdims=True)
-    exp_x_shifted = np.exp(x - x_max)
-    return exp_x_shifted / np.sum(exp_x_shifted, axis=axis, keepdims=True)
+    xp = array_namespace(x)
+    x = xp.asarray(x)
+    x_max = xp.max(x, axis=axis, keepdims=True)
+    exp_x_shifted = xp.exp(x - x_max)
+    return exp_x_shifted / xp.sum(exp_x_shifted, axis=axis, keepdims=True)
 
 
+@xp_capabilities()
 def log_softmax(x, axis=None):
     r"""Compute the logarithm of the softmax function.
 
@@ -390,23 +405,22 @@ def log_softmax(x, axis=None):
     array([  0., -inf])
 
     """
+    xp = array_namespace(x)
+    x = xp.asarray(x)
 
-    x = _asarray_validated(x, check_finite=False)
-
-    x_max = np.amax(x, axis=axis, keepdims=True)
+    x_max = xp.max(x, axis=axis, keepdims=True)
 
     if x_max.ndim > 0:
-        x_max[~np.isfinite(x_max)] = 0
-    elif not np.isfinite(x_max):
+        x_max = xpx.at(x_max, ~xp.isfinite(x_max)).set(0)
+    elif not xp.isfinite(x_max):
         x_max = 0
 
     tmp = x - x_max
-    exp_tmp = np.exp(tmp)
+    exp_tmp = xp.exp(tmp)
 
     # suppress warnings about log of zero
     with np.errstate(divide='ignore'):
-        s = np.sum(exp_tmp, axis=axis, keepdims=True)
-        out = np.log(s)
+        s = xp.sum(exp_tmp, axis=axis, keepdims=True)
+        out = xp.log(s)
 
-    out = tmp - out
-    return out
+    return tmp - out

scipy/special/_orthogonal.pyi

@@ -1,10 +1,10 @@
 from typing import (
     Any,
-    Callable,
     Literal,
     Optional,
     overload,
 )
+from collections.abc import Callable
 
 import numpy as np
 

scipy/special/_spherical_bessel.py

@@ -1,5 +1,5 @@
 from functools import wraps
-from scipy._lib._util import _lazywhere
+import scipy._lib.array_api_extra as xpx
 import numpy as np
 from ._ufuncs import (_spherical_jn, _spherical_yn, _spherical_in,
                       _spherical_kn, _spherical_jn_d, _spherical_yn_d,
@@ -28,9 +28,9 @@ def use_reflection(sign_n_even=None, reflection_fun=None):
                 return fun(n, z, derivative)  # complex dtype just works
 
             f2 = standard_reflection if reflection_fun is None else reflection_fun
-            return _lazywhere(z.real >= 0, (n, z),
-                              f=lambda n, z: fun(n, z, derivative),
-                              f2=lambda n, z: f2(n, z, derivative))[()]
+            return xpx.apply_where(z.real >= 0, (n, z),
+                                   lambda n, z: fun(n, z, derivative),
+                                   lambda n, z: f2(n, z, derivative))[()]
         return wrapper
     return decorator