scipy 1.15.3__cp313-cp313-win_amd64.whl → 1.16.0rc2__cp313-cp313-win_amd64.whl

scipy/optimize/tests/test_optimize.py

@@ -7,6 +7,7 @@ Authors:
 
 """
 import itertools
+import inspect
 import platform
 import threading
 import numpy as np
@@ -33,10 +34,11 @@ from scipy.optimize import rosen, rosen_der, rosen_hess
 
 from scipy.sparse import (coo_matrix, csc_matrix, csr_matrix, coo_array,
                           csr_array, csc_array)
-from scipy.conftest import array_api_compatible
-from scipy._lib._array_api_no_0d import xp_assert_equal, array_namespace
+from scipy._lib._array_api_no_0d import xp_assert_equal
+from scipy._lib._array_api import make_xp_test_case
+from scipy._lib._util import MapWrapper
 
-skip_xp_backends = pytest.mark.skip_xp_backends
+lazy_xp_modules = [optimize]
 
 
 def test_check_grad():
@@ -1318,6 +1320,8 @@ class TestOptimizeSimple(CheckOptimize):
 
             if method == 'tnc':
                 kwargs['options'] = dict(maxfun=100)
+            elif method == 'cobyla':
+                kwargs['options'] = dict(maxiter=100)
             else:
                 kwargs['options'] = dict(maxiter=5)
 
@@ -1552,7 +1556,7 @@ class TestOptimizeSimple(CheckOptimize):
 
     @pytest.mark.parametrize('method', ['nelder-mead', 'powell', 'cg', 'bfgs',
                                         'newton-cg', 'l-bfgs-b', 'tnc',
-                                        'cobyla', 'cobyqa', 'slsqp',
+                                        'cobyqa', 'slsqp',
                                         'trust-constr', 'dogleg', 'trust-ncg',
                                         'trust-exact', 'trust-krylov'])
     def test_nan_values(self, method, num_parallel_threads):
@@ -1683,6 +1687,23 @@ class TestOptimizeSimple(CheckOptimize):
         if method == 'cobyqa':
             ref = optimize.minimize(**kwargs, options={'maxfev': maxiter})
             assert res.nfev == ref.nfev == maxiter
+        elif method == 'cobyla':
+            # COBYLA calls the callback once per iteration, not once per function
+            # evaluation, so this test is not applicable. However we can test
+            # the COBYLA status to verify that res stopped back on the callback
+            # and ref stopped based on the iteration limit.
+            # COBYLA requires at least n+2 function evaluations
+            maxiter = max(maxiter, len(kwargs['x0'])+2)
+            ref = optimize.minimize(**kwargs, options={'maxiter': maxiter})
+            assert res.status == 30
+            assert res.message == ("Return from COBYLA because the callback function "
+                                   "requested termination")
+            assert ref.status == 3
+            assert ref.message == ("Return from COBYLA because the objective function "
+                                   "has been evaluated MAXFUN times.")
+            # Return early because res/ref will be unequal for COBYLA for the reasons
+            # mentioned above.
+            return
         else:
             ref = optimize.minimize(**kwargs, options={'maxiter': maxiter})
             assert res.nit == ref.nit == maxiter
@@ -2453,33 +2474,29 @@ def test_powell_output():
         assert np.isscalar(res.fun)
 
 
-@array_api_compatible
 class TestRosen:
+    @make_xp_test_case(optimize.rosen)
     def test_rosen(self, xp):
         # integer input should be promoted to the default floating type
         x = xp.asarray([1, 1, 1])
         xp_assert_equal(optimize.rosen(x),
                         xp.asarray(0.))
 
-    @skip_xp_backends('jax.numpy',
-                      reasons=["JAX arrays do not support item assignment"])
-    @pytest.mark.usefixtures("skip_xp_backends")
+    @make_xp_test_case(optimize.rosen_der)
     def test_rosen_der(self, xp):
         x = xp.asarray([1, 1, 1, 1])
         xp_assert_equal(optimize.rosen_der(x),
                         xp.zeros_like(x, dtype=xp.asarray(1.).dtype))
 
-    @skip_xp_backends('jax.numpy',
-                      reasons=["JAX arrays do not support item assignment"])
-    @pytest.mark.usefixtures("skip_xp_backends")
+    @make_xp_test_case(optimize.rosen_hess, optimize.rosen_hess_prod)
     def test_hess_prod(self, xp):
         one = xp.asarray(1.)
-        xp_test = array_namespace(one)
+
         # Compare rosen_hess(x) times p with rosen_hess_prod(x,p). See gh-1775.
         x = xp.asarray([3, 4, 5])
         p = xp.asarray([2, 2, 2])
         hp = optimize.rosen_hess_prod(x, p)
-        p = xp_test.astype(p, one.dtype)
+        p = xp.astype(p, one.dtype)
         dothp = optimize.rosen_hess(x) @ p
         xp_assert_equal(hp, dothp)
 
@@ -2907,6 +2924,10 @@ def setup_test_equal_bounds():
     def callback(x, *args):
         check_x(x)
 
+    def callback2(intermediate_result):
+        assert isinstance(intermediate_result, OptimizeResult)
+        check_x(intermediate_result.x)
+
     def constraint1(x):
         check_x(x, check_values=False)
         return x[0:1] - 1
@@ -2957,7 +2978,7 @@ def setup_test_equal_bounds():
                    ([c1b, c2b], [c1b, c2b]))
 
     # test with and without callback function
-    callbacks = (None, callback)
+    callbacks = (None, callback, callback2)
 
     data = {"methods": methods, "kwds": kwds, "bound_types": bound_types,
             "constraints": constraints, "callbacks": callbacks,
@@ -2996,6 +3017,12 @@ def test_equal_bounds(method, kwds, bound_type, constraints, callback):
     test_constraints, reference_constraints = constraints
     if test_constraints and not method == 'SLSQP':
         pytest.skip('Only SLSQP supports nonlinear constraints')
+
+    if method in ['SLSQP', 'TNC'] and callable(callback):
+        sig = inspect.signature(callback)
+        if 'intermediate_result' in set(sig.parameters):
+            pytest.skip("SLSQP, TNC don't support intermediate_result")
+
     # reference constraints always have analytical jacobian
     # if test constraints are not the same, we'll need finite differences
     fd_needed = (test_constraints != reference_constraints)
@@ -3012,7 +3039,7 @@ def test_equal_bounds(method, kwds, bound_type, constraints, callback):
 
     # compare the output of a solution with FD vs that of an analytic grad
     assert res.success
-    assert_allclose(res.fun, expected.fun, rtol=1.5e-6)
+    assert_allclose(res.fun, expected.fun, rtol=2e-6)
     assert_allclose(res.x, expected.x, rtol=5e-4)
 
     if fd_needed or kwds['jac'] is False:
@@ -3236,8 +3263,8 @@ def test_gh12594():
                                          coo_array, csr_array, csc_array])
 def test_sparse_hessian(method, sparse_type):
     # gh-8792 reported an error for minimization with `newton_cg` when `hess`
-    # returns a sparse matrix. Check that results are the same whether `hess`
-    # returns a dense or sparse matrix for optimization methods that accept
+    # returns a sparse array. Check that results are the same whether `hess`
+    # returns a dense or sparse array for optimization methods that accept
     # sparse Hessian matrices.
 
     def sparse_rosen_hess(x):
@@ -3255,3 +3282,54 @@ def test_sparse_hessian(method, sparse_type):
     assert res_dense.nfev == res_sparse.nfev
     assert res_dense.njev == res_sparse.njev
     assert res_dense.nhev == res_sparse.nhev
+
+
+@pytest.mark.parametrize('workers', [None, 2])
+@pytest.mark.parametrize(
+    'method',
+    ['l-bfgs-b',
+     'bfgs',
+     'slsqp',
+     'trust-constr',
+     'Newton-CG',
+     'CG',
+     'tnc',
+     'trust-ncg',
+     'trust-krylov'])
+class TestWorkers:
+
+    def setup_method(self):
+        self.x0 = np.array([1.0, 2.0, 3.0])
+
+    def test_smoke(self, workers, method):
+        # checks parallelised optimization output is same as serial
+        workers = workers or map
+
+        kwds = {'jac': None, 'hess': None}
+        if method in ['Newton-CG', 'trust-ncg', 'trust-krylov']:
+            #  methods that require a callable jac
+            kwds['jac'] = rosen_der
+            kwds['hess'] = '2-point'
+
+        with MapWrapper(workers) as mf:
+            res = optimize.minimize(
+                rosen, self.x0, options={"workers":mf}, method=method, **kwds
+            )
+        res_default = optimize.minimize(
+            rosen, self.x0, method=method, **kwds
+        )
+        assert_equal(res.x, res_default.x)
+        assert_equal(res.nfev, res_default.nfev)
+
+    def test_equal_bounds(self, workers, method):
+        workers = workers or map
+        if method not in ['l-bfgs-b', 'slsqp', 'trust-constr', 'tnc']:
+            pytest.skip(f"{method} cannot use bounds")
+
+        bounds = Bounds([0, 2.0, 0.], [10., 2.0, 10.])
+        with MapWrapper(workers) as mf:
+            res = optimize.minimize(
+                rosen, self.x0, bounds=bounds, options={"workers": mf}, method=method
+            )
+        assert res.success
+        assert_allclose(res.x[1], 2.0)

scipy/optimize/tests/test_slsqp.py

@@ -592,7 +592,6 @@ class TestSLSQP:
         # The problem is infeasible, so it cannot succeed
         assert not res.success
 
-    @pytest.mark.thread_unsafe
     def test_parameters_stay_within_bounds(self):
         # gh11403. For some problems the SLSQP Fortran code suggests a step
         # outside one of the lower/upper bounds. When this happens
@@ -607,7 +606,40 @@ class TestSLSQP:
         def f(x):
             assert (x >= bounds.lb).all()
             return np.linalg.norm(x)
+        # The following should not raise any warnings which was the case, with the
+        # old Fortran code.
+        res = minimize(f, x0, method='SLSQP', bounds=bounds)
+        assert res.success
+
+
+def test_slsqp_segfault_wrong_workspace_computation():
+    # See gh-14915
+    # This problem is not well-defined, however should not cause a segfault.
+    # The previous F77 workspace computation did not handle only equality-
+    # constrained problems correctly.
+    rng = np.random.default_rng(1742651087222879)
+    x = rng.uniform(size=[22,365])
+    target = np.linspace(0.9, 4.0, 50)
+
+    def metric(v, weights):
+        return [[0, 0],[1, 1]]
+
+    def efficient_metric(v, target):
+        def metric_a(weights):
+            return metric(v, weights)[1][0]
+
+        def metric_b(weights, v):
+            return metric(v, weights)[0][0]
+
+        constraints = ({'type': 'eq', 'fun': lambda x: metric_a(x) - target},
+                       {'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
+        weights = np.array([len(v)*[1./len(v)]])[0]
+        result = minimize(metric_b,
+                          weights,
+                          args=(v,),
+                          method='SLSQP',
+                          constraints=constraints)
+        return result
+
+    efficient_metric(x, target)
 
-        with pytest.warns(RuntimeWarning, match='x were outside bounds'):
-            res = minimize(f, x0, method='SLSQP', bounds=bounds)
-            assert res.success

scipy/optimize/tests/test_zeros.py

@@ -225,6 +225,10 @@ class TestBracketMethods(TestScalarRootFinders):
         assert r.converged
         assert_allclose(root, 0)
 
+    def test_gh_22934(self):
+        with pytest.raises(ValueError, match="maxiter must be >= 0"):
+            zeros.brentq(lambda x: x**2 - 1, -2, 0, maxiter=-1)
+
 
 class TestNewton(TestScalarRootFinders):
     def test_newton_collections(self):
@@ -428,7 +432,7 @@ class TestNewton(TestScalarRootFinders):
             if derivs == 1:
                 # Check that the correct Exception is raised and
                 # validate the start of the message.
-                msg = 'Failed to converge after %d iterations, value is .*' % (iters)
+                msg = f'Failed to converge after {iters} iterations, value is .*'
                 with pytest.raises(RuntimeError, match=msg):
                     x, r = zeros.newton(f1, x0, maxiter=iters, disp=True, **kwargs)
 
@@ -508,6 +512,18 @@ class TestNewton(TestScalarRootFinders):
         assert_allclose(abs(res.root), 2**-0.5)
         assert res.root.dtype == np.dtype(np.float64)
 
+    def test_newton_special_parameters(self):
+        # give zeros.newton() some strange parameters
+        # and check whether an exception appears
+        with pytest.raises(ValueError, match="tol too small"):
+            zeros.newton(f1, 3, tol=-1e-6)
+
+        with pytest.raises(ValueError, match="maxiter must be greater than 0"):
+            zeros.newton(f1, 3, tol=1e-6, maxiter=-50)
+
+        with pytest.raises(ValueError, match="x1 and x0 must be different" ):
+            zeros.newton(f1, 3, x1=3)
+
 
 def test_gh_5555():
     root = 0.1
@@ -963,3 +979,20 @@ def test_maxiter_int_check_gh10236(method):
     message = "'float' object cannot be interpreted as an integer"
     with pytest.raises(TypeError, match=message):
         method(f1, 0.0, 1.0, maxiter=72.45)
+
+@pytest.mark.parametrize("method", [zeros.bisect, zeros.ridder,
+                                    zeros.brentq, zeros.brenth])
+def test_bisect_special_parameter(method):
+    # give some zeros method strange parameters
+    # and check whether an exception appears
+    root = 0.1
+    args = (1e-09, 0.004, 10, 0.27456)
+    rtolbad = 4 * np.finfo(float).eps / 2
+
+    def f(x):
+        return x - root
+
+    with pytest.raises(ValueError, match="xtol too small"):
+       method(f, -1e8, 1e7, args=args, xtol=-1e-6, rtol=TOL)
+    with pytest.raises(ValueError, match="rtol too small"):
+       method(f, -1e8, 1e7, args=args, xtol=1e-6, rtol=rtolbad)

scipy/signal/__init__.py

@@ -87,9 +87,12 @@ Filter design
                     -- defined as pass and stop bands.
    firwin2       -- Windowed FIR filter design, with arbitrary frequency
                     -- response.
+   firwin_2d        -- Windowed FIR filter design, with frequency response for 
+                    -- 2D using 1D design.
    freqs         -- Analog filter frequency response from TF coefficients.
    freqs_zpk     -- Analog filter frequency response from ZPK coefficients.
    freqz         -- Digital filter frequency response from TF coefficients.
+   sosfreqz      -- Digital filter frequency response for SOS format filter (legacy).
    freqz_sos     -- Digital filter frequency response for SOS format filter.
    freqz_zpk     -- Digital filter frequency response from ZPK coefficients.
    gammatone     -- FIR and IIR gammatone filter design.
@@ -266,9 +269,11 @@ Spectral analysis
    ShortTimeFFT   -- Interface for calculating the \
                      :ref:`Short Time Fourier Transform <tutorial_stft>` and \
                      its inverse.
+   closest_STFT_dual_window -- Calculate the STFT dual window of a given window \
+                               closest to a desired dual window.
    stft           -- Compute the Short Time Fourier Transform (legacy).
    istft          -- Compute the Inverse Short Time Fourier Transform (legacy).
-   check_COLA     -- Check the COLA constraint for iSTFT reconstruction.
+   check_COLA     -- Check the COLA constraint for iSTFT reconstruction (legacy).
    check_NOLA     -- Check the NOLA constraint for iSTFT reconstruction.
 
 Chirp Z-transform and Zoom FFT
@@ -289,28 +294,15 @@ repeatedly generate the same chirp signal with every call.  In these cases,
 use the classes to create a reusable function instead.
 
 """
+# bring in the public functionality from private namespaces
 
-from . import _sigtools, windows
-from ._waveforms import *
-from ._max_len_seq import max_len_seq
-from ._upfirdn import upfirdn
+# mypy: ignore-errors
 
-from ._spline import (
-    sepfir2d
-)
+from ._support_alternative_backends import *
+from . import _support_alternative_backends
+__all__ = _support_alternative_backends.__all__
+del _support_alternative_backends, _signal_api, _delegators  # noqa: F821
 
-from ._spline_filters import *
-from ._filter_design import *
-from ._fir_filter_design import *
-from ._ltisys import *
-from ._lti_conversion import *
-from ._signaltools import *
-from ._savitzky_golay import savgol_coeffs, savgol_filter
-from ._spectral_py import *
-from ._short_time_fft import *
-from ._peak_finding import *
-from ._czt import *
-from .windows import get_window  # keep this one in signal namespace
 
 # Deprecated namespaces, to be removed in v2.0.0
 from . import (
@@ -318,9 +310,6 @@ from . import (
     spectral, signaltools, waveforms, wavelets, spline
 )
 
-__all__ = [
-    s for s in dir() if not s.startswith("_")
-]
 
 from scipy._lib._testutils import PytestTester
 test = PytestTester(__name__)