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

scipy/ndimage/tests/test_splines.py

@@ -6,10 +6,8 @@ from scipy._lib._array_api import assert_almost_equal
 
 from scipy import ndimage
 
-from scipy.conftest import array_api_compatible
 skip_xp_backends = pytest.mark.skip_xp_backends
-pytestmark = [array_api_compatible, pytest.mark.usefixtures("skip_xp_backends"),
-              skip_xp_backends(cpu_only=True, exceptions=['cupy', 'jax.numpy'],)]
+pytestmark = [skip_xp_backends(cpu_only=True, exceptions=['cupy', 'jax.numpy'])]
 
 
 def get_spline_knot_values(order):

scipy/optimize/_basinhopping.py

@@ -84,7 +84,7 @@ class BasinHoppingRunner:
         self.energy = minres.fun
         self.incumbent_minres = minres  # best minimize result found so far
         if self.disp:
-            print("basinhopping step %d: f %g" % (self.nstep, self.energy))
+            print(f"basinhopping step {self.nstep}: f {self.energy:g}")
 
         # initialize storage class
         self.storage = Storage(minres)
@@ -171,8 +171,10 @@ class BasinHoppingRunner:
         if self.disp:
             self.print_report(minres.fun, accept)
             if new_global_min:
-                print("found new global minimum on step %d with function"
-                      " value %g" % (self.nstep, self.energy))
+                print(
+                    f"found new global minimum on step {self.nstep} with "
+                    f"function value {self.energy:g}"
+                )
 
         # save some variables as BasinHoppingRunner attributes
         self.xtrial = minres.x
@@ -184,9 +186,11 @@ class BasinHoppingRunner:
     def print_report(self, energy_trial, accept):
         """print a status update"""
         minres = self.storage.get_lowest()
-        print("basinhopping step %d: f %g trial_f %g accepted %d "
-              " lowest_f %g" % (self.nstep, self.energy, energy_trial,
-                                accept, minres.fun))
+        print(
+            f"basinhopping step {self.nstep}: f {self.energy:g} "
+            f"trial_f {energy_trial:g} accepted {accept} "
+            f"lowest_f {minres.fun:g}"
+        )
 
 
 class AdaptiveStepsize:
