scipy 1.15.3__cp312-cp312-musllinux_1_2_aarch64.whl → 1.16.0rc2__cp312-cp312-musllinux_1_2_aarch64.whl

scipy/optimize/tests/test_cobyla.py

@@ -1,17 +1,21 @@
 import math
 
 import numpy as np
-from numpy.testing import assert_allclose, assert_, assert_array_equal
-import pytest
+from numpy.testing import assert_allclose, assert_array_almost_equal
 
-from scipy.optimize import fmin_cobyla, minimize, Bounds
+from scipy.optimize import (
+    fmin_cobyla, minimize, Bounds, NonlinearConstraint, LinearConstraint,
+    OptimizeResult
+)
 
 
 class TestCobyla:
     def setup_method(self):
-        self.x0 = [4.95, 0.66]
+        # The algorithm is very fragile on 32 bit, so unfortunately we need to start
+        # very near the solution in order for the test to pass.
+        self.x0 = [np.sqrt(25 - (2.0/3)**2), 2.0/3 + 1e-4]
         self.solution = [math.sqrt(25 - (2.0/3)**2), 2.0/3]
-        self.opts = {'disp': False, 'rhobeg': 1, 'tol': 1e-5,
+        self.opts = {'disp': 0, 'rhobeg': 1, 'tol': 1e-6,
                      'maxiter': 100}
 
     def fun(self, x):
@@ -23,11 +27,10 @@ class TestCobyla:
     def con2(self, x):
         return -self.con1(x)
 
-    @pytest.mark.xslow(True, reason='not slow, but noisy so only run rarely')
-    def test_simple(self, capfd):
+    def test_simple(self):
         # use disp=True as smoke test for gh-8118
         x = fmin_cobyla(self.fun, self.x0, [self.con1, self.con2], rhobeg=1,
-                        rhoend=1e-5, maxfun=100, disp=True)
+                        rhoend=1e-5, maxfun=100, disp=1)
         assert_allclose(x, self.solution, atol=1e-4)
 
     def test_minimize_simple(self):
@@ -40,54 +43,80 @@ class TestCobyla:
                 self.n_calls += 1
                 self.last_x = x
 
+        class CallbackNewSyntax:
+            def __init__(self):
+                self.n_calls = 0
+
+            def __call__(self, intermediate_result):
+                assert isinstance(intermediate_result, OptimizeResult)
+                self.n_calls += 1
+
         callback = Callback()
+        callback_new_syntax = CallbackNewSyntax()
 
         # Minimize with method='COBYLA'
