scipy 1.16.1__cp313-cp313-win_amd64.whl → 1.16.2__cp313-cp313-win_amd64.whl

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)

scipy/signal/tests/test_spectral.py

@@ -1055,7 +1055,6 @@ class TestLombscargle:
         delta = f[1] - f[0]
         assert(w - f[np.argmax(P)] < (delta/2.))
 
-
     def test_amplitude(self):
         # Test if height of peak in unnormalized Lomb-Scargle periodogram
         # corresponds to amplitude of the generated input signal.
@@ -1503,6 +1502,45 @@ class TestLombscargle:
 
         lombscargle(t, y, freqs)
 
+    def test_input_mutation(self):
+        # this tests for mutation of the input arrays
+        # https://github.com/scipy/scipy/issues/23474
+
+        # Input parameters
+        ampl = 2.
+        w = 1.
+        phi = 0.5 * np.pi
+        nin = 100
+        nout = 1000
+        p = 0.7  # Fraction of points to select
+
+        # Randomly select a fraction of an array with timesteps
+        rng = np.random.default_rng()
+        r = rng.random(nin)
+        t = np.linspace(0.01*np.pi, 10.*np.pi, nin)[r >= p]
+
+        # Plot a sine wave for the selected times
+        y = ampl * np.sin(w*t + phi)
+
+        # Define the array of frequencies for which to compute the periodogram
+        f = np.linspace(0.01, 10., nout)
+
+        weights = np.ones_like(y)
+
+        # create original copies before passing
+        t_org = t.copy()
+        y_org = y.copy()
+        f_org = f.copy()
+        weights_org = weights.copy()
+
+        lombscargle(t, y, f, precenter=True, weights=weights)
+
+        # check all 4 array inputs
+        assert_array_equal(t, t_org)
+        assert_array_equal(y, y_org)
+        assert_array_equal(f, f_org)
+        assert_array_equal(weights, weights_org)
+
 
 class TestSTFT:
     @pytest.mark.thread_unsafe

scipy/spatial/qhull_src/COPYING_QHULL.txt

@@ -0,0 +1,39 @@
+                    Qhull, Copyright (c) 1993-2020
+                    
+                            C.B. Barber
+                           Arlington, MA 
+                          
+                               and
+
+       The National Science and Technology Research Center for
+        Computation and Visualization of Geometric Structures
+                        (The Geometry Center)
+                       University of Minnesota
+
+                       email: qhull@qhull.org
+
+This software includes Qhull from C.B. Barber and The Geometry Center.  
+Files derived from Qhull 1.0 are copyrighted by the Geometry Center.  The
+remaining files are copyrighted by C.B. Barber.  Qhull is free software 
+and may be obtained via http from www.qhull.org.  It may be freely copied, 
+modified, and redistributed under the following conditions:
+
+1. All copyright notices must remain intact in all files.
+
+2. A copy of this text file must be distributed along with any copies 
+   of Qhull that you redistribute; this includes copies that you have 
+   modified, or copies of programs or other software products that 
+   include Qhull.
+
+3. If you modify Qhull, you must include a notice giving the
+   name of the person performing the modification, the date of
+   modification, and the reason for such modification.
+
+4. When distributing modified versions of Qhull, or other software 
+   products that include Qhull, you must provide notice that the original 
+   source code may be obtained as noted above.
+
+5. There is no warranty or other guarantee of fitness for Qhull, it is 
+   provided solely "as is".  Bug reports or fixes may be sent to 
+   qhull_bug@qhull.org; the authors may or may not act on them as 
+   they desire.

scipy/spatial/tests/test_distance.py

@@ -32,14 +32,14 @@
 # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-import sys
-import os.path
-
 from functools import wraps, partial
+import os.path
+import sys
+import sysconfig
+import warnings
 import weakref
 
 import numpy as np
-import warnings
 from numpy.linalg import norm
 from numpy.testing import (verbose, assert_,
                            assert_array_equal, assert_equal,
@@ -632,6 +632,7 @@ class TestCdist:
                     assert_allclose(y1, y2, rtol=eps, verbose=verbose > 2)
 
     @pytest.mark.thread_unsafe
+    @pytest.mark.skipif(sysconfig.get_platform() == 'win-arm64', reason="numpy#29442")
     def test_cdist_out(self, metric):
         # Test that out parameter works properly
         eps = 1e-15