@@ -451,7 +455,9 @@ def basinhopping(func, x0, niter=100, T=1.0, stepsize=0.5,
         cause of the termination. The ``OptimizeResult`` object returned by the
         selected minimizer at the lowest minimum is also contained within this
         object and can be accessed through the ``lowest_optimization_result``
-        attribute.  See `OptimizeResult` for a description of other attributes.
+        attribute. ``lowest_optimization_result`` will only be updated if a
+        local minimization was successful.          
+        See `OptimizeResult` for a description of other attributes.
 
     See Also
     --------

scipy/optimize/_bracket.py

@@ -1,7 +1,7 @@
 import numpy as np
 import scipy._lib._elementwise_iterative_method as eim
 from scipy._lib._util import _RichResult
-from scipy._lib._array_api import array_namespace, xp_ravel, xp_default_dtype
+from scipy._lib._array_api import array_namespace, xp_ravel, xp_promote
 
 _ELIMITS = -1  # used in _bracket_root
 _ESTOPONESIDE = 2  # used in _bracket_root
@@ -14,13 +14,7 @@ def _bracket_root_iv(func, xl0, xr0, xmin, xmax, factor, args, maxiter):
     if not np.iterable(args):
         args = (args,)
 
-    xp = array_namespace(xl0)
-    xl0 = xp.asarray(xl0)[()]
-    if (not xp.isdtype(xl0.dtype, "numeric")
-        or xp.isdtype(xl0.dtype, "complex floating")):
-        raise ValueError('`xl0` must be numeric and real.')
-    if not xp.isdtype(xl0.dtype, "real floating"):
-        xl0 = xp.asarray(xl0, dtype=xp_default_dtype(xp))
+    xp = array_namespace(xl0, xr0, xmin, xmax, factor, *args)
 
     # If xr0 is not supplied, fill with a dummy value for the sake of
     # broadcasting. We need to wait until xmax has been validated to
@@ -33,8 +27,11 @@ def _bracket_root_iv(func, xl0, xr0, xmin, xmax, factor, args, maxiter):
     xmin = -xp.inf if xmin is None else xmin
     xmax = xp.inf if xmax is None else xmax
     factor = 2. if factor is None else factor
-    xl0, xr0, xmin, xmax, factor = xp.broadcast_arrays(
-        xl0, xp.asarray(xr0), xp.asarray(xmin), xp.asarray(xmax), xp.asarray(factor))
+    xl0, xr0, xmin, xmax, factor = xp_promote(
+        xl0, xr0, xmin, xmax, factor, broadcast=True, force_floating=True, xp=xp)
+
+    if not xp.isdtype(xl0.dtype, ('integral', 'real floating')):
+        raise ValueError('`xl0` must be numeric and real.')
 
     if (not xp.isdtype(xr0.dtype, "numeric")
         or xp.isdtype(xr0.dtype, "complex floating")):
@@ -57,7 +54,7 @@ def _bracket_root_iv(func, xl0, xr0, xmin, xmax, factor, args, maxiter):
     # Calculate the default value of xr0 if a value has not been supplied.
     # Be careful to ensure xr0 is not larger than xmax.
     if xr0_not_supplied:
-        xr0 = xl0 + xp.minimum((xmax - xl0)/ 8, xp.asarray(1.0))
+        xr0 = xl0 + xp.minimum((xmax - xl0)/ 8, 1.0)
         xr0 = xp.astype(xr0, xl0.dtype, copy=False)
 
     maxiter = xp.asarray(maxiter)
@@ -425,13 +422,7 @@ def _bracket_minimum_iv(func, xm0, xl0, xr0, xmin, xmax, factor, args, maxiter):
     if not np.iterable(args):
         args = (args,)
 
-    xp = array_namespace(xm0)
-    xm0 = xp.asarray(xm0)[()]
-    if (not xp.isdtype(xm0.dtype, "numeric")
-        or xp.isdtype(xm0.dtype, "complex floating")):
-        raise ValueError('`xm0` must be numeric and real.')
-    if not xp.isdtype(xm0.dtype, "real floating"):
-        xm0 = xp.asarray(xm0, dtype=xp_default_dtype(xp))
+    xp = array_namespace(xm0, xl0, xr0, xmin, xmax, factor, *args)
 
     xmin = -xp.inf if xmin is None else xmin
     xmax = xp.inf if xmax is None else xmax
@@ -450,10 +441,12 @@ def _bracket_minimum_iv(func, xm0, xl0, xr0, xmin, xmax, factor, args, maxiter):
         xr0_not_supplied = True
 
     factor = 2.0 if factor is None else factor
-    xl0, xm0, xr0, xmin, xmax, factor = xp.broadcast_arrays(
-        xp.asarray(xl0), xm0, xp.asarray(xr0), xp.asarray(xmin),
-        xp.asarray(xmax), xp.asarray(factor)
-    )
+
+    xm0, xl0, xr0, xmin, xmax, factor = xp_promote(
+        xm0, xl0, xr0, xmin, xmax, factor, broadcast=True, force_floating=True, xp=xp)
+
+    if not xp.isdtype(xm0.dtype, ('integral', 'real floating')):
+        raise ValueError('`xm0` must be numeric and real.')
 
     if (not xp.isdtype(xl0.dtype, "numeric")
         or xp.isdtype(xl0.dtype, "complex floating")):
@@ -481,10 +474,10 @@ def _bracket_minimum_iv(func, xm0, xl0, xr0, xmin, xmax, factor, args, maxiter):
     # by the user. We need to be careful to ensure xl0 and xr0 are not outside
     # of (xmin, xmax).
     if xl0_not_supplied:
-        xl0 = xm0 - xp.minimum((xm0 - xmin)/16, xp.asarray(0.5))
+        xl0 = xm0 - xp.minimum((xm0 - xmin)/16, 0.5)
         xl0 = xp.astype(xl0, xm0.dtype, copy=False)
     if xr0_not_supplied:
-        xr0 = xm0 + xp.minimum((xmax - xm0)/16, xp.asarray(0.5))
+        xr0 = xm0 + xp.minimum((xmax - xm0)/16, 0.5)
         xr0 = xp.astype(xr0, xm0.dtype, copy=False)
 
     maxiter = xp.asarray(maxiter)

scipy/optimize/_chandrupatla.py

@@ -2,7 +2,7 @@ import math
 import numpy as np
 import scipy._lib._elementwise_iterative_method as eim
 from scipy._lib._util import _RichResult
-from scipy._lib._array_api import xp_sign, xp_copy, xp_take_along_axis
+from scipy._lib._array_api import xp_copy
 
 # TODO:
 # - (maybe?) don't use fancy indexing assignment
@@ -134,7 +134,7 @@ def _chandrupatla(func, a, b, *, args=(), xatol=None, xrtol=None,
     func, xs, fs, args, shape, dtype, xp = temp
     x1, x2 = xs
     f1, f2 = fs
-    status = xp.full_like(x1, xp.asarray(eim._EINPROGRESS),
+    status = xp.full_like(x1, eim._EINPROGRESS,
                           dtype=xp.int32)  # in progress
     nit, nfev = 0, 2  # two function evaluations performed above
     finfo = xp.finfo(dtype)
@@ -187,7 +187,7 @@ def _chandrupatla(func, a, b, *, args=(), xatol=None, xrtol=None,
 
         # If the bracket is no longer valid, report failure (unless a function
         # tolerance is met, as detected above).
-        i = (xp_sign(work.f1) == xp_sign(work.f2)) & ~stop
+        i = (xp.sign(work.f1) == xp.sign(work.f2)) & ~stop
         NaN = xp.asarray(xp.nan, dtype=work.xmin.dtype)
         work.xmin[i], work.fmin[i], work.status[i] = NaN, NaN, eim._ESIGNERR
         stop[i] = True
@@ -219,7 +219,7 @@ def _chandrupatla(func, a, b, *, args=(), xatol=None, xrtol=None,
         j = ((1 - xp.sqrt(1 - xi1)) < phi1) & (phi1 < xp.sqrt(xi1))
 
         f1j, f2j, f3j, alphaj = work.f1[j], work.f2[j], work.f3[j], alpha[j]
-        t = xp.full_like(alpha, xp.asarray(0.5))
+        t = xp.full_like(alpha, 0.5)
         t[j] = (f1j / (f1j - f2j) * f3j / (f3j - f2j)
                 - alphaj * f1j / (f3j - f1j) * f2j / (f2j - f3j))
 
@@ -401,8 +401,7 @@ def _chandrupatla_minimize(func, x1, x2, x3, *, args=(), xatol=None,
     x1, x2, x3 = xs
     f1, f2, f3 = fs
     phi = xp.asarray(0.5 + 0.5*5**0.5, dtype=dtype)[()]  # golden ratio
-    status = xp.full_like(x1, xp.asarray(eim._EINPROGRESS),
-                          dtype=xp.int32)  # in progress
+    status = xp.full_like(x1, eim._EINPROGRESS, dtype=xp.int32)  # in progress
     nit, nfev = 0, 3  # three function evaluations performed above
     fatol = xp.finfo(dtype).smallest_normal if fatol is None else fatol
     frtol = xp.finfo(dtype).smallest_normal if frtol is None else frtol
@@ -412,8 +411,8 @@ def _chandrupatla_minimize(func, x1, x2, x3, *, args=(), xatol=None,
     # Ensure that x1 < x2 < x3 initially.
     xs, fs = xp.stack((x1, x2, x3)), xp.stack((f1, f2, f3))
     i = xp.argsort(xs, axis=0)
-    x1, x2, x3 = xp_take_along_axis(xs, i, axis=0)  # data-apis/array-api#808
-    f1, f2, f3 = xp_take_along_axis(fs, i, axis=0)  # data-apis/array-api#808
+    x1, x2, x3 = xp.take_along_axis(xs, i, axis=0)  # data-apis/array-api#808
+    f1, f2, f3 = xp.take_along_axis(fs, i, axis=0)  # data-apis/array-api#808
     q0 = xp_copy(x3)  # "At the start, q0 is set at x3..." ([1] after (7))
 
     work = _RichResult(x1=x1, f1=f1, x2=x2, f2=f2, x3=x3, f3=f3, phi=phi,
@@ -449,7 +448,7 @@ def _chandrupatla_minimize(func, x1, x2, x3, *, args=(), xatol=None,
         # tol away from x2."
         # See also QBASIC code after "Accept Ql adjust if close to X2".
         j = xp.abs(q1[i] - work.x2[i]) <= work.xtol[i]
-        xi[j] = work.x2[i][j] + xp_sign(x32[i][j]) * work.xtol[i][j]
+        xi[j] = work.x2[i][j] + xp.sign(x32[i][j]) * work.xtol[i][j]
 
         # "If condition (7) is not satisfied, golden sectioning of the larger
         # interval is carried out to introduce the new point."
@@ -467,7 +466,7 @@ def _chandrupatla_minimize(func, x1, x2, x3, *, args=(), xatol=None,
         # point. In QBASIC code, see "IF SGN(X-X2) = SGN(X3-X2) THEN...".
         # There is an awful lot of data copying going on here; this would
         # probably benefit from code optimization or implementation in Pythran.
-        i = xp_sign(x - work.x2) == xp_sign(work.x3 - work.x2)
+        i = xp.sign(x - work.x2) == xp.sign(work.x3 - work.x2)
         xi, x1i, x2i, x3i = x[i], work.x1[i], work.x2[i], work.x3[i],
         fi, f1i, f2i, f3i = f[i], work.f1[i], work.f2[i], work.f3[i]
         j = fi > f2i

scipy/optimize/_cobyla_py.py

@@ -10,39 +10,24 @@ Functions
 
 """
 
-import functools
-from threading import RLock
+from inspect import signature
 
 import numpy as np
-from scipy.optimize import _cobyla as cobyla
 from ._optimize import (OptimizeResult, _check_unknown_options,
     _prepare_scalar_function)
-try:
-    from itertools import izip
-except ImportError:
-    izip = zip
+from ._constraints import NonlinearConstraint
+
 
 __all__ = ['fmin_cobyla']
 
-# Workaround as _cobyla.minimize is not threadsafe
-# due to an unknown f2py bug and can segfault,
-# see gh-9658.
-_module_lock = RLock()
-def synchronized(func):
-    @functools.wraps(func)
-    def wrapper(*args, **kwargs):
-        with _module_lock:
-            return func(*args, **kwargs)
-    return wrapper
-
-@synchronized
+
 def fmin_cobyla(func, x0, cons, args=(), consargs=None, rhobeg=1.0,
                 rhoend=1e-4, maxfun=1000, disp=None, catol=2e-4,
                 *, callback=None):
     """
     Minimize a function using the Constrained Optimization By Linear
-    Approximation (COBYLA) method. This method wraps a FORTRAN
-    implementation of the algorithm.
+    Approximation (COBYLA) method. This method uses the pure-python implementation
+    of the algorithm from PRIMA.
 
     Parameters
     ----------
@@ -113,6 +98,11 @@ def fmin_cobyla(func, x0, cons, args=(), consargs=None, rhobeg=1.0,
     how these issues are resolved, as well as how the points v_i are
     updated, refer to the source code or the references below.
 
+        .. versionchanged:: 1.16.0
+            The original Powell implementation was replaced by a pure
+            Python version from the PRIMA package, with bug fixes and
+            improvements being made.
+
 
     References
     ----------
@@ -127,6 +117,9 @@ def fmin_cobyla(func, x0, cons, args=(), consargs=None, rhobeg=1.0,
     Powell M.J.D. (2007), "A view of algorithms for optimization without
     derivatives", Cambridge University Technical Report DAMTP 2007/NA03
 
+    Zhang Z. (2023), "PRIMA: Reference Implementation for Powell's Methods with
+    Modernization and Amelioration", https://www.libprima.net,
+    :doi:`10.5281/zenodo.8052654`
 
     Examples
     --------
@@ -169,7 +162,12 @@ def fmin_cobyla(func, x0, cons, args=(), consargs=None, rhobeg=1.0,
         consargs = args
 
     # build constraints
-    con = tuple({'type': 'ineq', 'fun': c, 'args': consargs} for c in cons)
+    nlcs = []
+    for con in cons:
+        # Use default argument, otherwise the last `con` is captured by all wrapped_con
+        def wrapped_con(x, confunc=con):
+            return confunc(x, *consargs)
+        nlcs.append(NonlinearConstraint(wrapped_con, 0, np.inf))
 
     # options
     opts = {'rhobeg': rhobeg,
@@ -179,21 +177,21 @@ def fmin_cobyla(func, x0, cons, args=(), consargs=None, rhobeg=1.0,
             'catol': catol,
             'callback': callback}
 
-    sol = _minimize_cobyla(func, x0, args, constraints=con,
+    sol = _minimize_cobyla(func, x0, args, constraints=nlcs,
                            **opts)
     if disp and not sol['success']:
         print(f"COBYLA failed to find a solution: {sol.message}")
     return sol['x']
 
 
-@synchronized
 def _minimize_cobyla(fun, x0, args=(), constraints=(),
                      rhobeg=1.0, tol=1e-4, maxiter=1000,
-                     disp=False, catol=2e-4, callback=None, bounds=None,
-                     **unknown_options):
+                     disp=0, catol=None, f_target=-np.inf,
+                     callback=None, bounds=None, **unknown_options):
     """
     Minimize a scalar function of one or more variables using the
     Constrained Optimization BY Linear Approximation (COBYLA) algorithm.
+    This method uses the pure-python implementation of the algorithm from PRIMA.
 
     Options
     -------
@@ -202,74 +200,44 @@ def _minimize_cobyla(fun, x0, args=(), constraints=(),
     tol : float
         Final accuracy in the optimization (not precisely guaranteed).
         This is a lower bound on the size of the trust region.
-    disp : bool
-        Set to True to print convergence messages. If False,
-        `verbosity` is ignored as set to 0.
+    disp : int
+        Controls the frequency of output:
+            0. (default) There will be no printing
+            1. A message will be printed to the screen at the end of iteration, showing
+               the best vector of variables found and its objective function value
+            2. in addition to 1, each new value of RHO is printed to the screen,
+               with the best vector of variables so far and its objective function
+               value.
+            3. in addition to 2, each function evaluation with its variables will
+               be printed to the screen.
     maxiter : int
         Maximum number of function evaluations.
     catol : float
         Tolerance (absolute) for constraint violations
+    f_target : float
+        Stop if the objective function is less than `f_target`.
+
+        .. versionchanged:: 1.16.0
+            The original Powell implementation was replaced by a pure
+            Python version from the PRIMA package, with bug fixes and
+            improvements being made.
 
+
+    References
+    ----------
+    Zhang Z. (2023), "PRIMA: Reference Implementation for Powell's Methods with
+    Modernization and Amelioration", https://www.libprima.net,
+    :doi:`10.5281/zenodo.8052654`
     """
+    from .._lib.pyprima import minimize
+    from .._lib.pyprima.common.infos import SMALL_TR_RADIUS, FTARGET_ACHIEVED
+    from .._lib.pyprima.common.message import get_info_string
     _check_unknown_options(unknown_options)
-    maxfun = maxiter
     rhoend = tol
-    iprint = int(bool(disp))
-
-    # check constraints
-    if isinstance(constraints, dict):
-        constraints = (constraints, )
-
-    if bounds:
-        i_lb = np.isfinite(bounds.lb)
-        if np.any(i_lb):
-            def lb_constraint(x, *args, **kwargs):
-                return x[i_lb] - bounds.lb[i_lb]
-
-            constraints.append({'type': 'ineq', 'fun': lb_constraint})
-
-        i_ub = np.isfinite(bounds.ub)
-        if np.any(i_ub):
-            def ub_constraint(x):
-                return bounds.ub[i_ub] - x[i_ub]
-
-            constraints.append({'type': 'ineq', 'fun': ub_constraint})
-
-    for ic, con in enumerate(constraints):
-        # check type
-        try:
-            ctype = con['type'].lower()
-        except KeyError as e:
-            raise KeyError('Constraint %d has no type defined.' % ic) from e
-        except TypeError as e:
-            raise TypeError('Constraints must be defined using a '
-                            'dictionary.') from e
-        except AttributeError as e:
-            raise TypeError("Constraint's type must be a string.") from e
-        else:
-            if ctype != 'ineq':
-                raise ValueError(f"Constraints of type '{con['type']}' not handled by "
-                                 "COBYLA.")
-
-        # check function
-        if 'fun' not in con:
-            raise KeyError('Constraint %d has no function defined.' % ic)
-
-        # check extra arguments
-        if 'args' not in con:
-            con['args'] = ()
-
-    # m is the total number of constraint values
-    # it takes into account that some constraints may be vector-valued
-    cons_lengths = []
-    for c in constraints:
-        f = c['fun'](x0, *c['args'])
-        try:
-            cons_length = len(f)
-        except TypeError:
-            cons_length = 1
-        cons_lengths.append(cons_length)
-    m = sum(cons_lengths)
+    iprint = disp if disp is not None else 0
+    if iprint != 0 and iprint != 1 and iprint != 2 and iprint != 3:
+        raise ValueError(f'disp argument to minimize must be 0, 1, 2, or 3,\
+                          received {iprint}')
 
     # create the ScalarFunction, cobyla doesn't require derivative function
     def _jac(x, *args):
@@ -277,40 +245,53 @@ def _minimize_cobyla(fun, x0, args=(), constraints=(),
 
     sf = _prepare_scalar_function(fun, x0, args=args, jac=_jac)
 
-    def calcfc(x, con):
-        f = sf.fun(x)
-        i = 0
-        for size, c in izip(cons_lengths, constraints):
-            con[i: i + size] = c['fun'](x, *c['args'])
-            i += size
-        return f
-
-    def wrapped_callback(x):
-        if callback is not None:
-            callback(np.copy(x))
-
-    info = np.zeros(4, np.float64)
-    xopt, info = cobyla.minimize(calcfc, m=m, x=np.copy(x0), rhobeg=rhobeg,
-                                  rhoend=rhoend, iprint=iprint, maxfun=maxfun,
-                                  dinfo=info, callback=wrapped_callback)
-
-    if info[3] > catol:
-        # Check constraint violation
-        info[0] = 4
-
-    return OptimizeResult(x=xopt,
-                          status=int(info[0]),
-                          success=info[0] == 1,
-                          message={1: 'Optimization terminated successfully.',
-                                   2: 'Maximum number of function evaluations '
-                                      'has been exceeded.',
-                                   3: 'Rounding errors are becoming damaging '
-                                      'in COBYLA subroutine.',
-                                   4: 'Did not converge to a solution '
-                                      'satisfying the constraints. See '
-                                      '`maxcv` for magnitude of violation.',
-                                   5: 'NaN result encountered.'
-                                   }.get(info[0], 'Unknown exit status.'),
-                          nfev=int(info[1]),
-                          fun=info[2],
-                          maxcv=info[3])
+    if callback is not None:
+        sig = signature(callback)
+        if set(sig.parameters) == {"intermediate_result"}:
+            def wrapped_callback_intermediate(x, f, nf, tr, cstrv, nlconstrlist):
+                intermediate_result = OptimizeResult(x=np.copy(x), fun=f, nfev=nf,
+                                                     nit=tr, maxcv=cstrv)
+                callback(intermediate_result=intermediate_result)
+        else:
+            def wrapped_callback_intermediate(x, f, nf, tr, cstrv, nlconstrlist):
+                callback(np.copy(x))
+        def wrapped_callback(x, f, nf, tr, cstrv, nlconstrlist):
+            try:
+                wrapped_callback_intermediate(x, f, nf, tr, cstrv, nlconstrlist)
+                return False
+            except StopIteration:
+                return True
+    else:
+        wrapped_callback = None
+
+
+    ctol = catol if catol is not None else np.sqrt(np.finfo(float).eps)
+    options = {
+        'rhobeg': rhobeg,
+        'rhoend': rhoend,
+        'maxfev': maxiter,
+        'iprint': iprint,
+        'ctol': ctol,
+        'ftarget': f_target,
+    }
+
+    result = minimize(sf.fun, x0, method='cobyla', bounds=bounds,
+                      constraints=constraints, callback=wrapped_callback,
+                      options=options)
+
+
+    if result.cstrv > ctol:
+        success = False
+        message = ('Did not converge to a solution satisfying the constraints. See '
+                  '`maxcv` for the magnitude of the violation.')
+    else:
+        success = result.info == SMALL_TR_RADIUS or result.info == FTARGET_ACHIEVED
+        message = get_info_string('COBYLA', result.info)
+
+    return OptimizeResult(x=result.x,
+                          status=result.info,
+                          success=success,
+                          message=message,
+                          nfev=result.nf,
+                          fun=result.f,
+                          maxcv=result.cstrv)

scipy/optimize/_constraints.py

@@ -1,11 +1,15 @@
 """Constraints definition for minimize."""
+from warnings import warn, catch_warnings, simplefilter, filterwarnings
+
 import numpy as np
-from ._hessian_update_strategy import BFGS
+
 from ._differentiable_functions import (
-    VectorFunction, LinearVectorFunction, IdentityVectorFunction)
+    VectorFunction, LinearVectorFunction, IdentityVectorFunction
+)
+from ._hessian_update_strategy import BFGS
 from ._optimize import OptimizeWarning
-from warnings import warn, catch_warnings, simplefilter, filterwarnings
-from scipy.sparse import issparse
+
+from scipy._lib._sparse import issparse
 
 
 def _arr_to_scalar(x):
@@ -48,7 +52,7 @@ class NonlinearConstraint:
         'cs'} select a finite difference scheme for the numerical estimation.
         A callable must have the following signature::
 
-            jac(x) -> {ndarray, sparse matrix}, shape (m, n)
+            jac(x) -> {ndarray, sparse array}, shape (m, n)
 
         Default is '2-point'.
     hess : {callable, '2-point', '3-point', 'cs', HessianUpdateStrategy, None}, optional
@@ -63,7 +67,7 @@ class NonlinearConstraint:
 
         A callable must return the Hessian matrix of ``dot(fun, v)`` and
         must have the following signature:
-        ``hess(x, v) -> {LinearOperator, sparse matrix, array_like}, shape (n, n)``.
+        ``hess(x, v) -> {LinearOperator, sparse array, array_like}, shape (n, n)``.
         Here ``v`` is ndarray with shape (m,) containing Lagrange multipliers.
     keep_feasible : array_like of bool, optional
         Whether to keep the constraint components feasible throughout
@@ -73,7 +77,7 @@ class NonlinearConstraint:
         Relative step size for the finite difference approximation. Default is
         None, which will select a reasonable value automatically depending
         on a finite difference scheme.
-    finite_diff_jac_sparsity: {None, array_like, sparse matrix}, optional
+    finite_diff_jac_sparsity: {None, array_like, sparse array}, optional
         Defines the sparsity structure of the Jacobian matrix for finite
         difference estimation, its shape must be (m, n). If the Jacobian has
         only few non-zero elements in *each* row, providing the sparsity
@@ -135,7 +139,7 @@ class LinearConstraint:
 
     Parameters
     ----------
-    A : {array_like, sparse matrix}, shape (m, n)
+    A : {array_like, sparse array}, shape (m, n)
         Matrix defining the constraint.
     lb, ub : dense array_like, optional
         Lower and upper limits on the constraint. Each array must have the
@@ -559,7 +563,7 @@ def old_constraint_to_new(ic, con):
     try:
         ctype = con['type'].lower()
     except KeyError as e:
-        raise KeyError('Constraint %d has no type defined.' % ic) from e
+        raise KeyError(f'Constraint {ic} has no type defined.') from e
     except TypeError as e:
         raise TypeError(
             'Constraints must be a sequence of dictionaries.'
@@ -570,7 +574,7 @@ def old_constraint_to_new(ic, con):
         if ctype not in ['eq', 'ineq']:
             raise ValueError(f"Unknown constraint type '{con['type']}'.")
     if 'fun' not in con:
-        raise ValueError('Constraint %d has no function defined.' % ic)
+        raise ValueError(f'Constraint {ic} has no function defined.')
 
     lb = 0
     if ctype == 'eq':