scipy 1.15.2__cp310-cp310-win_amd64.whl → 1.15.3__cp310-cp310-win_amd64.whl

scipy/__config__.py

@@ -59,7 +59,7 @@ CONFIG = _cleanup(
             },
             "pythran": {
                 "version": r"0.17.0",
-                "include directory": r"C:\Users\runneradmin\AppData\Local\Temp\pip-build-env-k1sc59yc\overlay\Lib\site-packages/pythran"
+                "include directory": r"C:\Users\runneradmin\AppData\Local\Temp\pip-build-env-1iowlesx\overlay\Lib\site-packages/pythran"
             },
         },
         "Machine Information": {
@@ -83,8 +83,8 @@ CONFIG = _cleanup(
                 "found": bool("True".lower().replace('false', '')),
                 "version": "0.3.28",
                 "detection method": "pkgconfig",
-                "include directory": r"C:/Users/runneradmin/AppData/Local/Temp/cibw-run-8da2dz2z/cp310-win_amd64/build/venv/Lib/site-packages/scipy_openblas32/include",
-                "lib directory": r"C:/Users/runneradmin/AppData/Local/Temp/cibw-run-8da2dz2z/cp310-win_amd64/build/venv/Lib/site-packages/scipy_openblas32/lib",
+                "include directory": r"C:/Users/runneradmin/AppData/Local/Temp/cibw-run-6w_ufqtf/cp310-win_amd64/build/venv/Lib/site-packages/scipy_openblas32/include",
+                "lib directory": r"C:/Users/runneradmin/AppData/Local/Temp/cibw-run-6w_ufqtf/cp310-win_amd64/build/venv/Lib/site-packages/scipy_openblas32/lib",
                 "openblas configuration": r"OpenBLAS 0.3.28 DYNAMIC_ARCH NO_AFFINITY Haswell MAX_THREADS=24",
                 "pc file directory": r"D:/a/scipy/scipy",
             },
@@ -93,8 +93,8 @@ CONFIG = _cleanup(
                 "found": bool("True".lower().replace('false', '')),
                 "version": "0.3.28",
                 "detection method": "pkgconfig",
-                "include directory": r"C:/Users/runneradmin/AppData/Local/Temp/cibw-run-8da2dz2z/cp310-win_amd64/build/venv/Lib/site-packages/scipy_openblas32/include",
-                "lib directory": r"C:/Users/runneradmin/AppData/Local/Temp/cibw-run-8da2dz2z/cp310-win_amd64/build/venv/Lib/site-packages/scipy_openblas32/lib",
+                "include directory": r"C:/Users/runneradmin/AppData/Local/Temp/cibw-run-6w_ufqtf/cp310-win_amd64/build/venv/Lib/site-packages/scipy_openblas32/include",
+                "lib directory": r"C:/Users/runneradmin/AppData/Local/Temp/cibw-run-6w_ufqtf/cp310-win_amd64/build/venv/Lib/site-packages/scipy_openblas32/lib",
                 "openblas configuration": r"OpenBLAS 0.3.28 DYNAMIC_ARCH NO_AFFINITY Haswell MAX_THREADS=24",
                 "pc file directory": r"D:/a/scipy/scipy",
             },
@@ -106,7 +106,7 @@ CONFIG = _cleanup(
             },
         },
         "Python Information": {
-            "path": r"C:\Users\runneradmin\AppData\Local\Temp\cibw-run-8da2dz2z\cp310-win_amd64\build\venv\Scripts\python.exe",
+            "path": r"C:\Users\runneradmin\AppData\Local\Temp\cibw-run-6w_ufqtf\cp310-win_amd64\build\venv\Scripts\python.exe",
             "version": "3.10",
         },
     }

scipy/__init__.py

@@ -44,14 +44,14 @@ Public API in the main SciPy namespace
 
 
 # start delvewheel patch
-def _delvewheel_patch_1_10_0():
+def _delvewheel_patch_1_10_1():
     import os
     if os.path.isdir(libs_dir := os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'scipy.libs'))):
         os.add_dll_directory(libs_dir)
 
 
