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

scipy/optimize/_zeros_py.py

@@ -317,8 +317,9 @@ def newton(func, x0, fprime=None, args=(), tol=1.48e-8, maxiter=50,
                 msg = "Derivative was zero."
                 if disp:
                     msg += (
-                        " Failed to converge after %d iterations, value is %s."
-                        % (itr + 1, p0))
+                        f" Failed to converge after {itr + 1} iterations,"
+                        f" value is {p0}."
+                    )
                     raise RuntimeError(msg)
                 warnings.warn(msg, RuntimeWarning, stacklevel=2)
                 return _results_select(
@@ -365,8 +366,9 @@ def newton(func, x0, fprime=None, args=(), tol=1.48e-8, maxiter=50,
                     msg = f"Tolerance of {p1 - p0} reached."
                     if disp:
                         msg += (
-                            " Failed to converge after %d iterations, value is %s."
-                            % (itr + 1, p1))
+                            f" Failed to converge after {itr + 1} iterations,"
+                            f" value is {p1}."
+                        )
                         raise RuntimeError(msg)
                     warnings.warn(msg, RuntimeWarning, stacklevel=2)
                 p = (p1 + p0) / 2.0
@@ -386,8 +388,7 @@ def newton(func, x0, fprime=None, args=(), tol=1.48e-8, maxiter=50,
             funcalls += 1
 
     if disp:
-        msg = ("Failed to converge after %d iterations, value is %s."
-               % (itr + 1, p))
+        msg = f"Failed to converge after {itr + 1} iterations, value is {p}."
         raise RuntimeError(msg)
 
     return _results_select(full_output, (p, funcalls, itr + 1, _ECONVERR), method)
@@ -512,11 +513,11 @@ def bisect(f, a, b, args=(),
     b : scalar
         The other end of the bracketing interval [a,b].
     xtol : number, optional
-        The computed root ``x0`` will satisfy ``np.allclose(x, x0,
+        The computed root ``x0`` will satisfy ``np.isclose(x, x0,
         atol=xtol, rtol=rtol)``, where ``x`` is the exact root. The
         parameter must be positive.
     rtol : number, optional
-        The computed root ``x0`` will satisfy ``np.allclose(x, x0,
+        The computed root ``x0`` will satisfy ``np.isclose(x, x0,
         atol=xtol, rtol=rtol)``, where ``x`` is the exact root. The
         parameter cannot be smaller than its default value of
         ``4*np.finfo(float).eps``.
@@ -543,6 +544,22 @@ def bisect(f, a, b, args=(),
         Object containing information about the convergence. In particular,
         ``r.converged`` is True if the routine converged.
 
+    Notes
+    -----
+    As mentioned in the parameter documentation, the computed root ``x0`` will
+    satisfy ``np.isclose(x, x0, atol=xtol, rtol=rtol)``, where ``x`` is the
+    exact root. In equation form, this terminating condition is ``abs(x - x0)
+    <= xtol + rtol * abs(x0)``.
+
+    The default value ``xtol=2e-12`` may lead to surprising behavior if one
+    expects `bisect` to always compute roots with relative error near machine
+    precision. Care should be taken to select `xtol` for the use case at hand.
+    Setting ``xtol=5e-324``, the smallest subnormal number, will ensure the
+    highest level of accuracy. Larger values of `xtol` may be useful for saving
+    function evaluations when a root is at or near zero in applications where
+    the tiny absolute differences available between floating point numbers near
+    zero are not meaningful.
+
     Examples
     --------
 
@@ -564,6 +581,7 @@ def bisect(f, a, b, args=(),
     brentq, brenth, bisect, newton
     fixed_point : scalar fixed-point finder
     fsolve : n-dimensional root-finding
+    elementwise.find_root : efficient elementwise 1-D root-finder
 
     """
     if not isinstance(args, tuple):
@@ -594,11 +612,11 @@ def ridder(f, a, b, args=(),
     b : scalar
         The other end of the bracketing interval [a,b].
     xtol : number, optional
-        The computed root ``x0`` will satisfy ``np.allclose(x, x0,
+        The computed root ``x0`` will satisfy ``np.isclose(x, x0,
         atol=xtol, rtol=rtol)``, where ``x`` is the exact root. The
         parameter must be positive.
     rtol : number, optional
-        The computed root ``x0`` will satisfy ``np.allclose(x, x0,
+        The computed root ``x0`` will satisfy ``np.isclose(x, x0,
         atol=xtol, rtol=rtol)``, where ``x`` is the exact root. The
         parameter cannot be smaller than its default value of
         ``4*np.finfo(float).eps``.
@@ -629,6 +647,7 @@ def ridder(f, a, b, args=(),
     --------
     brentq, brenth, bisect, newton : 1-D root-finding
     fixed_point : scalar fixed-point finder
+    elementwise.find_root : efficient elementwise 1-D root-finder
 
     Notes
     -----
@@ -641,6 +660,20 @@ def ridder(f, a, b, args=(),
     The routine used here diverges slightly from standard presentations in
     order to be a bit more careful of tolerance.
 
+    As mentioned in the parameter documentation, the computed root ``x0`` will
+    satisfy ``np.isclose(x, x0, atol=xtol, rtol=rtol)``, where ``x`` is the
+    exact root. In equation form, this terminating condition is ``abs(x - x0)
+    <= xtol + rtol * abs(x0)``.
+
+    The default value ``xtol=2e-12`` may lead to surprising behavior if one
+    expects `ridder` to always compute roots with relative error near machine
+    precision. Care should be taken to select `xtol` for the use case at hand.
+    Setting ``xtol=5e-324``, the smallest subnormal number, will ensure the
+    highest level of accuracy. Larger values of `xtol` may be useful for saving
+    function evaluations when a root is at or near zero in applications where
+    the tiny absolute differences available between floating point numbers near
+    zero are not meaningful.
+
     References
     ----------
     .. [Ridders1979]
@@ -709,13 +742,13 @@ def brentq(f, a, b, args=(),
     b : scalar
         The other end of the bracketing interval :math:`[a, b]`.
     xtol : number, optional
-        The computed root ``x0`` will satisfy ``np.allclose(x, x0,
+        The computed root ``x0`` will satisfy ``np.isclose(x, x0,
         atol=xtol, rtol=rtol)``, where ``x`` is the exact root. The
         parameter must be positive. For nice functions, Brent's
         method will often satisfy the above condition with ``xtol/2``
         and ``rtol/2``. [Brent1973]_
     rtol : number, optional
-        The computed root ``x0`` will satisfy ``np.allclose(x, x0,
+        The computed root ``x0`` will satisfy ``np.isclose(x, x0,
         atol=xtol, rtol=rtol)``, where ``x`` is the exact root. The
         parameter cannot be smaller than its default value of
         ``4*np.finfo(float).eps``. For nice functions, Brent's
@@ -754,11 +787,26 @@ def brentq(f, a, b, args=(),
     fsolve : N-D root-finding
     brenth, ridder, bisect, newton : 1-D root-finding
     fixed_point : scalar fixed-point finder
+    elementwise.find_root : efficient elementwise 1-D root-finder
 
     Notes
     -----
     `f` must be continuous.  f(a) and f(b) must have opposite signs.
 
+    As mentioned in the parameter documentation, the computed root ``x0`` will
+    satisfy ``np.isclose(x, x0, atol=xtol, rtol=rtol)``, where ``x`` is the
+    exact root. In equation form, this terminating condition is ``abs(x - x0)
+    <= xtol + rtol * abs(x0)``.
+
+    The default value ``xtol=2e-12`` may lead to surprising behavior if one
+    expects `brentq` to always compute roots with relative error near machine
+    precision. Care should be taken to select `xtol` for the use case at hand.
+    Setting ``xtol=5e-324``, the smallest subnormal number, will ensure the
+    highest level of accuracy. Larger values of `xtol` may be useful for saving
+    function evaluations when a root is at or near zero in applications where
+    the tiny absolute differences available between floating point numbers near
+    zero are not meaningful.
+
     References
     ----------
     .. [Brent1973]
@@ -827,13 +875,13 @@ def brenth(f, a, b, args=(),
     b : scalar
         The other end of the bracketing interval [a,b].
     xtol : number, optional
-        The computed root ``x0`` will satisfy ``np.allclose(x, x0,
+        The computed root ``x0`` will satisfy ``np.isclose(x, x0,
         atol=xtol, rtol=rtol)``, where ``x`` is the exact root. The
         parameter must be positive. As with `brentq`, for nice
         functions the method will often satisfy the above condition
         with ``xtol/2`` and ``rtol/2``.
     rtol : number, optional
-        The computed root ``x0`` will satisfy ``np.allclose(x, x0,
+        The computed root ``x0`` will satisfy ``np.isclose(x, x0,
         atol=xtol, rtol=rtol)``, where ``x`` is the exact root. The
         parameter cannot be smaller than its default value of
         ``4*np.finfo(float).eps``. As with `brentq`, for nice functions
@@ -872,6 +920,23 @@ def brenth(f, a, b, args=(),
     fsolve : N-D root-finding
     brentq, ridder, bisect, newton : 1-D root-finding
     fixed_point : scalar fixed-point finder
+    elementwise.find_root : efficient elementwise 1-D root-finder
+
+    Notes
+    -----
+    As mentioned in the parameter documentation, the computed root ``x0`` will
+    satisfy ``np.isclose(x, x0, atol=xtol, rtol=rtol)``, where ``x`` is the
+    exact root. In equation form, this terminating condition is ``abs(x - x0)
+    <= xtol + rtol * abs(x0)``.
+
+    The default value ``xtol=2e-12`` may lead to surprising behavior if one
+    expects `brenth` to always compute roots with relative error near machine
+    precision. Care should be taken to select `xtol` for the use case at hand.
+    Setting ``xtol=5e-324``, the smallest subnormal number, will ensure the
+    highest level of accuracy. Larger values of `xtol` may be useful for saving
+    function evaluations when a root is at or near zero in applications where
+    the tiny absolute differences available between floating point numbers near
+    zero are not meaningful.
 
     References
     ----------
@@ -1089,7 +1154,7 @@ class TOMS748Solver:
         self.k = max(k, self._K_MIN)
         # Noisily replace a high value of k with self._K_MAX
         if self.k > self._K_MAX:
-            msg = "toms748: Overriding k: ->%d" % self._K_MAX
+            msg = f"toms748: Overriding k: ->{self._K_MAX}"
             warnings.warn(msg, RuntimeWarning, stacklevel=3)
             self.k = self._K_MAX
 
@@ -1291,11 +1356,11 @@ def toms748(f, a, b, args=(), k=1,
         The number of Newton quadratic steps to perform each
         iteration. ``k>=1``.
     xtol : scalar, optional
-        The computed root ``x0`` will satisfy ``np.allclose(x, x0,
+        The computed root ``x0`` will satisfy ``np.isclose(x, x0,
         atol=xtol, rtol=rtol)``, where ``x`` is the exact root. The
         parameter must be positive.
     rtol : scalar, optional
-        The computed root ``x0`` will satisfy ``np.allclose(x, x0,
+        The computed root ``x0`` will satisfy ``np.isclose(x, x0,
         atol=xtol, rtol=rtol)``, where ``x`` is the exact root.
     maxiter : int, optional
         If convergence is not achieved in `maxiter` iterations, an error is
@@ -1321,6 +1386,7 @@ def toms748(f, a, b, args=(), k=1,
     --------
     brentq, brenth, ridder, bisect, newton
     fsolve : find roots in N dimensions.
+    elementwise.find_root : efficient elementwise 1-D root-finder
 
     Notes
     -----
@@ -1343,6 +1409,20 @@ def toms748(f, a, b, args=(), k=1,
     the kth root of ``(3k-2)``, hence ``k=1`` or ``k=2`` are
     usually appropriate.
 
+    As mentioned in the parameter documentation, the computed root ``x0`` will
+    satisfy ``np.isclose(x, x0, atol=xtol, rtol=rtol)``, where ``x`` is the
+    exact root. In equation form, this terminating condition is ``abs(x - x0)
+    <= xtol + rtol * abs(x0)``.
+
+    The default value ``xtol=2e-12`` may lead to surprising behavior if one
+    expects `toms748` to always compute roots with relative error near machine
+    precision. Care should be taken to select `xtol` for the use case at hand.
+    Setting ``xtol=5e-324``, the smallest subnormal number, will ensure the
+    highest level of accuracy. Larger values of `xtol` may be useful for saving
+    function evaluations when a root is at or near zero in applications where
+    the tiny absolute differences available between floating point numbers near
+    zero are not meaningful.
+
     References
     ----------
     .. [APS1995]

scipy/optimize/slsqp.py

@@ -9,7 +9,6 @@ __all__ = [  # noqa: F822
     'OptimizeResult',
     'fmin_slsqp',
     'slsqp',
-    'zeros',
 ]
 
 

scipy/optimize/tests/test__basinhopping.py

@@ -210,7 +210,7 @@ class TestBasinHopping:
                                niter=self.niter, disp=self.disp)
             assert_almost_equal(res.x, self.sol[i], self.tol)
 
-    @pytest.mark.fail_slow(20)
+    @pytest.mark.fail_slow(40)
     def test_all_nograd_minimizers(self):
         # Test 2-D minimizations without gradient. Newton-CG requires jac=True,
         # so not included here.

scipy/optimize/tests/test__differential_evolution.py

@@ -11,7 +11,7 @@ from scipy.optimize import differential_evolution, OptimizeResult
 from scipy.optimize._constraints import (Bounds, NonlinearConstraint,
                                          LinearConstraint)
 from scipy.optimize import rosen, minimize
-from scipy.sparse import csr_matrix
+from scipy.sparse import csr_array
 from scipy import stats
 
 import numpy as np
@@ -965,7 +965,7 @@ class TestDifferentialEvolutionSolver:
             violations.append(pc.violation(x))
         np.testing.assert_allclose(pc.violation(xs.T), np.array(violations).T)
 
-        pc = _ConstraintWrapper(LinearConstraint(csr_matrix(A), -np.inf, 0),
+        pc = _ConstraintWrapper(LinearConstraint(csr_array(A), -np.inf, 0),
                                 x0)
         assert (pc.violation(x0) > 0).any()
         assert (pc.violation([-10, 2, -10, 4]) == 0).all()
@@ -1070,10 +1070,10 @@ class TestDifferentialEvolutionSolver:
         assert_(np.all(res.x <= np.array(bounds)[:, 1]))
 
         # now repeat the same solve, using the same overall constraints,
-        # but using a sparse matrix for the LinearConstraint instead of an
+        # but using a sparse array for the LinearConstraint instead of an
         # array
 
-        L = LinearConstraint(csr_matrix(A), -np.inf, b)
+        L = LinearConstraint(csr_array(A), -np.inf, b)
 
         # using a lower popsize to speed the test up
         res = differential_evolution(

scipy/optimize/tests/test__linprog_clean_inputs.py

@@ -1,13 +1,15 @@
 """
 Unit test for Linear Programming via Simplex Algorithm.
 """
+from copy import deepcopy
+from datetime import date
+
 import numpy as np
 from numpy.testing import assert_, assert_allclose, assert_equal
+from numpy.exceptions import VisibleDeprecationWarning
 from pytest import raises as assert_raises
+
 from scipy.optimize._linprog_util import _clean_inputs, _LPProblem
-from scipy._lib._util import VisibleDeprecationWarning
-from copy import deepcopy
-from datetime import date
 
 
 def test_aliasing():

scipy/optimize/tests/test__numdiff.py

@@ -3,13 +3,16 @@ from itertools import product
 
 import numpy as np
 from numpy.testing import assert_allclose, assert_equal, assert_
+import pytest
 from pytest import raises as assert_raises
 
-from scipy.sparse import csr_matrix, csc_matrix, lil_matrix
+from scipy._lib._util import MapWrapper, _ScalarFunctionWrapper
+from scipy.sparse import csr_array, csc_array, lil_array
 
 from scipy.optimize._numdiff import (
     _adjust_scheme_to_bounds, approx_derivative, check_derivative,
     group_columns, _eps_for_method, _compute_absolute_step)
+from scipy.optimize import rosen
 
 
 def test_group_columns():
@@ -22,7 +25,7 @@ def test_group_columns():
         [0, 0, 0, 0, 1, 1],
         [0, 0, 0, 0, 0, 0]
     ]
-    for transform in [np.asarray, csr_matrix, csc_matrix, lil_matrix]:
+    for transform in [np.asarray, csr_array, csc_array, lil_array]:
         A = transform(structure)
         order = np.arange(6)
         groups_true = np.array([0, 1, 2, 0, 1, 2])
@@ -267,16 +270,52 @@ class TestApproxDerivativesDense:
 
     def test_scalar_vector(self):
         x0 = 0.5
-        jac_diff_2 = approx_derivative(self.fun_scalar_vector, x0,
-                                       method='2-point')
-        jac_diff_3 = approx_derivative(self.fun_scalar_vector, x0)
+        with MapWrapper(2) as mapper:
+            jac_diff_2 = approx_derivative(self.fun_scalar_vector, x0,
+                                           method='2-point', workers=mapper)
+        jac_diff_3 = approx_derivative(self.fun_scalar_vector, x0, workers=map)
         jac_diff_4 = approx_derivative(self.fun_scalar_vector, x0,
-                                       method='cs')
+                                       method='cs', workers=None)
         jac_true = self.jac_scalar_vector(np.atleast_1d(x0))
         assert_allclose(jac_diff_2, jac_true, rtol=1e-6)
         assert_allclose(jac_diff_3, jac_true, rtol=1e-9)
         assert_allclose(jac_diff_4, jac_true, rtol=1e-12)
 
+    @pytest.mark.fail_slow(5.0)
+    def test_workers_evaluations_and_nfev(self):
+        # check that nfev consumed by approx_derivative is tracked properly
+        # and that parallel evaluation is same as series
+        x0 = [0.5, 1.5, 2.0]
+        with MapWrapper(2) as mapper:
+            md2, mdct2 = approx_derivative(rosen, x0,
+                                           method='2-point', workers=mapper,
+                                           full_output=True)
+            md3, mdct3 = approx_derivative(rosen, x0,
+                                           workers=mapper, full_output=True)
+        # supply a number for workers. This is not normally recommended
+        # for upstream workers as setting up processes incurs a large overhead
+        md4, mdct4 = approx_derivative(rosen, x0,
+                                       method='cs', workers=2,
+                                       full_output=True)
+
+        sfr = _ScalarFunctionWrapper(rosen)
+        d2, dct2 = approx_derivative(sfr, x0, method='2-point', full_output=True)
+        assert_equal(dct2['nfev'], sfr.nfev)
+        sfr.nfev = 0
+        d3, dct3 = approx_derivative(sfr, x0, full_output=True)
+        assert_equal(dct3['nfev'], sfr.nfev)
+        sfr.nfev = 0
+        d4, dct4 = approx_derivative(sfr, x0, method='cs', full_output=True)
+        assert_equal(dct4['nfev'], sfr.nfev)
+
+        assert_equal(mdct2['nfev'], dct2['nfev'])
+        assert_equal(mdct3['nfev'], dct3['nfev'])
+        assert_equal(mdct4['nfev'], dct4['nfev'])
+        # also check that gradients are equivalent
+        assert_equal(md2, d2)
+        assert_equal(md3, d3)
+        assert_equal(md4, d4)
+
     def test_vector_scalar(self):
         x0 = np.array([100.0, -0.5])
         jac_diff_2 = approx_derivative(self.fun_vector_scalar, x0,
@@ -308,8 +347,9 @@ class TestApproxDerivativesDense:
         jac_diff_2 = approx_derivative(self.fun_vector_vector, x0,
                                        method='2-point')
         jac_diff_3 = approx_derivative(self.fun_vector_vector, x0)
-        jac_diff_4 = approx_derivative(self.fun_vector_vector, x0,
-                                       method='cs')
+        with MapWrapper(2) as mapper:
+            jac_diff_4 = approx_derivative(self.fun_vector_vector, x0,
+                                           method='cs', workers=mapper)
         jac_true = self.jac_vector_vector(x0)
         assert_allclose(jac_diff_2, jac_true, rtol=1e-5)
         assert_allclose(jac_diff_3, jac_true, rtol=1e-6)
@@ -569,6 +609,7 @@ class TestApproxDerivativeSparse:
 
         return A
 
+    @pytest.mark.fail_slow(5)
     def test_all(self):
         A = self.structure(self.n)
         order = np.arange(self.n)
@@ -576,19 +617,22 @@ class TestApproxDerivativeSparse:
         np.random.shuffle(order)
         groups_2 = group_columns(A, order)
 
-        for method, groups, l, u in product(
-                ['2-point', '3-point', 'cs'], [groups_1, groups_2],
-                [-np.inf, self.lb], [np.inf, self.ub]):
-            J = approx_derivative(self.fun, self.x0, method=method,
-                                  bounds=(l, u), sparsity=(A, groups))
-            assert_(isinstance(J, csr_matrix))
-            assert_allclose(J.toarray(), self.J_true, rtol=1e-6)
-
-            rel_step = np.full_like(self.x0, 1e-8)
-            rel_step[::2] *= -1
-            J = approx_derivative(self.fun, self.x0, method=method,
-                                  rel_step=rel_step, sparsity=(A, groups))
-            assert_allclose(J.toarray(), self.J_true, rtol=1e-5)
+        with MapWrapper(2) as mapper:
+            for method, groups, l, u, mf in product(
+                    ['2-point', '3-point', 'cs'], [groups_1, groups_2],
+                    [-np.inf, self.lb], [np.inf, self.ub], [map, mapper]):
+                J = approx_derivative(self.fun, self.x0, method=method,
+                                      bounds=(l, u), sparsity=(A, groups),
+                                      workers=mf)
+                assert_(isinstance(J, csr_array))
+                assert_allclose(J.toarray(), self.J_true, rtol=1e-6)
+
+                rel_step = np.full_like(self.x0, 1e-8)
+                rel_step[::2] *= -1
+                J = approx_derivative(self.fun, self.x0, method=method,
+                                      rel_step=rel_step, sparsity=(A, groups),
+                                      workers=mf)
+                assert_allclose(J.toarray(), self.J_true, rtol=1e-5)
 
     def test_no_precomputed_groups(self):
         A = self.structure(self.n)
@@ -607,7 +651,7 @@ class TestApproxDerivativeSparse:
 
     def test_check_derivative(self):
         def jac(x):
-            return csr_matrix(self.jac(x))
+            return csr_array(self.jac(x))
 
         accuracy = check_derivative(self.fun, jac, self.x0,
                                     bounds=(self.lb, self.ub))

scipy/optimize/tests/test__remove_redundancy.py

@@ -18,7 +18,7 @@ from scipy.optimize._remove_redundancy import _remove_redundancy_pivot_dense
 from scipy.optimize._remove_redundancy import _remove_redundancy_pivot_sparse
 from scipy.optimize._remove_redundancy import _remove_redundancy_id
 
-from scipy.sparse import csc_matrix
+from scipy.sparse import csc_array
 
 
 def setup_module():
@@ -223,6 +223,6 @@ class TestRRID(RRCommonTests):
 
 class TestRRPivotSparse(RRCommonTests):
     def rr(self, A, b):
-        rr_res = _remove_redundancy_pivot_sparse(csc_matrix(A), b)
+        rr_res = _remove_redundancy_pivot_sparse(csc_array(A), b)
         A1, b1, status, message = rr_res
         return A1.toarray(), b1, status, message

scipy/optimize/tests/test__shgo.py

@@ -26,7 +26,7 @@ class StructTestFunction:
 def wrap_constraints(g):
     cons = []
     if g is not None:
-        if not isinstance(g, (tuple, list)):
+        if not isinstance(g, tuple | list):
             g = (g,)
         else:
             pass
@@ -856,6 +856,14 @@ class TestShgoArguments:
         assert_allclose(res.fun, ref.fun)
         assert_allclose(res.x, ref.x, atol=1e-15)
 
+        # Testing the passing of jac via options dict
+        res = shgo(func, bounds=bounds, sampling_method="sobol",
+                   minimizer_kwargs={'method': 'SLSQP'},
+                   options={'jac': True})
+        assert res.success
+        assert_allclose(res.fun, ref.fun)
+        assert_allclose(res.x, ref.x, atol=1e-15)
+
     @pytest.mark.parametrize('derivative', ['jac', 'hess', 'hessp'])
     def test_21_2_derivative_options(self, derivative):
         """shgo used to raise an error when passing `options` with 'jac'