-        cons = ({'type': 'ineq', 'fun': self.con1},
+        cons = (NonlinearConstraint(self.con1, 0, np.inf),
                 {'type': 'ineq', 'fun': self.con2})
         sol = minimize(self.fun, self.x0, method='cobyla', constraints=cons,
                        callback=callback, options=self.opts)
+        sol_new = minimize(self.fun, self.x0, method='cobyla', constraints=cons,
+                       callback=callback_new_syntax, options=self.opts)
         assert_allclose(sol.x, self.solution, atol=1e-4)
-        assert_(sol.success, sol.message)
-        assert_(sol.maxcv < 1e-5, sol)
-        assert_(sol.nfev < 70, sol)
-        assert_(sol.fun < self.fun(self.solution) + 1e-3, sol)
-        assert_(sol.nfev == callback.n_calls,
-                "Callback is not called exactly once for every function eval.")
-        assert_array_equal(
+        assert sol.success, sol.message
+        assert sol.maxcv < 1e-5, sol
+        assert sol.nfev < 70, sol
+        assert sol.fun < self.fun(self.solution) + 1e-3, sol
+        assert_array_almost_equal(
             sol.x,
             callback.last_x,
-            "Last design vector sent to the callback is not equal to returned value.",
+            decimal=5,
+            err_msg="Last design vector sent to the callback is not equal to"
+                 " returned value.",
         )
+        assert sol_new.success, sol_new.message
+        assert sol.fun == sol_new.fun
+        assert sol.maxcv == sol_new.maxcv
+        assert sol.nfev == sol_new.nfev
+        assert callback.n_calls == callback_new_syntax.n_calls, \
+            "Callback is not called the same amount of times for old and new syntax."
 
     def test_minimize_constraint_violation(self):
-        rng = np.random.RandomState(1234)
-        pb = rng.rand(10, 10)
-        spread = rng.rand(10)
-
-        def p(w):
-            return pb.dot(w)
-
-        def f(w):
-            return -(w * spread).sum()
-
-        def c1(w):
-            return 500 - abs(p(w)).sum()
-
-        def c2(w):
-            return 5 - abs(p(w).sum())
-
-        def c3(w):
-            return 5 - abs(p(w)).max()
-
-        cons = ({'type': 'ineq', 'fun': c1},
-                {'type': 'ineq', 'fun': c2},
-                {'type': 'ineq', 'fun': c3})
-        w0 = np.zeros((10,))
-        sol = minimize(f, w0, method='cobyla', constraints=cons,
-                       options={'catol': 1e-6})
-        assert_(sol.maxcv > 1e-6)
-        assert_(not sol.success)
+        # We set up conflicting constraints so that the algorithm will be
+        # guaranteed to end up with maxcv > 0.
+        cons = ({'type': 'ineq', 'fun': lambda x: 4 - x},
+                {'type': 'ineq', 'fun': lambda x: x - 5})
+        sol = minimize(lambda x: x, [0], method='cobyla', constraints=cons,
+                       options={'catol': 0.6})
+        assert sol.maxcv > 0.1
+        assert sol.success
+        sol = minimize(lambda x: x, [0], method='cobyla', constraints=cons,
+                       options={'catol': 0.4})
+        assert sol.maxcv > 0.1
+        assert not sol.success
+
+    def test_f_target(self):
+        f_target = 250
+        sol = minimize(lambda x: x**2, [500], method='cobyla',
+                       options={'f_target': f_target})
+        assert sol.status == 1
+        assert sol.success
+        assert sol.fun <= f_target
+
+    def test_minimize_linear_constraints(self):
+        constraints = LinearConstraint([1.0, 1.0], 1.0, 1.0)
+        sol = minimize(
+            self.fun,
+            self.x0,
+            method='cobyla',
+            constraints=constraints,
+            options=self.opts,
+        )
+        solution = [(4 - np.sqrt(7)) / 3, (np.sqrt(7) - 1) / 3]
+        assert_allclose(sol.x, solution, atol=1e-4)
+        assert sol.success, sol.message
+        assert sol.maxcv < 1e-8, sol
+        assert sol.nfev <= 100, sol
+        assert sol.fun < self.fun(solution) + 1e-3, sol
 
 
 def test_vector_constraints():
@@ -124,7 +153,7 @@ def test_vector_constraints():
     constraints = [{'type': 'ineq', 'fun': cons} for cons in cons_list]
     sol = minimize(fun, x0, constraints=constraints, tol=1e-5)
     assert_allclose(sol.x, xsol, atol=1e-4)
-    assert_(sol.success, sol.message)
+    assert sol.success, sol.message
     assert_allclose(sol.fun, fsol, atol=1e-4)
 
     constraints = {'type': 'ineq', 'fun': fmin}

scipy/optimize/tests/test_constraints.py

@@ -97,7 +97,7 @@ def test_prepare_constraint_infeasible_x0():
         return A
 
     def hess(x, v):
-        return sps.csr_matrix((4, 4))
+        return sps.csr_array((4, 4))
 
     nonlinear = NonlinearConstraint(fun, -np.inf, 0, jac, hess,
                                     enforce_feasibility)

scipy/optimize/tests/test_differentiable_functions.py

@@ -5,7 +5,8 @@ from numpy.testing import (TestCase, assert_array_almost_equal,
                            assert_array_equal, assert_, assert_allclose,
                            assert_equal)
 from scipy._lib._gcutils import assert_deallocated
-from scipy.sparse import csr_matrix
+from scipy._lib._util import MapWrapper
+from scipy.sparse import csr_array
 from scipy.sparse.linalg import LinearOperator
 from scipy.optimize._differentiable_functions import (ScalarFunction,
                                                       VectorFunction,
@@ -130,6 +131,67 @@ class TestScalarFunction(TestCase):
         assert_array_almost_equal(f_analit, f_approx)
         assert_array_almost_equal(g_analit, g_approx)
 
+    @pytest.mark.fail_slow(5.0)
+    def test_workers(self):
+        x0 = np.array([2.0, 0.3])
+        ex = ExScalarFunction()
+        ex2 = ExScalarFunction()
+        with MapWrapper(2) as mapper:
+            approx = ScalarFunction(ex.fun, x0, (), '2-point',
+                                    ex.hess, None, (-np.inf, np.inf),
+                                    workers=mapper)
+            approx_series = ScalarFunction(ex2.fun, x0, (), '2-point',
+                                           ex2.hess, None, (-np.inf, np.inf),
+                                           )
+            assert_allclose(approx.grad(x0), ex.grad(x0))
+            assert_allclose(approx_series.grad(x0), ex.grad(x0))
+            assert_allclose(approx_series.hess(x0), ex.hess(x0))
+            assert_allclose(approx.hess(x0), ex.hess(x0))
+            assert_equal(approx.nfev, approx_series.nfev)
+            assert_equal(approx_series.nfev, ex2.nfev)
+            assert_equal(approx.ngev, approx_series.ngev)
+            assert_equal(approx.nhev, approx_series.nhev)
+            assert_equal(approx_series.nhev, ex2.nhev)
+
+            ex = ExScalarFunction()
+            ex2 = ExScalarFunction()
+            approx = ScalarFunction(ex.fun, x0, (), '3-point',
+                                    ex.hess, None, (-np.inf, np.inf),
+                                    workers=mapper)
+            approx_series = ScalarFunction(ex2.fun, x0, (), '3-point',
+                                           ex2.hess, None, (-np.inf, np.inf),
+                                          )
+            assert_allclose(approx.grad(x0), ex.grad(x0))
+            assert_allclose(approx_series.grad(x0), ex.grad(x0))
+            assert_allclose(approx_series.hess(x0), ex.hess(x0))
+            assert_allclose(approx.hess(x0), ex.hess(x0))
+            assert_equal(approx.nfev, approx_series.nfev)
+            assert_equal(approx_series.nfev, ex2.nfev)
+            assert_equal(approx.ngev, approx_series.ngev)
+            assert_equal(approx.nhev, approx_series.nhev)
+            assert_equal(approx_series.nhev, ex2.nhev)
+
+            ex = ExScalarFunction()
+            ex2 = ExScalarFunction()
+            x1 = np.array([3.0, 4.0])
+
+            approx = ScalarFunction(ex.fun, x0, (), ex.grad,
+                                    '3-point', None, (-np.inf, np.inf),
+                                    workers=mapper)
+            approx_series = ScalarFunction(ex2.fun, x0, (), ex2.grad,
+                                           '3-point', None, (-np.inf, np.inf),
+                                           )
+            assert_allclose(approx.grad(x1), ex.grad(x1))
+            assert_allclose(approx_series.grad(x1), ex.grad(x1))
+            approx_series.hess(x1)
+            approx.hess(x1)
+            assert_equal(approx.nfev, approx_series.nfev)
+            assert_equal(approx_series.nfev, ex2.nfev)
+            assert_equal(approx.ngev, approx_series.ngev)
+            assert_equal(approx_series.ngev, ex2.ngev)
+            assert_equal(approx.nhev, approx_series.nhev)
+            assert_equal(approx_series.nhev, ex2.nhev)
+
     def test_fun_and_grad(self):
         ex = ExScalarFunction()
 
@@ -419,8 +481,9 @@ class TestVectorialFunction(TestCase):
         assert_array_equal(analit.nfev, nfev)
         assert_array_equal(ex.njev, njev)
         assert_array_equal(analit.njev, njev)
-        approx = VectorFunction(ex.fun, x0, '2-point', ex.hess, None, None,
-                                (-np.inf, np.inf), None)
+        # create with defaults for the keyword arguments, to
+        # ensure that the defaults work
+        approx = VectorFunction(ex.fun, x0, '2-point', ex.hess)
         nfev += 3
         assert_array_equal(ex.nfev, nfev)
         assert_array_equal(analit.nfev+approx.nfev, nfev)
@@ -501,6 +564,94 @@ class TestVectorialFunction(TestCase):
         assert_array_almost_equal(f_analit, f_approx)
         assert_array_almost_equal(J_analit, J_approx)
 
+    def test_updating_on_initial_setup(self):
+        # Check that memoisation works with the freshly created VectorFunction
+        # On initialization vf.f_updated attribute wasn't being set correctly.
+        x0 = np.array([2.5, 3.0])
+        ex = ExVectorialFunction()
+        vf = VectorFunction(ex.fun, x0, ex.jac, ex.hess)
+        assert vf.f_updated
+        assert vf.nfev == 1
+        assert vf.njev == 1
+        assert ex.nfev == 1
+        assert ex.njev == 1
+        vf.fun(x0)
+        vf.jac(x0)
+        assert vf.nfev == 1
+        assert vf.njev == 1
+        assert ex.nfev == 1
+        assert ex.njev == 1
+
+    @pytest.mark.fail_slow(5.0)
+    def test_workers(self):
+        x0 = np.array([2.5, 3.0])
+        ex = ExVectorialFunction()
+        ex2 = ExVectorialFunction()
+        v = np.array([1.0, 2.0])
+
+        with MapWrapper(2) as mapper:
+            approx = VectorFunction(ex.fun, x0, '2-point',
+                                    ex.hess, None, None, (-np.inf, np.inf),
+                                    False, workers=mapper)
+            approx_series = VectorFunction(ex2.fun, x0, '2-point',
+                                           ex2.hess, None, None, (-np.inf, np.inf),
+                                           False)
+
+            assert_allclose(approx.jac(x0), ex.jac(x0))
+            assert_allclose(approx_series.jac(x0), ex.jac(x0))
+            assert_allclose(approx_series.hess(x0, v), ex.hess(x0, v))
+            assert_allclose(approx.hess(x0, v), ex.hess(x0, v))
+            assert_equal(approx.nfev, approx_series.nfev)
+            assert_equal(approx_series.nfev, ex2.nfev)
+            assert_equal(approx.njev, approx_series.njev)
+            assert_equal(approx.nhev, approx_series.nhev)
+            assert_equal(approx_series.nhev, ex2.nhev)
+
+            ex.nfev = ex.njev = ex.nhev = 0
+            ex2.nfev = ex2.njev = ex2.nhev = 0
+            approx = VectorFunction(ex.fun, x0, '3-point',
+                                    ex.hess, None, None, (-np.inf, np.inf),
+                                    False, workers=mapper)
+            approx_series = VectorFunction(ex2.fun, x0, '3-point',
+                                           ex2.hess, None, None, (-np.inf, np.inf),
+                                           False)
+            assert_allclose(approx.jac(x0), ex.jac(x0))
+            assert_allclose(approx_series.jac(x0), ex.jac(x0))
+            assert_allclose(approx_series.hess(x0, v), ex.hess(x0, v))
+            assert_allclose(approx.hess(x0, v), ex.hess(x0, v))
+
+            assert_equal(approx.nfev, approx_series.nfev)
+            assert_equal(approx_series.nfev, ex2.nfev)
+            assert_equal(approx.njev, approx_series.njev)
+            assert_equal(approx.nhev, approx_series.nhev)
+            assert_equal(approx_series.nhev, ex2.nhev)
+
+            # The following tests are somewhat redundant because the LinearOperator
+            # produced by VectorFunction.hess does not use any parallelisation.
+            # The tests are left for completeness, in case that situation changes.
+            ex.nfev = ex.njev = ex.nhev = 0
+            ex2.nfev = ex2.njev = ex2.nhev = 0
+            approx = VectorFunction(ex.fun, x0, ex.jac,
+                                    '2-point', None, None, (-np.inf, np.inf),
+                                    False, workers=mapper)
+            approx_series = VectorFunction(ex2.fun, x0, ex2.jac,
+                                           '2-point', None, None, (-np.inf, np.inf),
+                                           False)
+            assert_allclose(approx.jac(x0), ex.jac(x0))
+            assert_allclose(approx_series.jac(x0), ex.jac(x0))
+
+            H_analit = ex2.hess(x0, v)
+            H_approx_series = approx_series.hess(x0, v)
+            H_approx = approx.hess(x0, v)
+            x = [5, 2.0]
+            assert_allclose(H_approx.dot(x), H_analit.dot(x))
+            assert_allclose(H_approx_series.dot(x), H_analit.dot(x))
+
+            assert_equal(approx.nfev, approx_series.nfev)
+            assert_equal(approx_series.nfev, ex2.nfev)
+            assert_equal(approx.njev, approx_series.njev)
+            assert_equal(approx.nhev, approx_series.nhev)
+
     def test_finite_difference_hess_linear_operator(self):
         ex = ExVectorialFunction()
         nfev = 0
@@ -629,6 +780,38 @@ class TestVectorialFunction(TestCase):
         assert_array_equal(ex.nhev, nhev)
         assert_array_equal(analit.nhev+approx.nhev, nhev)
 
+        # Test VectorFunction.hess_wrapped with J0=None
+        x = np.array([1.5, 0.5])
+        v = np.array([1.0, 2.0])
+        njev_before = approx.hess_wrapped.njev
+        H = approx.hess_wrapped(x, v, J0=None)
+        assert isinstance(H, LinearOperator)
+        # The njev counter should be incremented by exactly 1
+        assert approx.hess_wrapped.njev == njev_before + 1
+
+    def test_fgh_overlap(self):
+        # VectorFunction.fun/jac should return copies to internal attributes
+        ex = ExVectorialFunction()
+        x0 = np.array([1.0, 0.0])
+
+        vf = VectorFunction(ex.fun, x0, '3-point', ex.hess, None, None,
+                            (-np.inf, np.inf), None)
+        f = vf.fun(np.array([1.1, 0.1]))
+        J = vf.jac([1.1, 0.1])
+        assert vf.f is not f
+        assert vf.J is not J
+        assert_equal(f, vf.f)
+        assert_equal(J, vf.J)
+
+        vf = VectorFunction(ex.fun, x0, ex.jac, ex.hess, None, None,
+                            (-np.inf, np.inf), None)
+        f = vf.fun(np.array([1.1, 0.1]))
+        J = vf.jac([1.1, 0.1])
+        assert vf.f is not f
+        assert vf.J is not J
+        assert_equal(f, vf.f)
+        assert_equal(J, vf.J)
+
     @pytest.mark.thread_unsafe
     def test_x_storage_overlap(self):
         # VectorFunction should not store references to arrays, it should
@@ -686,6 +869,44 @@ class TestVectorialFunction(TestCase):
         res = vf.jac(x0)
         assert res.dtype == np.float32
 
+    def test_sparse_analytic_jac(self):
+        ex = ExVectorialFunction()
+        x0 = np.array([1.0, 0.0])
+        def sparse_adapter(func):
+            def inner(x):
+                f_x = func(x)
+                return csr_array(f_x)
+            return inner
+
+        # jac(x) returns dense jacobian
+        vf1 = VectorFunction(ex.fun, x0, ex.jac, ex.hess, None, None,
+                            (-np.inf, np.inf), sparse_jacobian=None)
+        # jac(x) returns sparse jacobian, but sparse_jacobian=False requests dense
+        vf2 = VectorFunction(ex.fun, x0, sparse_adapter(ex.jac), ex.hess, None, None,
+                            (-np.inf, np.inf), sparse_jacobian=False)
+
+        res1 = vf1.jac(x0 + 1)
+        res2 = vf2.jac(x0 + 1)
+        assert_equal(res1, res2)
+
+    def test_sparse_numerical_jac(self):
+        ex = ExVectorialFunction()
+        x0 = np.array([1.0, 0.0])
+        N = len(x0)
+
+        # normal dense numerical difference
+        vf1 = VectorFunction(ex.fun, x0, '2-point', ex.hess, None, None,
+                             (-np.inf, np.inf), sparse_jacobian=None)
+        # use sparse numerical difference, but ask it to be converted to dense
+        finite_diff_jac_sparsity = csr_array(np.ones((N, N)))
+        vf2 = VectorFunction(ex.fun, x0, '2-point', ex.hess, None,
+                             finite_diff_jac_sparsity, (-np.inf, np.inf),
+                             sparse_jacobian=False)
+
+        res1 = vf1.jac(x0 + 1)
+        res2 = vf2.jac(x0 + 1)
+        assert_equal(res1, res2)
+
 
 def test_LinearVectorFunction():
     A_dense = np.array([
@@ -693,7 +914,7 @@ def test_LinearVectorFunction():
         [0, 4, 2]
     ])
     x0 = np.zeros(3)
-    A_sparse = csr_matrix(A_dense)
+    A_sparse = csr_array(A_dense)
     x = np.array([1, -1, 0])
     v = np.array([-1, 1])
     Ax = np.array([-3, -4])
@@ -779,7 +1000,6 @@ def test_ScalarFunctionNoReferenceCycle():
     platform.python_implementation() == "PyPy",
     reason="assert_deallocate not available on PyPy"
 )
-@pytest.mark.xfail(reason="TODO remove reference cycle from VectorFunction")
 def test_VectorFunctionNoReferenceCycle():
     """Regression test for gh-20768."""
     ex = ExVectorialFunction()
@@ -800,6 +1020,6 @@ def test_LinearVectorFunctionNoReferenceCycle():
         [0, 4, 2]
     ])
     x0 = np.zeros(3)