-_delvewheel_patch_1_10_0()
-del _delvewheel_patch_1_10_0
+_delvewheel_patch_1_10_1()
+del _delvewheel_patch_1_10_1
 # end delvewheel patch
 
 import importlib as _importlib

scipy/_lib/_array_api.py

@@ -593,3 +593,14 @@ def xp_float_to_complex(arr: Array, xp: ModuleType | None = None) -> Array:
         arr = xp.astype(arr, xp.complex128)
 
     return arr
+
+
+def xp_default_dtype(xp):
+    """Query the namespace-dependent default floating-point dtype.
+    """
+    if is_torch(xp):
+        # historically, we allow pytorch to keep its default of float32
+        return xp.get_default_dtype()
+    else:
+        # we default to float64
+        return xp.float64

scipy/_lib/tests/test_array_api.py

@@ -4,7 +4,7 @@ import pytest
 from scipy.conftest import array_api_compatible
 from scipy._lib._array_api import (
     _GLOBAL_CONFIG, array_namespace, _asarray, xp_copy, xp_assert_equal, is_numpy,
-    np_compat,
+    np_compat, xp_default_dtype
 )
 from scipy._lib._array_api_no_0d import xp_assert_equal as xp_assert_equal_no_0d
 
@@ -185,3 +185,7 @@ class TestArrayAPI:
         # scalars-vs-0d passes (if values match) also with regular python objects
         xp_assert_equal_no_0d(0., xp.asarray(0.))
         xp_assert_equal_no_0d(42, xp.asarray(42))
+
+    @array_api_compatible
+    def test_default_dtype(self, xp):
+        assert xp_default_dtype(xp) == xp.asarray(1.).dtype

scipy/integrate/_ivp/common.py

@@ -65,7 +65,7 @@ def norm(x):
     return np.linalg.norm(x) / x.size ** 0.5
 
 
