scipy 1.15.3__cp311-cp311-win_amd64.whl → 1.16.0rc2__cp311-cp311-win_amd64.whl

scipy/optimize/tests/test_least_squares.py

@@ -1,4 +1,5 @@
 from itertools import product
+from multiprocessing import Pool
 
 import numpy as np
 from numpy.linalg import norm
@@ -6,13 +7,14 @@ from numpy.testing import (assert_, assert_allclose,
                            assert_equal, suppress_warnings)
 import pytest
 from pytest import raises as assert_raises
-from scipy.sparse import issparse, lil_matrix
+from scipy.sparse import issparse, lil_array
 from scipy.sparse.linalg import aslinearoperator
 
 from scipy.optimize import least_squares, Bounds
 from scipy.optimize._lsq.least_squares import IMPLEMENTED_LOSSES
 from scipy.optimize._lsq.common import EPS, make_strictly_feasible, CL_scaling_vector
 
+from scipy.optimize import OptimizeResult
 
 def fun_trivial(x, a=0):
     return (x - a)**2 + 5.0
@@ -34,6 +36,15 @@ def fun_rosenbrock(x):
     return np.array([10 * (x[1] - x[0]**2), (1 - x[0])])
 
 
+class Fun_Rosenbrock:
+    def __init__(self):
+        self.nfev = 0
+
+    def __call__(self, x, a=0):
+        self.nfev += 1
+        return fun_rosenbrock(x)
+
+
 def jac_rosenbrock(x):
     return np.array([
         [-20 * x[0], 10],
@@ -92,7 +103,7 @@ class BroydenTridiagonal:
         self.x0 = make_strictly_feasible(self.x0, self.lb, self.ub)
 
         if mode == 'sparse':
-            self.sparsity = lil_matrix((n, n), dtype=int)
+            self.sparsity = lil_array((n, n), dtype=int)
             i = np.arange(n)
             self.sparsity[i, i] = 1
             i = np.arange(1, n)
@@ -116,7 +127,7 @@ class BroydenTridiagonal:
         return f
 
     def _jac(self, x):
-        J = lil_matrix((self.n, self.n))
+        J = lil_array((self.n, self.n))
         i = np.arange(self.n)
         J[i, i] = 3 - 2 * x
         i = np.arange(1, self.n)
@@ -227,25 +238,17 @@ class BaseMixin:
                       2.0, x_scale='auto', method=self.method)
         assert_raises(ValueError, least_squares, fun_trivial,
                       2.0, x_scale=-1.0, method=self.method)
-        assert_raises(ValueError, least_squares, fun_trivial,
-                      2.0, x_scale=None, method=self.method)
         assert_raises(ValueError, least_squares, fun_trivial,
                       2.0, x_scale=1.0+2.0j, method=self.method)
 
     def test_diff_step(self):
-        # res1 and res2 should be equivalent.
-        # res2 and res3 should be different.
         res1 = least_squares(fun_trivial, 2.0, diff_step=1e-1,
                              method=self.method)
-        res2 = least_squares(fun_trivial, 2.0, diff_step=-1e-1,
-                             method=self.method)
         res3 = least_squares(fun_trivial, 2.0,
                              diff_step=None, method=self.method)
         assert_allclose(res1.x, 0, atol=1e-4)
-        assert_allclose(res2.x, 0, atol=1e-4)
         assert_allclose(res3.x, 0, atol=1e-4)
-        assert_equal(res1.x, res2.x)
-        assert_equal(res1.nfev, res2.nfev)
+
 
     def test_incorrect_options_usage(self):
         assert_raises(TypeError, least_squares, fun_trivial, 2.0,
@@ -265,7 +268,6 @@ class BaseMixin:
         assert_allclose(res.optimality, 0, atol=1e-2)
         assert_equal(res.active_mask, 0)
         if self.method == 'lm':
-            assert_(res.nfev < 30)
             assert_(res.njev is None)
         else:
             assert_(res.nfev < 10)
@@ -293,6 +295,17 @@ class BaseMixin:
         assert_equal(res.status, 0)
         assert_equal(res.success, 0)
 
+    def test_nfev(self):
+        # checks that the true number of nfev are being consumed
+        for i in range(1, 3):
+            rng = np.random.default_rng(128908)
+            x0 = rng.uniform(size=2) * 10
+            ftrivial = Fun_Rosenbrock()
+            res = least_squares(
+               ftrivial, x0, jac=jac_rosenbrock, method=self.method, max_nfev=i
+            )
+            assert res.nfev == ftrivial.nfev
+
     def test_rosenbrock(self):
         x0 = [-2, 1]
         x_opt = [1, 1]
@@ -387,6 +400,27 @@ class BaseMixin:
                                 method=self.method)
             assert_allclose(res.x, x_opt)
 
+    @pytest.mark.fail_slow(5.0)
+    def test_workers(self):
+        serial = least_squares(fun_trivial, 2.0, method=self.method)
+
+        reses = []
+        for workers in [None, 2]:
+            res = least_squares(
+                fun_trivial, 2.0, method=self.method, workers=workers
+            )
+            reses.append(res)
+        with Pool() as workers:
+            res = least_squares(
+                fun_trivial, 2.0, method=self.method, workers=workers.map
+            )
+            reses.append(res)
+        for res in reses:
+            assert res.success
+            assert_equal(res.x, serial.x)
+            assert_equal(res.nfev, serial.nfev)
+            assert_equal(res.njev, serial.njev)
+
 
 class BoundsMixin:
     def test_inconsistent(self):
@@ -779,6 +813,17 @@ class TestLM(BaseMixin):
 
         assert_raises(ValueError, least_squares, fun_trivial, 2.0,
                       method='lm', loss='huber')
+    
+    def test_callback_with_lm_method(self):
+        def callback(x):
+            assert(False)  # Dummy callback function
+        
+        with suppress_warnings() as sup:
+            sup.filter(
+                UserWarning,
+                "Callback function specified, but not supported with `lm` method."
+            )
+            least_squares(fun_trivial, x0=[0], method='lm', callback=callback)
 
 
 def test_basic():
@@ -787,6 +832,73 @@ def test_basic():
     assert_allclose(res.x, 0, atol=1e-10)
 
 
+def test_callback():
+    # test that callback function works as expected
+
+    results = []
+    
+    def my_callback_optimresult(intermediate_result: OptimizeResult):
+        results.append(intermediate_result)
+        
+    def my_callback_x(x):
+        r = OptimizeResult()
+        r.nit = 1
+        r.x = x
+        results.append(r)
+        return False
+        
+    def my_callback_optimresult_stop_exception(
+        intermediate_result: OptimizeResult):
+        results.append(intermediate_result)
+        raise StopIteration
+
+    def my_callback_x_stop_exception(x):
+        r = OptimizeResult()
+        r.nit = 1
+        r.x = x
+        results.append(r)
+        raise StopIteration
+
+    # Try for different function signatures and stop methods
+    callbacks_nostop = [my_callback_optimresult, my_callback_x]
+    callbacks_stop = [my_callback_optimresult_stop_exception,
+                      my_callback_x_stop_exception]
+    
+    # Try for all the implemented methods: trf, trf_bounds and dogbox
+    calls = [
+        lambda callback: least_squares(fun_trivial, 5.0, method='trf', 
+                                       callback=callback),
+        lambda callback: least_squares(fun_trivial, 5.0, method='trf', 
+                                       bounds=(-8.0, 8.0), callback=callback),
+        lambda callback: least_squares(fun_trivial, 5.0, method='dogbox', 
+                                       callback=callback)
+    ]
+
+    for mycallback, call in product(callbacks_nostop, calls):
+        results.clear()
+        # Call the different implemented methods
+        res = call(mycallback)
+        # Check that callback was called
+        assert len(results) > 0
+        # Check that results data makes sense
+        assert results[-1].nit > 0
+        # Check that it didn't stop because of the callback
+        assert res.status != -2
+        # final callback x should be same as final result
+        assert_allclose(results[-1].x, res.x)
+
+    for mycallback, call in product(callbacks_stop, calls):
+        results.clear()
+        # Call the different implemented methods
+        res = call(mycallback)
+        # Check that callback was called
+        assert len(results) > 0
+        # Check that only one iteration was run
+        assert results[-1].nit == 1
+        # Check that it stopped because of the callback
+        assert res.status == -2
+
+
 def test_small_tolerances_for_lm():
     for ftol, xtol, gtol in [(None, 1e-13, 1e-13),
                              (1e-13, None, 1e-13),

scipy/optimize/tests/test_linear_assignment.py

@@ -7,7 +7,7 @@ import pytest
 import numpy as np
 
 from scipy.optimize import linear_sum_assignment
-from scipy.sparse import random
+from scipy.sparse import random_array
 from scipy.sparse._sputils import matrix
 from scipy.sparse.csgraph import min_weight_full_bipartite_matching
 from scipy.sparse.csgraph.tests.test_matching import (
@@ -93,8 +93,8 @@ def test_two_methods_give_same_result_on_many_sparse_inputs():
     for _ in range(100):
         lsa_raises = False
         mwfbm_raises = False
-        sparse = random(100, 100, density=0.06,
-                        data_rvs=lambda size: np.random.randint(1, 100, size))
+        sparse = random_array((100, 100), density=0.06,
+                              data_sampler=lambda size: np.random.randint(1, 100, size))
         # In csgraph, zeros correspond to missing edges, so we explicitly
         # replace those with infinities
         dense = np.full(sparse.shape, np.inf)

scipy/optimize/tests/test_linprog.py

@@ -5,6 +5,7 @@ import sys
 import platform
 
 import numpy as np
+from numpy.exceptions import VisibleDeprecationWarning
 from numpy.testing import (assert_, assert_allclose, assert_equal,
                            assert_array_less, assert_warns, suppress_warnings)
 from pytest import raises as assert_raises
@@ -12,7 +13,6 @@ from scipy.optimize import linprog, OptimizeWarning
 from scipy.optimize._numdiff import approx_derivative
 from scipy.sparse.linalg import MatrixRankWarning
 from scipy.linalg import LinAlgWarning
-from scipy._lib._util import VisibleDeprecationWarning
 import scipy.sparse
 import pytest
 
@@ -220,7 +220,7 @@ def l1_regression_prob(seed=0, m=8, d=9, n=100):
     # construct the problem
     c = np.ones(m+n)
     c[:m] = 0
-    A_ub = scipy.sparse.lil_matrix((2*n, n+m))
+    A_ub = scipy.sparse.lil_array((2*n, n+m))
     idx = 0
     for ii in range(n):
         A_ub[idx, :m] = phi @ x[:, ii]
@@ -519,7 +519,7 @@ class LinprogCommonTests:
         rng = np.random.RandomState(0)
         m = 100
         n = 150
-        A_eq = scipy.sparse.rand(m, n, 0.5)
+        A_eq = scipy.sparse.random_array((m, n), density=0.5)
         x_valid = rng.randn(n)
         c = rng.randn(n)
         ub = x_valid + rng.rand(n)

scipy/optimize/tests/test_lsq_linear.py

@@ -4,7 +4,7 @@ import numpy as np
 from numpy.linalg import lstsq
 from numpy.testing import assert_allclose, assert_equal, assert_
 
-from scipy.sparse import rand, coo_matrix
+from scipy.sparse import random_array, coo_array
 from scipy.sparse.linalg import aslinearoperator
 from scipy.optimize import lsq_linear
 from scipy.optimize._minimize import Bounds
@@ -177,7 +177,7 @@ class BaseMixin:
 
         assert_(abs(cost_bvls - cost_trf) < cost_trf*1e-10)
 
-    def test_convergence_small_matrix(self):
+    def test_convergence_small_array(self):
         A = np.array([[49.0, 41.0, -32.0],
                       [-19.0, -32.0, -8.0],
                       [-13.0, 10.0, 69.0]])
@@ -199,7 +199,7 @@ class SparseMixin:
         m = 5000
         n = 1000
         rng = np.random.RandomState(0)
-        A = rand(m, n, random_state=rng)
+        A = random_array((m, n), random_state=rng)
         b = rng.randn(m)
         res = lsq_linear(A, b)
         assert_allclose(res.optimality, 0, atol=1e-6)
@@ -213,7 +213,7 @@ class SparseMixin:
         m = 5000
         n = 1000
         rng = np.random.RandomState(0)
-        A = rand(m, n, random_state=rng)
+        A = random_array((m, n), random_state=rng)
         b = rng.randn(m)
         lb = rng.randn(n)
         ub = lb + 1
@@ -232,14 +232,14 @@ class SparseMixin:
         data = np.array([1., 1., 1., 1. + 1e-6, 1.])
         row = np.array([0, 0, 1, 2, 2])
         col = np.array([0, 2, 1, 0, 2])
-        A = coo_matrix((data, (row, col)), shape=(3, 3))
+        A = coo_array((data, (row, col)), shape=(3, 3))
 
         # Get the exact solution
         exact_sol = lsq_linear(A.toarray(), b, lsq_solver='exact')
 
         # Default lsmr arguments should not fully converge the solution
         default_lsmr_sol = lsq_linear(A, b, lsq_solver='lsmr')
-        with pytest.raises(AssertionError, match=""):
+        with pytest.raises(AssertionError):
             assert_allclose(exact_sol.x, default_lsmr_sol.x)
 
         # By increasing the maximum lsmr iters, it will converge

scipy/optimize/tests/test_minimize_constrained.py

@@ -1,7 +1,7 @@
 import numpy as np
 import pytest
 from scipy.linalg import block_diag
-from scipy.sparse import csc_matrix
+from scipy.sparse import csc_array
 from numpy.testing import (assert_array_almost_equal,
                            assert_array_less, assert_,
                            suppress_warnings)
@@ -430,7 +430,7 @@ class Elec:
                 Jx = 2 * np.diag(x_coord)
                 Jy = 2 * np.diag(y_coord)
                 Jz = 2 * np.diag(z_coord)
-                return csc_matrix(np.hstack((Jx, Jy, Jz)))
+                return csc_array(np.hstack((Jx, Jy, Jz)))
         else:
             jac = self.constr_jac
 

scipy/optimize/tests/test_minpack.py

@@ -308,7 +308,7 @@ class TestLeastSq:
         p0 = array([0,0,0])
         params_fit, ier = leastsq(self.residuals, p0,
                                   args=(self.y_meas, self.x))
-        assert_(ier in (1,2,3,4), 'solution not found (ier=%d)' % ier)
+        assert_(ier in (1, 2, 3, 4), f'solution not found (ier={ier})')
         # low precision due to random
         assert_array_almost_equal(params_fit, self.abc, decimal=2)
 
@@ -317,7 +317,7 @@ class TestLeastSq:
         params_fit, ier = leastsq(self.residuals, p0,
                                   args=(self.y_meas, self.x),
                                   Dfun=self.residuals_jacobian)
-        assert_(ier in (1,2,3,4), 'solution not found (ier=%d)' % ier)
+        assert_(ier in (1, 2, 3, 4), f'solution not found (ier={ier})')
         # low precision due to random
         assert_array_almost_equal(params_fit, self.abc, decimal=2)
 
@@ -405,7 +405,7 @@ class TestLeastSq:
         p0 = array([0,0,0])
         params_fit, ier = leastsq(func, p0,
                                   args=(self.y_meas, self.x))
-        assert_(ier in (1,2,3,4), 'solution not found (ier=%d)' % ier)
+        assert_(ier in (1, 2, 3, 4), f'solution not found (ier={ier})')
         # low precision due to random
         assert_array_almost_equal(params_fit, self.abc, decimal=2)
 
@@ -418,7 +418,7 @@ class TestLeastSq:
         params_fit, ier = leastsq(self.residuals, p0,
                                   args=(self.y_meas, self.x),
                                   Dfun=deriv_func)
-        assert_(ier in (1,2,3,4), 'solution not found (ier=%d)' % ier)
+        assert_(ier in (1, 2, 3, 4), f'solution not found (ier={ier})')
         # low precision due to random
         assert_array_almost_equal(params_fit, self.abc, decimal=2)
 

scipy/optimize/tests/test_nnls.py

@@ -2,6 +2,7 @@ import numpy as np
 from numpy.testing import assert_allclose
 from pytest import raises as assert_raises
 from scipy.optimize import nnls
+import pytest
 
 
 class TestNNLS:
@@ -21,7 +22,7 @@ class TestNNLS:
         x = np.abs(self.rng.uniform(low=-2, high=2, size=[10]))
         x[::2] = 0
         b = a @ x
-        xact, rnorm = nnls(a, b, atol=500*np.linalg.norm(a, 1)*np.spacing(1.))
+        xact, rnorm = nnls(a, b)
         assert_allclose(xact, x, rtol=0., atol=1e-10)
         assert rnorm < 1e-12
 
@@ -32,7 +33,7 @@ class TestNNLS:
         x = np.abs(self.rng.uniform(low=-2, high=2, size=[120]))
         x[::2] = 0
         b = a @ x
-        xact, rnorm = nnls(a, b, atol=500*np.linalg.norm(a, 1)*np.spacing(1.))
+        xact, rnorm = nnls(a, b)
         assert_allclose(xact, x, rtol=0., atol=1e-10)
         assert rnorm < 1e-12
 
@@ -153,7 +154,7 @@ class TestNNLS:
         k[nz] = 0
         W = np.diag(w)
 
-        dact, _ = nnls(W @ A, W @ k, atol=1e-7)
+        dact, _ = nnls(W @ A, W @ k)
 
         p = np.cumsum(dact)
         assert np.all(dact >= 0)
@@ -427,3 +428,42 @@ class TestNNLS:
         assert_allclose(sol, np.array([0.0, 0.0, 76.3611306173957, 0.0, 0.0]),
                         atol=5e-14)
         assert np.abs(np.linalg.norm(A@sol - b) - res) < 5e-14
+
+    def test_atol_deprecation_warning(self):
+        """Test that using atol parameter triggers deprecation warning"""
+        a = np.array([[1, 0], [1, 0], [0, 1]])
+        b = np.array([2, 1, 1])
+
+        with pytest.warns(DeprecationWarning, match="{'atol'}"):
+            nnls(a, b, atol=1e-8)
+
+    def test_2D_singleton_RHS_input(self):
+        # Test that a 2D singleton RHS input is accepted
+        A = np.array([[1.0, 0.5, -1.],
+                      [1.0, 0.5, 0.0],
+                      [-1., 0.0, 1.0]])
+        b = np.array([[-1.0, 2.0, 2.0]]).T
+        x, r = nnls(A, b)
+        assert_allclose(x, np.array([1.0, 2.0, 3.0]))
+        assert_allclose(r, 0.0)
+
+    def test_2D_not_singleton_RHS_input_2(self):
+        # Test that a 2D but not a column vector RHS input is rejected
+        A = np.array([[1.0, 0.5, -1.],
+                      [1.0, 0.5, 0.0],
+                      [1.0, 0.5, 0.0],
+                      [0.0, 0.0, 1.0]])
+        b = np.ones(shape=[4, 2], dtype=np.float64)
+        with pytest.raises(ValueError, match="Expected a 1D array"):
+            nnls(A, b)
+
+    def test_gh_22791_32bit(self):
+        # Scikit-learn got hit by this problem on 32-bit arch.
+        desired = [0, 0, 1.05617285, 0, 0, 0, 0, 0.23123048, 0, 0, 0, 0.26128651]
+        rng = np.random.RandomState(42)
+        n_samples, n_features = 5, 12
+        X = rng.randn(n_samples, n_features)
+        X[:2, :] = 0
+        y = rng.randn(n_samples)
+        coef, _ = nnls(X, y)
+        assert_allclose(coef, desired)

scipy/optimize/tests/test_nonlin.py

@@ -12,6 +12,7 @@ from numpy import diag, dot
 from numpy.linalg import inv
 import numpy as np
 import scipy
+from scipy.sparse.linalg import minres
 
 from .test_minpack import pressure_network
 
@@ -217,6 +218,41 @@ class TestNonlin:
         with pytest.raises(scipy.optimize.NoConvergence):
             nonlin.newton_krylov(wont_converge, xin=[0], maxiter=1)
 
+    def test_warnings_invalid_inner_param(self):
+        """
+        Test for ENH #21986, for behavior of `nonlin.newton_krylov`
+        Test the following scenarios:
+        1. Raise warning for invalid inner param
+        2. No warning for valid inner param
+        3. No warning for user-provided callable method
+        """
+        # This should raise exactly one warning
+        # (`inner_atol` is not valid for `minres`)
+        with pytest.warns(UserWarning,
+                          match="Please check inner method documentation"):
+            nonlin.newton_krylov(F, F.xin, method="minres", inner_atol=1e-5)
+
+        # This should not raise a warning (`minres` without `inner_atol`,
+        # but with `inner_maxiter` which is valid)
+        nonlin.newton_krylov(F, F.xin, method="minres", inner_maxiter=100,
+                             inner_callback= lambda _ : ...)
+
+        # Test newton_krylov with a user-provided callable method
+        def user_provided_callable_method_enh_21986(op, rhs, **kwargs):
+            """A dummy user-provided callable method for testing."""
+            # Return a dummy result (mimicking minres)
+            return minres(op, rhs, **kwargs)
+        # This should not raise any warnings
+        nonlin.newton_krylov(F, F.xin,
+                             method=user_provided_callable_method_enh_21986)
+
+    def test_non_inner_prefix(self):
+        with pytest.raises(ValueError,
+                           match="Unknown parameter"
+                           ):
+            # Pass a parameter without 'inner_' prefix
+            nonlin.newton_krylov(F, F.xin, method="minres", invalid_param=1e-5)
+
 
 class TestSecant:
     """Check that some Jacobian approximations satisfy the secant condition"""