scipy 1.16.0__cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl → 1.16.2__cp312-cp312-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-kgwue17m/lib/python3.12/site-packages/pythran"
+                "include directory": r"../../tmp/build-env-23kf95ry/lib/python3.12/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.12.11/lib/python3.12/site-packages/scipy_openblas32/include",
                 "lib directory": r"/opt/_internal/cpython-3.12.11/lib/python3.12/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.12.11/lib/python3.12/site-packages/scipy_openblas32/include",
                 "lib directory": r"/opt/_internal/cpython-3.12.11/lib/python3.12/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": "2.13.6",
+                "version": "3.0.1",
                 "detection method": "config-tool",
                 "include directory": r"unknown",
             },
         },
         "Python Information": {
-            "path": r"/tmp/build-env-kgwue17m/bin/python",
+            "path": r"/tmp/build-env-23kf95ry/bin/python",
             "version": "3.12",
         },
     }

scipy/_lib/_util.py

@@ -351,6 +351,13 @@ def _transition_to_rng(old_name, *, position_num=None, end_version=None,
 
             return fun(*args, **kwargs)
 
+        # Add the old parameter name to the function signature
+        wrapped_signature = inspect.signature(fun)
+        wrapper.__signature__ = wrapped_signature.replace(parameters=[
+            *wrapped_signature.parameters.values(),
+            inspect.Parameter(old_name, inspect.Parameter.KEYWORD_ONLY, default=None),
+        ])
+
         if replace_doc:
             doc = FunctionDoc(wrapper)
             parameter_names = [param.name for param in doc['Parameters']]

scipy/io/matlab/tests/test_streams.py

@@ -2,7 +2,9 @@
 
 """
 
+import platform
 import os
+import sys
 import zlib
 
 from io import BytesIO
@@ -15,6 +17,7 @@ import numpy as np
 
 from numpy.testing import assert_, assert_equal
 from pytest import raises as assert_raises
+import pytest
 
 from scipy.io.matlab._streams import (make_stream,
     GenericStream, ZlibInputStream,
@@ -194,6 +197,9 @@ class TestZlibInputStream:
         stream.seek(1024)
         assert_(stream.all_data_read())
 
+    @pytest.mark.skipif(
+            (platform.system() == 'Windows' and sys.version_info >= (3, 14)),
+            reason='gh-23185')
     def test_all_data_read_overlap(self):
         COMPRESSION_LEVEL = 6
 
@@ -210,6 +216,9 @@ class TestZlibInputStream:
         stream.seek(len(data))
         assert_(stream.all_data_read())
 
+    @pytest.mark.skipif(
+            (platform.system() == 'Windows' and sys.version_info >= (3, 14)),
+            reason='gh-23185')
     def test_all_data_read_bad_checksum(self):
         COMPRESSION_LEVEL = 6
 

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/linalg/tests/test_matfuncs.py

@@ -460,6 +460,13 @@ class TestSqrtM:
         np.fill_diagonal(M, 1)
         assert np.isrealobj(sqrtm(M))
 
+    def test_gh23278(self):
+        M = np.array([[1., 0., 0.], [0, 1, -1j], [0, 1j, 2]])
+        sq = sqrtm(M)
+        assert_allclose(sq @ sq, M, atol=1e-14)
+        sq = sqrtm(M.astype(np.complex64))
+        assert_allclose(sq @ sq, M, atol=1e-6)
+
     def test_data_size_preservation_uint_in_float_out(self):
         M = np.eye(10, dtype=np.uint8)
         assert sqrtm(M).dtype == np.float64

scipy/ndimage/_filters.py

@@ -232,7 +232,9 @@ def vectorized_filter(input, function, *, size=None, footprint=None, output=None
         We adjust `size` to the number of dimensions indicated by `axes`.
         For instance, if `axes` is ``(0, 2, 1)`` and ``n`` is passed for ``size``,
         then the effective `size` is ``(n, n, n)``.
-    %(output)s
+    output : array, optional
+        The array in which to place the output. By default, an array of the dtype
+        returned by `function` will be created.
     mode : {'reflect', 'constant', 'nearest', 'mirror', 'wrap'}, optional
         The `mode` parameter determines how the input array is extended
         beyond its boundaries. Default is 'reflect'. Behavior for each valid
@@ -1987,7 +1989,14 @@ def _rank_filter(input, rank, size=None, footprint=None, output=None,
                 "A sequence of modes is not supported by non-separable rank "
                 "filters")
         mode = _ni_support._extend_mode_to_code(mode, is_filter=True)
-        if input.ndim == 1:
+        # Some corner cases are currently not allowed to use the
+        # "new"/fast 1D rank filter code, including when the
+        # footprint is large compared to the array size.
+        # See discussion in gh-23293; longer-term it may be possible
+        # to allow the fast path for these corner cases as well,
+        # if algorithmic fixes are found.
+        lim2 = input.size - ((footprint.size - 1) // 2 - origin)
+        if input.ndim == 1 and ((lim2 >= 0) or (input.size == 1)):
             if input.dtype in (np.int64, np.float64, np.float32):
                 x = input
                 x_out = output

scipy/ndimage/tests/test_filters.py

@@ -3029,3 +3029,55 @@ class TestVectorizedFilter:
 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)
+
+
+@pytest.mark.parametrize('samples, mode, size, expected', [
+    ([1, 2], "reflect", 5, [2, 1]),
+    ([2], "reflect", 5, [2]), # original failure from gh-23075
+    ([2], "nearest", 5, [2]),
+    ([2], "wrap", 5, [2]),
+    ([2], "mirror", 5, [2]),
+    ([2], "constant", 5, [0]),
+    ([2], "reflect", 1, [2]),
+    ([2], "nearest", 1, [2]),
+    ([2], "wrap", 1, [2]),
+    ([2], "mirror", 1, [2]),
+    ([2], "constant", 1, [2]),
+    ([2], "reflect", 100, [2]),
+    ([2], "nearest", 100, [2]),
+    ([2], "wrap", 100, [2]),
+    ([2], "mirror", 100, [2]),
+    ([2], "constant", 100, [0]),
+])
+def test_gh_23075(samples, mode, size, expected):
+    # results verified against SciPy 1.14.1, before the median_filter
+    # overhaul
+    sample_array = np.asarray(samples, dtype=np.float32)
+    expected = np.asarray(expected, dtype=np.float32)
+    filtered_samples = ndimage.median_filter(sample_array, size=size, mode=mode)
+    xp_assert_close(filtered_samples, expected, check_shape=True, check_dtype=True)
+
+
+@pytest.mark.parametrize('samples, size, cval, expected', [
+    ([2], 5, 17.7, [17.7]),
+    ([2], 1, 0, [2]),
+    ([2], 100, 1.4, [1.4]),
+    ([9], 137, -7807.7, [-7807.7]),
+])
+def test_gh_23075_constant(samples, size, cval, expected):
+    # results verified against SciPy 1.14.1, before the median_filter
+    # overhaul
+    sample_array = np.asarray(samples, dtype=np.single)
+    expected = np.asarray(expected, dtype=np.single)
+    filtered_samples = ndimage.median_filter(sample_array,
+                                             size=size,
+                                             mode="constant",
+                                             cval=cval)
+    xp_assert_close(filtered_samples, expected, check_shape=True, check_dtype=True)
+
+
+def test_median_filter_lim2():
+    sample_array = np.ones(8)
+    expected = np.ones(8)
+    filtered_samples = ndimage.median_filter(sample_array, size=19, mode="reflect")
+    xp_assert_close(filtered_samples, expected, check_shape=True, check_dtype=True)

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/_lsq/least_squares.py

@@ -17,7 +17,7 @@ from .trf import trf
 from .dogbox import dogbox
 from .common import EPS, in_bounds, make_strictly_feasible
 
-    
+
 from scipy.optimize._optimize import _wrap_callback
 
 TERMINATION_MESSAGES = {
@@ -392,7 +392,7 @@ def least_squares(
 
         * For 'trf'    : ``x_scale == 1``
         * For 'dogbox' : ``x_scale == 1``
-        * For 'jac'    : ``x_scale == 'jac'``
+        * For 'lm'     : ``x_scale == 'jac'``
 
         .. versionchanged:: 1.16.0
             The default keyword value is changed from 1 to None to indicate that

scipy/optimize/_minimize.py

@@ -188,7 +188,6 @@ def minimize(fun, x0, args=(), method=None, jac=None, hess=None,
 
         Equality constraint means that the constraint function result is to
         be zero whereas inequality means that it is to be non-negative.
-        Note that COBYLA only supports inequality constraints.
 
     tol : float, optional
         Tolerance for termination. When `tol` is specified, the selected

scipy/optimize/_shgo_lib/_complex.py

@@ -183,6 +183,7 @@ class Complex:
             self.V = VertexCacheIndex()
 
         self.V_non_symm = []  # List of non-symmetric vertices
+        self.split_edge = cache(self._split_edge)
 
     def __call__(self):
         return self.H
@@ -995,8 +996,7 @@ class Complex:
                 d_v0v1.connect(d_v1v2)
         return
 
-    @cache
-    def split_edge(self, v1, v2):
+    def _split_edge(self, v1, v2):
         v1 = self.V[v1]
         v2 = self.V[v2]
         # Destroy original edge, if it exists:

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/_filter_design.py

@@ -60,6 +60,17 @@ def _is_int_type(x):
         return True
 
 
+def _real_dtype_for_complex(dtyp, *, xp):
+    if xp.isdtype(dtyp, 'real floating'):
+        return dtyp
+    if dtyp == xp.complex64:
+        return xp.float32
+    elif dtyp == xp.complex128:
+        return xp.float64
+    else:
+        raise ValueError(f"Unknown dtype {dtyp}.")
+
+
 # https://github.com/numpy/numpy/blob/v2.2.0/numpy/_core/function_base.py#L195-L302
 def _logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None, *, xp):
     if not isinstance(base, float | int) and xp.asarray(base).ndim > 0:
@@ -488,6 +499,7 @@ def freqz(b, a=1, worN=512, whole=False, plot=None, fs=2*pi,
     if xp.isdtype(a.dtype, 'integral'):
         a = xp.astype(a, xp_default_dtype(xp))
     res_dtype = xp.result_type(b, a)
+    real_dtype = _real_dtype_for_complex(res_dtype, xp=xp)
 
     b = xpx.atleast_nd(b, ndim=1, xp=xp)
     a = xpx.atleast_nd(a, ndim=1, xp=xp)
@@ -509,7 +521,7 @@ def freqz(b, a=1, worN=512, whole=False, plot=None, fs=2*pi,
         # if include_nyquist is true and whole is false, w should
         # include end point
         w = xp.linspace(0, lastpoint, N,
-                        endpoint=include_nyquist and not whole, dtype=res_dtype)
+                        endpoint=include_nyquist and not whole, dtype=real_dtype)
         n_fft = N if whole else 2 * (N - 1) if include_nyquist else 2 * N
         if (xp_size(a) == 1 and (b.ndim == 1 or (b.shape[-1] == 1))
                 and n_fft >= b.shape[0]

scipy/signal/_fir_filter_design.py

@@ -834,7 +834,7 @@ def remez(numtaps, bands, desired, *, weight=None, type='bandpass',
     xp = array_namespace(bands, desired, weight)
     bands = np.asarray(bands)
     desired = np.asarray(desired)
-    if weight:
+    if weight is not None:
         weight = np.asarray(weight)
 
     fs = _validate_fs(fs, allow_none=True)

scipy/signal/_polyutils.py

@@ -117,7 +117,7 @@ def poly(seq_of_zeros, *, xp):
     if xp.isdtype(a.dtype, 'complex floating'):
         # if complex roots are all complex conjugates, the roots are real.
         roots = xp.asarray(seq_of_zeros, dtype=xp.complex128)
-        if xp.all(_sort_cmplx(roots, xp) == _sort_cmplx(xp.conj(roots), xp)):
+        if xp.all(xp.sort(xp.imag(roots)) == xp.sort(xp.imag(xp.conj(roots)))):
             a = xp.asarray(xp.real(a), copy=True)
 
     return a