-    A_sparse = csr_matrix(A_dense)
+    A_sparse = csr_array(A_dense)
     with assert_deallocated(lambda: LinearVectorFunction(A_sparse, x0, None)):
         pass

scipy/optimize/tests/test_lbfgsb_hessinv.py

@@ -41,3 +41,25 @@ def test_2():
     assert_allclose(H1, result2.hess_inv, rtol=1e-2, atol=0.03)
 
 
+def test_3():
+
+    def todense_old_impl(self):
+        s, y, n_corrs, rho = self.sk, self.yk, self.n_corrs, self.rho
+        I_arr = np.eye(*self.shape, dtype=self.dtype)
+        Hk = I_arr
+
+        for i in range(n_corrs):
+            A1 = I_arr - s[i][:, np.newaxis] * y[i][np.newaxis, :] * rho[i]
+            A2 = I_arr - y[i][:, np.newaxis] * s[i][np.newaxis, :] * rho[i]
+
+            Hk = np.dot(A1, np.dot(Hk, A2)) + (rho[i] * s[i][:, np.newaxis] *
+                                                        s[i][np.newaxis, :])
+        return Hk
+
+    H0 = [[3, 0], [1, 2]]
+
+    def f(x):
+        return np.dot(x, np.dot(scipy.linalg.inv(H0), x))
+
+    result1 = minimize(fun=f, method='L-BFGS-B', x0=[10, 20])
+    assert_allclose(result1.hess_inv.todense(), todense_old_impl(result1.hess_inv))