scipy 1.16.1__cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl → 1.16.2__cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

scipy/__config__.py

@@ -36,7 +36,7 @@ CONFIG = _cleanup(
             "cython": {
                 "name": r"cython",
                 "linker": r"cython",
-                "version": r"3.1.2",
+                "version": r"3.1.3",
                 "commands": r"cython",
                 "args": r"",
                 "linker args": r"",
@@ -59,7 +59,7 @@ CONFIG = _cleanup(
             },
             "pythran": {
                 "version": r"0.18.0",
-                "include directory": r"../../tmp/build-env-stjxhef6/lib/python3.14/site-packages/pythran"
+                "include directory": r"../../tmp/build-env-98ospmy4/lib/python3.14/site-packages/pythran"
             },
         },
         "Machine Information": {
@@ -81,32 +81,32 @@ CONFIG = _cleanup(
             "blas": {
                 "name": "scipy-openblas",
                 "found": bool("True".lower().replace('false', '')),
-                "version": "0.3.28",
+                "version": "0.3.29.dev",
                 "detection method": "pkgconfig",
                 "include directory": r"/opt/_internal/cpython-3.14.0rc1/lib/python3.14/site-packages/scipy_openblas32/include",
                 "lib directory": r"/opt/_internal/cpython-3.14.0rc1/lib/python3.14/site-packages/scipy_openblas32/lib",
-                "openblas configuration": r"OpenBLAS 0.3.28 DYNAMIC_ARCH NO_AFFINITY neoversen2 MAX_THREADS=64",
+                "openblas configuration": r"OpenBLAS 0.3.29.dev DYNAMIC_ARCH NO_AFFINITY neoversev2 MAX_THREADS=64",
                 "pc file directory": r"/project",
             },
             "lapack": {
                 "name": "scipy-openblas",
                 "found": bool("True".lower().replace('false', '')),
-                "version": "0.3.28",
+                "version": "0.3.29.dev",
                 "detection method": "pkgconfig",
                 "include directory": r"/opt/_internal/cpython-3.14.0rc1/lib/python3.14/site-packages/scipy_openblas32/include",
                 "lib directory": r"/opt/_internal/cpython-3.14.0rc1/lib/python3.14/site-packages/scipy_openblas32/lib",
-                "openblas configuration": r"OpenBLAS 0.3.28 DYNAMIC_ARCH NO_AFFINITY neoversen2 MAX_THREADS=64",
+                "openblas configuration": r"OpenBLAS 0.3.29.dev DYNAMIC_ARCH NO_AFFINITY neoversev2 MAX_THREADS=64",
                 "pc file directory": r"/project",
             },
             "pybind11": {
                 "name": "pybind11",
-                "version": "3.0.0",
+                "version": "3.0.1",
                 "detection method": "config-tool",
                 "include directory": r"unknown",
             },
         },
         "Python Information": {
-            "path": r"/tmp/build-env-stjxhef6/bin/python",
+            "path": r"/tmp/build-env-98ospmy4/bin/python",
             "version": "3.14",
         },
     }

scipy/linalg/tests/test_lapack.py

@@ -4,6 +4,7 @@
 
 from functools import reduce
 import random
+import sysconfig
 
 from numpy.testing import (assert_equal, assert_array_almost_equal, assert_,
                            assert_allclose, assert_almost_equal,
@@ -503,7 +504,7 @@ class TestDlasd4:
             roots.append(res[1])
 
             assert_(
-                (res[3] <= 0), 
+                (res[3] <= 0),
                 f"LAPACK root finding dlasd4 failed to find the singular value {i}"
             )
         roots = np.array(roots)[::-1]
@@ -3495,6 +3496,9 @@ def test_sy_hetrs(mtype, dtype, lower):
 def test_sy_he_tri(dtype, lower, mtype):
     if mtype == 'he' and dtype in REAL_DTYPES:
         pytest.skip("hetri not for real dtypes.")
+    if sysconfig.get_platform() == 'win-arm64' and dtype in COMPLEX_DTYPES:
+        pytest.skip("Test segfaulting on win-arm64 in CI, see gh-23133")
+
     rng = np.random.default_rng(1723059677121834)
     n = 20
     A = rng.random((n, n)) + rng.random((n, n))*1j

scipy/optimize/_lbfgsb_py.py

@@ -440,8 +440,8 @@ def _minimize_lbfgsb(fun, x0, args=(), jac=None, bounds=None,
         raise ValueError('maxls must be positive.')
 
     x = array(x0, dtype=np.float64)
-    f = array(0.0, dtype=np.int32)
-    g = zeros((n,), dtype=np.int32)
+    f = array(0.0, dtype=np.float64)
+    g = zeros((n,), dtype=np.float64)
     wa = zeros(2*m*n + 5*n + 11*m*m + 8*m, float64)
     iwa = zeros(3*n, dtype=np.int32)
     task = zeros(2, dtype=np.int32)

scipy/optimize/_slsqp_py.py

@@ -234,8 +234,8 @@ def _minimize_slsqp(func, x0, args=(), jac=None, bounds=None,
     disp : bool
         Set to True to print convergence messages. If False,
         `verbosity` is ignored and set to 0.
-    maxiter : int
-        Maximum number of iterations.
+    maxiter : int, optional
+        Maximum number of iterations. Default value is 100.
     finite_diff_rel_step : None or array_like, optional
         If ``jac in ['2-point', '3-point', 'cs']`` the relative step size to
         use for numerical approximation of `jac`. The absolute step
@@ -268,8 +268,8 @@ def _minimize_slsqp(func, x0, args=(), jac=None, bounds=None,
     attribute as a NumPy array. Denoting the dimension of the equality constraints
     with ``meq``, and of inequality constraints with ``mineq``, then the returned
     array slice ``m[:meq]`` contains the multipliers for the equality constraints,
-    and the remaining ``m[meq:meq + mineq]`` contains the multipliers for the 
-    inequality constraints. The multipliers corresponding to bound inequalities 
+    and the remaining ``m[meq:meq + mineq]`` contains the multipliers for the
+    inequality constraints. The multipliers corresponding to bound inequalities
     are not returned. See [1]_ pp. 321 or [2]_ for an explanation of how to interpret
     these multipliers. The internal QP problem is solved using the methods given
     in [3]_ Chapter 25.
@@ -461,7 +461,7 @@ def _minimize_slsqp(func, x0, args=(), jac=None, bounds=None,
         "inconsistent": 0,
         "reset": 0,
         "iter": 0,
-        "itermax": maxiter,
+        "itermax": int(maxiter),
         "line": 0,
         "m": m,
         "meq": meq,

scipy/optimize/tests/test_optimize.py

@@ -3167,6 +3167,15 @@ def test_bounds_with_list():
     )
 
 
+@pytest.mark.parametrize('method', (
+    'slsqp', 'cg', 'cobyqa', 'powell','nelder-mead', 'bfgs', 'l-bfgs-b',
+    'trust-constr'))
+def test_minimize_maxiter_noninteger(method):
+    # Regression test for gh-23430
+    x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2])
+    optimize.minimize(rosen, x0, method=method, options={'maxiter': 100.1})
+
+
 def test_x_overwritten_user_function():
     # if the user overwrites the x-array in the user function it's likely
     # that the minimizer stops working properly.

scipy/signal/_short_time_fft.py

@@ -1,11 +1,7 @@
 """Implementation of an FFT-based Short-time Fourier Transform. """
 
-# Implementation Notes for this file (as of 2023-07)
+# Implementation Notes for this file (as of 2025-08)
 # --------------------------------------------------
-# * MyPy version 1.1.1 does not seem to support decorated property methods
-#   properly. Hence, applying ``@property`` to methods decorated with `@cache``
-#   (as tried with the ``lower_border_end`` method) causes a mypy error when
-#   accessing it as an index (e.g., ``SFT.lower_border_end[0]``).
 # * Since the method `stft` and `istft` have identical names as the legacy
 #   functions in the signal module, referencing them as HTML link in the
 #   docstrings has to be done by an explicit `~ShortTimeFFT.stft` instead of an
@@ -17,10 +13,9 @@
 #   (currently 0.9). Consult Issue 18512 and PR 16660 for further details.
 
 
-# Provides typing union operator ``|`` in Python 3.9:
 # Linter does not allow to import ``Generator`` from ``typing`` module:
 from collections.abc import Generator, Callable
-from functools import cache, lru_cache, partial
+from functools import partial, cached_property
 from typing import get_args, Literal
 
 import numpy as np
@@ -419,6 +414,15 @@ class ShortTimeFFT:
     _fac_mag: float | None = None
     _fac_psd: float | None = None
     _lower_border_end: tuple[int, int] | None = None
+    # The following tuples store parameter(s) and return value(s) of methods for caching
+    # (initialized with invalid parameters; should only be accessed by atomic
+    # read/writes to alleviate potential multithreading issues):
+    _cache_post_padding: tuple[int, tuple[int, int]] = -1, (0, 0)
+    _cache_upper_border_begin: tuple[int, tuple[int, int]] = -1, (0, 0)
+    _cache_t: tuple[tuple[int, int | None, int | None, int, float], np.ndarray] = \
+        (-1, None, None, 0, 0.), np.ndarray([])
+    _cache_f: tuple[tuple[FFT_MODE_TYPE, int, float], np.ndarray] = \
+        ('onesided', -1, 1.), np.ndarray([])
 
     def __init__(self, win: np.ndarray, hop: int, fs: float, *,
                  fft_mode: FFT_MODE_TYPE = 'onesided',
@@ -1607,7 +1611,7 @@ class ShortTimeFFT:
         """
         return self.m_num // 2
 
-    @cache
+    @cached_property
     def _pre_padding(self) -> tuple[int, int]:
         """Smallest signal index and slice index due to padding.
 
@@ -1617,13 +1621,12 @@ class ShortTimeFFT:
         w2 = self.win.real**2 + self.win.imag**2
         # move window to the left until the overlap with t >= 0 vanishes:
         n0 = -self.m_num_mid
-        for q_, n_ in enumerate(range(n0, n0-self.m_num-1, -self.hop)):
+        for p_, n_ in enumerate(range(n0, n0-self.m_num-1, -self.hop)):
             n_next = n_ - self.hop
             if n_next + self.m_num <= 0 or all(w2[n_next:] == 0):
-                return n_, -q_
-        raise RuntimeError("This is code line should not have been reached!")
-        # If this case is reached, it probably means the first slice should be
-        # returned, i.e.: return n0, 0
+                return n_, -p_
+        # Make the linter happy:
+        raise RuntimeError("This code line should never run! Please file a bug.")
 
     @property
     def k_min(self) -> int:
@@ -1646,7 +1649,7 @@ class ShortTimeFFT:
         upper_border_begin: Where post-padding effects start.
         ShortTimeFFT: Class this property belongs to.
         """
-        return self._pre_padding()[0]
+        return self._pre_padding[0]
 
     @property
     def p_min(self) -> int:
@@ -1671,9 +1674,8 @@ class ShortTimeFFT:
         p_range: Determine and validate slice index range.
         ShortTimeFFT: Class this property belongs to.
         """
-        return self._pre_padding()[1]
+        return self._pre_padding[1]
 
-    @lru_cache(maxsize=256)
     def _post_padding(self, n: int) -> tuple[int, int]:
         """Largest signal index and slice index due to padding.
 
@@ -1681,9 +1683,17 @@ class ShortTimeFFT:
         ----------
         n : int
             Number of samples of input signal (must be ≥ half of the window length).
+
+        Notes
+        -----
+        Note that the return values are cached together with the parameter `n` to avoid
+        unnecessary recalculations.
         """
         if not (n >= (m2p := self.m_num - self.m_num_mid)):
             raise ValueError(f"Parameter n must be >= ceil(m_num/2) = {m2p}!")
+        last_arg, last_return_value = self._cache_post_padding
+        if n == last_arg:  # use cached value:
+            return last_return_value
         w2 = self.win.real**2 + self.win.imag**2
         # move window to the right until the overlap for t < t[n] vanishes:
         q1 = n // self.hop   # last slice index with t[p1] <= t[n]
@@ -1691,15 +1701,17 @@ class ShortTimeFFT:
         for q_, k_ in enumerate(range(k1, n+self.m_num, self.hop), start=q1):
             n_next = k_ + self.hop
             if n_next >= n or all(w2[:n-n_next] == 0):
-                return k_ + self.m_num, q_ + 1
-        raise RuntimeError("This is code line should not have been reached!")
+                return_value = k_ + self.m_num, q_ + 1
+                self._cache_post_padding = n, return_value
+                return return_value
+        raise RuntimeError("This code line should never run! Please file a bug.")
         # If this case is reached, it probably means the last slice should be
         # returned, i.e.: return k1 + self.m_num - self.m_num_mid, q1 + 1
 
     def k_max(self, n: int) -> int:
         """First sample index after signal end not touched by a time slice.
 
-        `k_max` - 1 is the largest sample index of the slice `p_max` for a
+        `k_max` - 1 is the largest sample index of the slice `p_max` - 1 for a
         given input signal of `n` samples.
         A detailed example is provided in the :ref:`tutorial_stft_sliding_win`
         section of the :ref:`user_guide`.
@@ -1785,7 +1797,6 @@ class ShortTimeFFT:
         upper_border_begin: Where post-padding effects start.
         ShortTimeFFT: Class this property belongs to.
         """
-        # not using @cache decorator due to MyPy limitations
         if self._lower_border_end is not None:
             return self._lower_border_end
 
@@ -1801,7 +1812,6 @@ class ShortTimeFFT:
         self._lower_border_end = (0, max(self.p_min, 0))  # ends at first slice
         return self._lower_border_end
 
-    @lru_cache(maxsize=256)
     def upper_border_begin(self, n: int) -> tuple[int, int]:
         """First signal index and first slice index affected by post-padding.
 
@@ -1823,6 +1833,11 @@ class ShortTimeFFT:
         p_ub : int
             Lowest index of time slice of which the end sticks out past the signal end.
 
+        Notes
+        -----
+        Note that the return values are cached together with the parameter `n` to avoid
+        unnecessary recalculations.
+
         See Also
         --------
         k_min: The smallest possible signal index.
@@ -1836,6 +1851,9 @@ class ShortTimeFFT:
         """
         if not (n >= (m2p := self.m_num - self.m_num_mid)):
             raise ValueError(f"Parameter n must be >= ceil(m_num/2) = {m2p}!")
+        last_arg, last_return_value = self._cache_upper_border_begin
+        if n == last_arg:  # use cached value:
+            return last_return_value
         w2 = self.win.real**2 + self.win.imag**2
         q2 = n // self.hop + 1  # first t[q] >= t[n]
         q1 = max((n-self.m_num) // self.hop - 1, -1)
@@ -1843,8 +1861,11 @@ class ShortTimeFFT:
         for q_ in range(q2, q1, -1):
             k_ = q_ * self.hop + (self.m_num - self.m_num_mid)
             if k_ <= n or all(w2[n-k_:] == 0):
-                return (q_ + 1) * self.hop - self.m_num_mid, q_ + 1
-        return 0, 0  # border starts at first slice
+                return_value = (q_ + 1) * self.hop - self.m_num_mid, q_ + 1
+                self. _cache_upper_border_begin = n, return_value
+                return return_value
+        # make linter happy:
+        raise RuntimeError("This code line should never run! Please file a bug.")
 
     @property
     def delta_t(self) -> float:
@@ -1912,7 +1933,6 @@ class ShortTimeFFT:
                              f"does not hold for signal length {n=}!")
         return p0_, p1_
 
-    @lru_cache(maxsize=1)
     def t(self, n: int, p0: int | None = None, p1: int | None = None,
           k_offset: int = 0) -> np.ndarray:
         """Times of STFT for an input signal with `n` samples.
@@ -1934,6 +1954,10 @@ class ShortTimeFFT:
         k_offset
             Index of first sample (t = 0) in `x`.
 
+        Notes
+        -----
+        Note that the returned array is cached together with the method's call
+        parameters to avoid unnecessary recalculations.
 
         See Also
         --------
@@ -1944,8 +1968,18 @@ class ShortTimeFFT:
         fs: Sampling frequency (being ``1/T``)
         ShortTimeFFT: Class this method belongs to.
         """
+        if not (n > 0 and isinstance(n, int | np.integer)):
+            raise ValueError(f"Parameter {n=} is not a positive integer!")
+        args = n, p0, p1, k_offset, self.T  # since `self.T` is mutable, it's needed too
+        last_args, last_return_value = self._cache_t
+        if args == last_args:  # use cached value:
+            return last_return_value
+
         p0, p1 = self.p_range(n, p0, p1)
-        return np.arange(p0, p1) * self.delta_t + k_offset * self.T
+        return_value = np.arange(p0, p1) * self.delta_t + k_offset * self.T
+
+        self._cache_t = args, return_value
+        return return_value
 
     def nearest_k_p(self, k: int, left: bool = True) -> int:
         """Return nearest sample index k_p for which t[k_p] == t[p] holds.
@@ -2022,6 +2056,7 @@ class ShortTimeFFT:
         """Frequencies values of the STFT.
 
         A 1d array of length `f_pts` with `delta_f` spaced entries is returned.
+        This array is calculated lazily.
 
         See Also
         --------
@@ -2030,15 +2065,22 @@ class ShortTimeFFT:
         mfft: Length of the input for FFT used.
         ShortTimeFFT: Class this property belongs to.
         """
+        last_state, last_return_value = self._cache_f
+        current_state = self.fft_mode, self.mfft, self.T
+        if current_state == last_state:  # use cached value:
+            return last_return_value
+
         if self.fft_mode in {'onesided', 'onesided2X'}:
-            return fft_lib.rfftfreq(self.mfft, self.T)
+            return_value = fft_lib.rfftfreq(self.mfft, self.T)
         elif self.fft_mode == 'twosided':
-            return fft_lib.fftfreq(self.mfft, self.T)
+            return_value = fft_lib.fftfreq(self.mfft, self.T)
         elif self.fft_mode == 'centered':
-            return fft_lib.fftshift(fft_lib.fftfreq(self.mfft, self.T))
-        # This should never happen but makes the Linters happy:
-        fft_modes = get_args(FFT_MODE_TYPE)
-        raise RuntimeError(f"{self.fft_mode=} not in {fft_modes}!")
+            return_value = fft_lib.fftshift(fft_lib.fftfreq(self.mfft, self.T))
+        else:  # This should never happen but makes the Linters happy:
+            fft_modes = get_args(FFT_MODE_TYPE)
+            raise RuntimeError(f"{self.fft_mode=} not in {fft_modes}!")
+        self._cache_f = current_state, return_value
+        return return_value
 
     def _fft_func(self, x: np.ndarray) -> np.ndarray:
         """FFT based on the `fft_mode`, `mfft`, `scaling` and `phase_shift`
@@ -2095,8 +2137,7 @@ class ShortTimeFFT:
             Xc[..., 1:q1] /= fac
             x = fft_lib.irfft(Xc, n=self.mfft, axis=-1)
         else:  # This should never happen but makes the Linter happy:
-            error_str = f"{self.fft_mode=} not in {get_args(FFT_MODE_TYPE)}!"
-            raise RuntimeError(error_str)
+            raise RuntimeError(f"{self.fft_mode=} not in {get_args(FFT_MODE_TYPE)}!")
 
         if self.phase_shift is None:
             return x[..., :self.m_num]

scipy/signal/_spectral_py.py

@@ -243,11 +243,11 @@ def lombscargle(
         )
 
     # weight vector must sum to 1
-    weights *= 1.0 / weights.sum()
+    weights = weights * (1.0 / weights.sum())
 
     # if requested, perform precenter
     if precenter:
-        y -= y.mean()
+        y = y - y.mean()
 
     # transform arrays
     # row vector

scipy/signal/tests/test_short_time_fft.py

@@ -531,11 +531,15 @@ def test_border_values():
     assert SFT.p_max(10) == 4
     assert SFT.k_max(10) == 16
     assert SFT.upper_border_begin(10) == (4, 2)
+    assert SFT.upper_border_begin(10) == (4, 2)  # needed to test caching
     # Raise exceptions:
     with pytest.raises(ValueError, match="^Parameter n must be"):
         SFT.upper_border_begin(3)
     with pytest.raises(ValueError, match="^Parameter n must be"):
         SFT._post_padding(3)
+    with pytest.raises(RuntimeError):
+        SFT._hop = -1  # illegal hop interval
+        SFT.upper_border_begin(8)
 
 def test_border_values_exotic():
     """Ensure that the border calculations are correct for windows with
@@ -573,6 +577,11 @@ def test_t():
     SFT.fs = 1/8
     assert SFT.fs == 1/8
     assert SFT.T == 8
+    with pytest.raises(ValueError):
+        # noinspection PyTypeChecker
+        SFT.t(1.5)  # only integers allowed
+    with pytest.raises(ValueError):
+        SFT.t(-1)  # only positive `n` allowed
 
 
 @pytest.mark.parametrize('fft_mode, f',

scipy/signal/tests/test_signaltools.py

@@ -2084,7 +2084,9 @@ class _TestLinearFilter:
         a = self.convert_dtype(a, xp)
         x = self.convert_dtype(x, xp)
         zi = self.convert_dtype(zi, xp)
-        assert_raises(ValueError, lfilter, b, a, x, axis, zi)
+        # NOTE: MemoryError is currently allowed below because of:
+        # https://github.com/numpy/numpy/issues/29721
+        assert_raises((ValueError, MemoryError), lfilter, b, a, x, axis, zi)
 
     @skip_xp_backends('cupy', reason='cupy does not raise')
     def test_bad_size_zi(self, xp):
@@ -2134,7 +2136,11 @@ class _TestLinearFilter:
         self.base_bad_size_zi([1, 1, 1], [1], x2, 0, [[0, 1, 2, 3], [4, 5, 6, 7]], xp)
 
         self.base_bad_size_zi([1], [1, 1], x2, 0, [0, 1, 2], xp)
-        self.base_bad_size_zi([1], [1, 1], x2, 0, [[[0, 1, 2]]], xp)
+        # this case is disabled on the release branch
+        # because of:
+        # https://github.com/scipy/scipy/pull/23543#issuecomment-3276286172
+        # https://github.com/numpy/numpy/issues/29721
+        #self.base_bad_size_zi([1], [1, 1], x2, 0, [[[0, 1, 2]]], xp)
         self.base_bad_size_zi([1], [1, 1], x2, 0, [[0], [1], [2]], xp)
         self.base_bad_size_zi([1], [1, 1], x2, 0, [[0, 1]], xp)
         self.base_bad_size_zi([1], [1, 1], x2, 0, [[0, 1, 2, 3]], xp)