-def select_initial_step(fun, t0, y0, t_bound, 
+def select_initial_step(fun, t0, y0, t_bound,
                         max_step, f0, direction, order, rtol, atol):
     """Empirically select a good initial step.
 
@@ -80,7 +80,7 @@ def select_initial_step(fun, t0, y0, t_bound,
     y0 : ndarray, shape (n,)
         Initial value of the dependent variable.
     t_bound : float
-        End-point of integration interval; used to ensure that t0+step<=tbound 
+        End-point of integration interval; used to ensure that t0+step<=tbound
         and that fun is only evaluated in the interval [t0,tbound]
     max_step : float
         Maximum allowable step size.
@@ -112,7 +112,7 @@ def select_initial_step(fun, t0, y0, t_bound,
     interval_length = abs(t_bound - t0)
     if interval_length == 0.0:
         return 0.0
-    
+
     scale = atol + np.abs(y0) * rtol
     d0 = norm(y0 / scale)
     d1 = norm(f0 / scale)

scipy/integrate/_ivp/ivp.py

@@ -694,8 +694,15 @@ def solve_ivp(fun, t_span, y0, method='RK45', t_eval=None, dense_output=False,
             g = g_new
 
         if t_eval is None:
-            ts.append(t)
-            ys.append(y)
+            donot_append = (len(ts) > 1 and
+                            ts[-1] == t and
+                            dense_output)
+            if not donot_append:
+                ts.append(t)
+                ys.append(y)
+            else:
+                if len(interpolants) > 0:
+                    interpolants.pop()
         else:
             # The value in t_eval equal to t will be included.
             if solver.direction > 0:

scipy/integrate/_ivp/tests/test_ivp.py

@@ -151,6 +151,25 @@ def compute_error(y, y_true, rtol, atol):
     e = (y - y_true) / (atol + rtol * np.abs(y_true))
     return np.linalg.norm(e, axis=0) / np.sqrt(e.shape[0])
 
+def test_duplicate_timestamps():
+    def upward_cannon(t, y):
+        return [y[1], -9.80665]
+
+    def hit_ground(t, y):
+        return y[0]
+
+    hit_ground.terminal = True
+    hit_ground.direction = -1
+
+    sol = solve_ivp(upward_cannon, [0, np.inf], [0, 0.01],
+                    max_step=0.05 * 0.001 / 9.80665,
+                    events=hit_ground, dense_output=True)
+    assert_allclose(sol.sol(0.01), np.asarray([-0.00039033, -0.08806632]),
+                    rtol=1e-5, atol=1e-8)
+    assert_allclose(sol.t_events, np.asarray([[0.00203943]]), rtol=1e-5, atol=1e-8)
+    assert_allclose(sol.y_events, [np.asarray([[ 0.0, -0.01 ]])], atol=1e-9)
+    assert sol.success
+    assert_equal(sol.status, 1)
 
 @pytest.mark.thread_unsafe
 def test_integration():

scipy/integrate/_tanhsinh.py

@@ -98,8 +98,9 @@ def tanhsinh(f, a, b, *, args=(), log=False, maxlevel=None, minlevel=2,
         Absolute termination tolerance (default: 0) and relative termination
         tolerance (default: ``eps**0.75``, where ``eps`` is the precision of
         the result dtype), respectively.  Iteration will stop when
-        ``res.error < atol + rtol * abs(res.df)``. The error estimate is as
-        described in [1]_ Section 5. While not theoretically rigorous or
+        ``res.error < atol`` or  ``res.error < res.integral * rtol``. The error
+        estimate is as described in [1]_ Section 5 but with a lower bound of
+        ``eps * res.integral``. While not theoretically rigorous or
         conservative, it is said to work well in practice. Must be non-negative
         and finite if `log` is False, and must be expressed as the log of a
         non-negative and finite number if `log` is True.
@@ -445,9 +446,9 @@ def tanhsinh(f, a, b, *, args=(), log=False, maxlevel=None, minlevel=2,
             stop[i] = True
         else:
             # Terminate if convergence criterion is met
-            work.rerr, work.aerr = _estimate_error(work, xp)
-            i = ((work.rerr < rtol) | (work.rerr + xp_real(work.Sn) < atol) if log
-                 else (work.rerr < rtol) | (work.rerr * xp.abs(work.Sn) < atol))
+            rerr, aerr = _estimate_error(work, xp)
+            i = (rerr < rtol) | (aerr < atol)
+            work.aerr =  xp.reshape(xp.astype(aerr, work.dtype), work.Sn.shape)
             work.status[i] = eim._ECONVERGED
             stop[i] = True
 
@@ -772,22 +773,23 @@ def _estimate_error(work, xp):
         d2 = xp_real(special.logsumexp(xp.stack([work.Sn, Snm2 + work.pi*1j]), axis=0))
         d3 = log_e1 + xp.max(xp_real(work.fjwj), axis=-1)
         d4 = work.d4
-        ds = xp.stack([d1 ** 2 / d2, 2 * d1, d3, d4])
+        d5 = log_e1 + xp.real(work.Sn)
+        temp = xp.where(d1 > -xp.inf, d1 ** 2 / d2, -xp.inf)
+        ds = xp.stack([temp, 2 * d1, d3, d4, d5])
         aerr = xp.max(ds, axis=0)
-        rerr = xp.maximum(log_e1, aerr - xp_real(work.Sn))
+        rerr = aerr - xp.real(work.Sn)
     else:
         # Note: explicit computation of log10 of each of these is unnecessary.
         d1 = xp.abs(work.Sn - Snm1)
         d2 = xp.abs(work.Sn - Snm2)
         d3 = e1 * xp.max(xp.abs(work.fjwj), axis=-1)
         d4 = work.d4
-        # If `d1` is 0, no need to warn. This does the right thing.
-        # with np.errstate(divide='ignore'):
-        ds = xp.stack([d1**(xp.log(d1)/xp.log(d2)), d1**2, d3, d4])
+        d5 = e1 * xp.abs(work.Sn)
+        temp = xp.where(d1 > 0, d1**(xp.log(d1)/xp.log(d2)), 0)
+        ds = xp.stack([temp, d1**2, d3, d4, d5])
         aerr = xp.max(ds, axis=0)
-        rerr = xp.maximum(e1, aerr/xp.abs(work.Sn))
+        rerr = aerr/xp.abs(work.Sn)
 
-    aerr = xp.reshape(xp.astype(aerr, work.dtype), work.Sn.shape)
     return rerr, aerr
 
 

scipy/integrate/tests/test_tanhsinh.py

@@ -753,6 +753,16 @@ class TestTanhSinh:
         x[-1] = 1000
         _tanhsinh(np.sin, 1, x)
 
+    def test_gh_22681_finite_error(self, xp):
+        # gh-22681 noted a case in which the error was NaN on some platforms;
+        # check that this does in fact fail in CI.
+        a = complex(12, -10)
+        b = complex(12, 39)
+        def f(t):
+            return xp.sin(a * (1 - t) + b * t)
+        res = _tanhsinh(f, xp.asarray(0.), xp.asarray(1.), atol=0, rtol=0, maxlevel=10)
+        assert xp.isfinite(res.error)
+
 
 @array_api_compatible
 @pytest.mark.usefixtures("skip_xp_backends")

scipy/linalg/tests/test_interpolative.py

@@ -213,3 +213,20 @@ class TestInterpolativeDecomposition:
         B = A.copy()
         interp_decomp(A.T, eps, rand=rand)
         assert_array_equal(A, B)
+
+    def test_svd_aslinearoperator_shape_check(self):
+        # See gh-issue #22451
+        rng = np.random.default_rng(1744580941832515)
+        x = rng.uniform(size=[7, 5])
+        xl = aslinearoperator(x)
+        u, s, v = pymatrixid.svd(xl, 3)
+        assert_equal(u.shape, (7, 3))
+        assert_equal(s.shape, (3,))
+        assert_equal(v.shape, (5, 3))
+
+        x = rng.uniform(size=[4, 9])
+        xl = aslinearoperator(x)
+        u, s, v = pymatrixid.svd(xl, 2)
+        assert_equal(u.shape, (4, 2))
+        assert_equal(s.shape, (2,))
+        assert_equal(v.shape, (9, 2))

scipy/ndimage/_ndimage_api.py

@@ -12,4 +12,5 @@ from ._interpolation import *   # noqa: F403
 from ._measurements import *   # noqa: F403
 from ._morphology import *   # noqa: F403
 
-__all__ = [s for s in dir() if not s.startswith('_')]
+# '@' due to pytest bug, scipy/scipy#22236
+__all__ = [s for s in dir() if not s.startswith(('_', '@'))]

scipy/ndimage/tests/test_filters.py

@@ -6,6 +6,9 @@ import re
 import numpy as np
 import pytest
 from numpy.testing import suppress_warnings, assert_allclose, assert_array_equal
+from hypothesis import strategies as st
+from hypothesis import given
+import hypothesis.extra.numpy as npst
 from pytest import raises as assert_raises
 from scipy import ndimage
 from scipy._lib._array_api import (
@@ -2904,3 +2907,14 @@ def test_gh_22333():
     expected = [58, 67, 87, 108, 163, 108, 108, 108, 87]
     actual = ndimage.median_filter(x, size=9, mode='constant')
     assert_array_equal(actual, expected)
+
+
+@given(x=npst.arrays(dtype=np.float64,
+                     shape=st.integers(min_value=1, max_value=1000)),
+       size=st.integers(min_value=1, max_value=50),
+       mode=st.sampled_from(["constant", "mirror", "wrap", "reflect",
+                             "nearest"]),
+      )
+def test_gh_22586_crash_property(x, size, mode):
+    # property-based test for median_filter resilience to hard crashing
+    ndimage.median_filter(x, size=size, mode=mode)