scipy 1.15.3__cp313-cp313t-macosx_14_0_arm64.whl → 1.16.0rc2__cp313-cp313t-macosx_14_0_arm64.whl

scipy/optimize/_slsqp_py.py

@@ -16,9 +16,8 @@ Functions
 __all__ = ['approx_jacobian', 'fmin_slsqp']
 
 import numpy as np
-from scipy.optimize._slsqp import slsqp
-from numpy import (zeros, array, linalg, append, concatenate, finfo,
-                   sqrt, vstack, isfinite, atleast_1d)
+from ._slsqplib import slsqp
+from scipy.linalg import norm as lanorm
 from ._optimize import (OptimizeResult, _check_unknown_options,
                         _prepare_scalar_function, _clip_x_for_func,
                         _check_clip_x)
@@ -26,11 +25,11 @@ from ._numdiff import approx_derivative
 from ._constraints import old_bound_to_new, _arr_to_scalar
 from scipy._lib._array_api import array_namespace
 from scipy._lib import array_api_extra as xpx
-
+from numpy.typing import NDArray
 
 __docformat__ = "restructuredtext en"
 
-_epsilon = sqrt(finfo(float).eps)
+_epsilon = np.sqrt(np.finfo(np.float64).eps)
 
 
 def approx_jacobian(x, func, epsilon, *args):
@@ -217,15 +216,19 @@ def _minimize_slsqp(func, x0, args=(), jac=None, bounds=None,
                     constraints=(),
                     maxiter=100, ftol=1.0E-6, iprint=1, disp=False,
                     eps=_epsilon, callback=None, finite_diff_rel_step=None,
-                    **unknown_options):
+                    workers=None, **unknown_options):
     """
     Minimize a scalar function of one or more variables using Sequential
     Least Squares Programming (SLSQP).
 
-    Options
-    -------
+    Parameters
+    ----------
     ftol : float
-        Precision goal for the value of f in the stopping criterion.
+        Precision target for the value of f in the stopping criterion. This value
+        controls the final accuracy for checking various optimality conditions;
+        gradient of the lagrangian and absolute sum of the constraint violations
+        should be lower than ``ftol``. Similarly, computed step size and the
+        objective function changes are checked against this value. Default is 1e-6.
     eps : float
         Step size used for numerical approximation of the Jacobian.
     disp : bool
@@ -240,9 +243,55 @@ def _minimize_slsqp(func, x0, args=(), jac=None, bounds=None,
         possibly adjusted to fit into the bounds. For ``method='3-point'``
         the sign of `h` is ignored. If None (default) then step is selected
         automatically.
+    workers : int, map-like callable, optional
+        A map-like callable, such as `multiprocessing.Pool.map` for evaluating
+        any numerical differentiation in parallel.
+        This evaluation is carried out as ``workers(fun, iterable)``.
+
+        .. versionadded:: 1.16.0
+
+    Returns
+    -------
+    res : OptimizeResult
+        The optimization result represented as an `OptimizeResult` object.
+        In this dict-like object the following fields are of particular importance:
+        ``x`` the solution array, ``success`` a Boolean flag indicating if the
+        optimizer exited successfully, ``message`` which describes the reason for
+        termination, and ``multipliers`` which contains the Karush-Kuhn-Tucker
+        (KKT) multipliers for the QP approximation used in solving the original
+        nonlinear problem. See ``Notes`` below. See also `OptimizeResult` for a
+        description of other attributes.
+
+    Notes
+    -----
+    The KKT multipliers are returned in the ``OptimizeResult.multipliers``
+    attribute as a NumPy array. Denoting the dimension of the equality constraints
+    with ``meq``, and of inequality constraints with ``mineq``, then the returned
+    array slice ``m[:meq]`` contains the multipliers for the equality constraints,
+    and the remaining ``m[meq:meq + mineq]`` contains the multipliers for the 
+    inequality constraints. The multipliers corresponding to bound inequalities 
+    are not returned. See [1]_ pp. 321 or [2]_ for an explanation of how to interpret
+    these multipliers. The internal QP problem is solved using the methods given
+    in [3]_ Chapter 25.
+
+    Note that if new-style `NonlinearConstraint` or `LinearConstraint` were
+    used, then ``minimize`` converts them first to old-style constraint dicts.
+    It is possible for a single new-style constraint to simultaneously contain
+    both inequality and equality constraints. This means that if there is mixing
+    within a single constraint, then the returned list of multipliers will have
+    a different length than the original new-style constraints.
+
+    References
+    ----------
+    .. [1] Nocedal, J., and S J Wright, 2006, "Numerical Optimization", Springer,
+       New York.
+    .. [2] Kraft, D., "A software package for sequential quadratic programming",
+       1988, Tech. Rep. DFVLR-FB 88-28, DLR German Aerospace Center, Germany.
+    .. [3] Lawson, C. L., and R. J. Hanson, 1995, "Solving Least Squares Problems",
+       SIAM, Philadelphia, PA.
+
     """
     _check_unknown_options(unknown_options)
-    iter = maxiter - 1
     acc = ftol
     epsilon = eps
 
@@ -277,7 +326,7 @@ def _minimize_slsqp(func, x0, args=(), jac=None, bounds=None,
         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 defined using a '
                             'dictionary.') from e
@@ -289,7 +338,7 @@ def _minimize_slsqp(func, x0, args=(), jac=None, bounds=None,
 
         # check function
         if 'fun' not in con:
-            raise ValueError('Constraint %d has no function defined.' % ic)
+            raise ValueError(f'Constraint {ic} has no function defined.')
 
         # check Jacobian
         cjac = con.get('jac')
@@ -331,26 +380,15 @@ def _minimize_slsqp(func, x0, args=(), jac=None, bounds=None,
 
     # Set the parameters that SLSQP will need
     # meq, mieq: number of equality and inequality constraints
-    meq = sum(map(len, [atleast_1d(c['fun'](x, *c['args']))
+    meq = sum(map(len, [np.atleast_1d(c['fun'](x, *c['args']))
               for c in cons['eq']]))
-    mieq = sum(map(len, [atleast_1d(c['fun'](x, *c['args']))
+    mieq = sum(map(len, [np.atleast_1d(c['fun'](x, *c['args']))
                for c in cons['ineq']]))
     # m = The total number of constraints
     m = meq + mieq
-    # la = The number of constraints, or 1 if there are no constraints
-    la = array([1, m]).max()
     # n = The number of independent variables
     n = len(x)
 
-    # Define the workspaces for SLSQP
-    n1 = n + 1
-    mineq = m - meq + n1 + n1
-    len_w = (3*n1+m)*(n1+1)+(n1-meq+1)*(mineq+2) + 2*mineq+(n1+mineq)*(n1-meq) \
-            + 2*meq + n1 + ((n+1)*n)//2 + 2*m + 3*n + 3*n1 + 1
-    len_jw = mineq
-    w = zeros(len_w)
-    jw = zeros(len_jw)
-
     # Decompose bounds into xl and xu
     if bounds is None or len(bounds) == 0:
         xl = np.empty(n, dtype=float)
@@ -358,8 +396,8 @@ def _minimize_slsqp(func, x0, args=(), jac=None, bounds=None,
         xl.fill(np.nan)
         xu.fill(np.nan)
     else:
-        bnds = array([(_arr_to_scalar(l), _arr_to_scalar(u))
-                      for (l, u) in bounds], float)
+        bnds = np.array([(_arr_to_scalar(lo), _arr_to_scalar(up))
+                      for (lo, up) in bounds], float)
         if bnds.shape[0] != n:
             raise IndexError('SLSQP Error: the length of bounds is not '
                              'compatible with that of x0.')
@@ -370,142 +408,196 @@ def _minimize_slsqp(func, x0, args=(), jac=None, bounds=None,
         if bnderr.any():
             raise ValueError("SLSQP Error: lb > ub in bounds "
                              f"{', '.join(str(b) for b in bnderr)}.")
-        xl, xu = bnds[:, 0], bnds[:, 1]
+        xl, xu = bnds[:, 0].copy(), bnds[:, 1].copy()
 
-        # Mark infinite bounds with nans; the Fortran code understands this
-        infbnd = ~isfinite(bnds)
+        # Mark infinite bounds with nans; the C code expects this
+        infbnd = ~np.isfinite(bnds)
         xl[infbnd[:, 0]] = np.nan
         xu[infbnd[:, 1]] = np.nan
 
     # ScalarFunction provides function and gradient evaluation
     sf = _prepare_scalar_function(func, x, jac=jac, args=args, epsilon=eps,
                                   finite_diff_rel_step=finite_diff_rel_step,
-                                  bounds=new_bounds)
+                                  bounds=new_bounds, workers=workers)
     # gh11403 SLSQP sometimes exceeds bounds by 1 or 2 ULP, make sure this
     # doesn't get sent to the func/grad evaluator.
     wrapped_fun = _clip_x_for_func(sf.fun, new_bounds)
     wrapped_grad = _clip_x_for_func(sf.grad, new_bounds)
 
-    # Initialize the iteration counter and the mode value
-    mode = array(0, int)
-    acc = array(acc, float)
-    majiter = array(iter, int)
-    majiter_prev = 0
-
-    # Initialize internal SLSQP state variables
-    alpha = array(0, float)
-    f0 = array(0, float)
-    gs = array(0, float)
-    h1 = array(0, float)
-    h2 = array(0, float)
-    h3 = array(0, float)
-    h4 = array(0, float)
-    t = array(0, float)
-    t0 = array(0, float)
-    tol = array(0, float)
-    iexact = array(0, int)
-    incons = array(0, int)
-    ireset = array(0, int)
-    itermx = array(0, int)
-    line = array(0, int)
-    n1 = array(0, int)
-    n2 = array(0, int)
-    n3 = array(0, int)
+    # Initialize internal SLSQP state variables dictionary
+    # This dictionary is passed to the SLSQP matching the C struct defined as
+    #
+    # struct SLSQP_static_vars {
+    #     double acc, alpha, f0, gs, h1, h2, h3, h4, t, t0, tol;
+    #     int exact, inconsistent, reset, iter, itermax, line, mode, meq;
+    # };
+    #
+    # exact : a dummy variable and should be kept 0 since the underlying code
+    #         always uses an inexact search.
+    # inconsistent: a boolean set to 1 if the linearized QP is not well-defined
+    #               while the original nonlinear problem is still solvable. Then
+    #               the problem is augmented with a regularizing dummy variable.
+    # reset: holds the count of resetting bfgs to identity matrix.
+    # iter  : the current and itermax is the maximum number of iterations.
+    # line  : the current line search iteration.
+    # mode  : the exit mode of the solver.
+    # alpha, f0, gs, h1, h2, h3, h4, t, t0 : internal variables used by the solver.
+    #
+    # The dict holds the intermediate state of the solver. The keys are the same
+    # as the C struct members and will be modified in-place.
+    state_dict = {
+        "acc": acc,
+        "alpha": 0.0,
+        "f0": 0.0,
+        "gs": 0.0,
+        "h1": 0.0,
+        "h2": 0.0,
+        "h3": 0.0,
+        "h4": 0.0,
+        "t": 0.0,
+        "t0": 0.0,
+        "tol": 10.0*acc,
+        "exact": 0,
+        "inconsistent": 0,
+        "reset": 0,
+        "iter": 0,
+        "itermax": maxiter,
+        "line": 0,
+        "m": m,
+        "meq": meq,
+        "mode": 0,
+        "n": n
+    }
 
     # Print the header if iprint >= 2
     if iprint >= 2:
-        print("%5s %5s %16s %16s" % ("NIT", "FC", "OBJFUN", "GNORM"))
+        print(f"{'NIT':>5} {'FC':>5} {'OBJFUN':>16} {'GNORM':>16}")
+
+    # Internal buffer and int array
+    indices = np.zeros([max(m + 2*n + 2, 1)], dtype=np.int32)
+
+    # The worst case workspace requirements for the buffer are:
+
+    # n*(n+1)//2 + m + 4*n + 3                                           # SLSQP
+    # (n+1)*(n+2) + (n+1)*meq + m + (mineq + 2*n + 2)*(n+1) +  3*n + 3   # LSQ
+    # mineq + 2n + 2 + 2*meq + (n+1) + (mineq + 3n + 3)*(n + 1 - meq)    # LSEI
+    # (mineq + 2n + 2 + 2)*(n + 2) + mineq + 2n + 2                      # LDP
+    # mineq + 2n + 2                                                     # NNLS
+
+    # If we sum all up and simplify by the help of sympy we get the following
+    buffer_size = (
+        n*(n+1)//2 + 3*m*n - (m + 5*n + 7)*meq + 9*m + 8*n*n + 35*n + meq*meq + 28
+    )
+    # If no inequality constraints are given, top up workspace for the missing
+    # terms.
+    if mieq == 0:
+        buffer_size += 2*n*(n + 1)
+    buffer = np.zeros(max(buffer_size, 1), dtype=np.float64)
 
     # mode is zero on entry, so call objective, constraints and gradients
     # there should be no func evaluations here because it's cached from
     # ScalarFunction
     fx = wrapped_fun(x)
-    g = append(wrapped_grad(x), 0.0)
-    c = _eval_constraint(x, cons)
-    a = _eval_con_normals(x, cons, la, n, m, meq, mieq)
+    g = wrapped_grad(x)
+
+    # Allocate the multiplier array both for constraints and user specified
+    # bounds (extra +2 is for a possible augmented problem).
+    mult = np.zeros([max(1, m + 2*n + 2)], dtype=np.float64)
+
+    # Allocate the constraints and normals once and repopulate as needed
+    C = np.zeros([max(1, m), n], dtype=np.float64, order='F')
+    d = np.zeros([max(1, m)], dtype=np.float64)
+    _eval_con_normals(C, x, cons, m, meq)
+    _eval_constraint(d, x, cons, m, meq)
+
+    iter_prev = 0
 
-    while 1:
+    while True:
         # Call SLSQP
-        slsqp(m, meq, x, xl, xu, fx, c, g, a, acc, majiter, mode, w, jw,
-              alpha, f0, gs, h1, h2, h3, h4, t, t0, tol,
-              iexact, incons, ireset, itermx, line,
-              n1, n2, n3)
+        slsqp(state_dict, fx, g, C, d, x, mult, xl, xu, buffer, indices)
 
-        if mode == 1:  # objective and constraint evaluation required
-            fx = wrapped_fun(x)
-            c = _eval_constraint(x, cons)
+        if state_dict['mode'] == 1:  # objective and constraint evaluation required
+            fx = sf.fun(x)
+            _eval_constraint(d, x, cons, m, meq)
 
-        if mode == -1:  # gradient evaluation required
-            g = append(wrapped_grad(x), 0.0)
-            a = _eval_con_normals(x, cons, la, n, m, meq, mieq)
+        if state_dict['mode'] == -1:  # gradient evaluation required
+            g = sf.grad(x)
+            _eval_con_normals(C, x, cons, m, meq)
 
-        if majiter > majiter_prev:
+        if state_dict['iter'] > iter_prev:
             # call callback if major iteration has incremented
             if callback is not None:
                 callback(np.copy(x))
 
             # Print the status of the current iterate if iprint > 2
             if iprint >= 2:
-                print("%5i %5i % 16.6E % 16.6E" % (majiter, sf.nfev,
-                                                   fx, linalg.norm(g)))
+                print(f"{state_dict['iter']:5d} {sf.nfev:5d} "
+                      f"{fx:16.6E} {lanorm(g):16.6E}")
 
         # If exit mode is not -1 or 1, slsqp has completed
-        if abs(mode) != 1:
+        if abs(state_dict['mode']) != 1:
             break
 
-        majiter_prev = int(majiter)
+        iter_prev = state_dict['iter']
 
     # Optimization loop complete. Print status if requested
     if iprint >= 1:
-        print(exit_modes[int(mode)] + "    (Exit mode " + str(mode) + ')')
+        print(
+            exit_modes[state_dict['mode']] + f"    (Exit mode {state_dict['mode']})"
+        )
         print("            Current function value:", fx)
-        print("            Iterations:", majiter)
+        print("            Iterations:", state_dict['iter'])
         print("            Function evaluations:", sf.nfev)
         print("            Gradient evaluations:", sf.ngev)
 
-    return OptimizeResult(x=x, fun=fx, jac=g[:-1], nit=int(majiter),
-                          nfev=sf.nfev, njev=sf.ngev, status=int(mode),
-                          message=exit_modes[int(mode)], success=(mode == 0))
-
-
-def _eval_constraint(x, cons):
-    # Compute constraints
-    if cons['eq']:
-        c_eq = concatenate([atleast_1d(con['fun'](x, *con['args']))
-                            for con in cons['eq']])
-    else:
-        c_eq = zeros(0)
-
-    if cons['ineq']:
-        c_ieq = concatenate([atleast_1d(con['fun'](x, *con['args']))
-                             for con in cons['ineq']])
-    else:
-        c_ieq = zeros(0)
-
-    # Now combine c_eq and c_ieq into a single matrix
-    c = concatenate((c_eq, c_ieq))
-    return c
-
-
-def _eval_con_normals(x, cons, la, n, m, meq, mieq):
-    # Compute the normals of the constraints
-    if cons['eq']:
-        a_eq = vstack([con['jac'](x, *con['args'])
-                       for con in cons['eq']])
-    else:  # no equality constraint
-        a_eq = zeros((meq, n))
-
-    if cons['ineq']:
-        a_ieq = vstack([con['jac'](x, *con['args'])
-                        for con in cons['ineq']])
-    else:  # no inequality constraint
-        a_ieq = zeros((mieq, n))
-
-    # Now combine a_eq and a_ieq into a single a matrix
-    if m == 0:  # no constraints
-        a = zeros((la, n))
-    else:
-        a = vstack((a_eq, a_ieq))
-    a = concatenate((a, zeros([la, 1])), 1)
-
-    return a
+    return OptimizeResult(
+        x=x, fun=fx, jac=g, nit=state_dict['iter'], nfev=sf.nfev, njev=sf.ngev,
+        status=state_dict['mode'], message=exit_modes[state_dict['mode']],
+        success=(state_dict['mode'] == 0), multipliers=mult[:m]
+    )
+
+# The following functions modify their first input argument in-place.
+def _eval_constraint(d: NDArray, x: NDArray, cons: dict, m: int, meq: int):
+    if m == 0:
+        return
+
+    # The reason why we don't use regular increments with a sane for loop is that
+    # the constraint evaluations do not necessarily return scalars. Their
+    # output length needs to be taken into account while placing them in d.
+
+    if meq > 0:
+        row = 0
+        for con in cons['eq']:
+            temp = np.atleast_1d(con['fun'](x, *con['args'])).ravel()
+            d[row:row + len(temp)] = temp
+            row += len(temp)
+
+    if m > meq:
+        row = meq
+        for con in cons['ineq']:
+            temp = np.atleast_1d(con['fun'](x, *con['args'])).ravel()
+            d[row:row + len(temp)] = temp
+            row += len(temp)
+
+    return
+
+
+def _eval_con_normals(C: NDArray, x: NDArray, cons: dict, m: int, meq: int):
+    if m == 0:
+        return
+
+    if meq > 0:
+        row = 0
+        for con in cons['eq']:
+            temp = np.atleast_2d(con['jac'](x, *con['args']))
+            C[row:row + temp.shape[0], :] = temp
+            row += temp.shape[0]
+
+    if m > meq:
+        row = meq
+        for con in cons['ineq']:
+            temp = np.atleast_2d(con['jac'](x, *con['args']))
+            C[row:row + temp.shape[0], :] = temp
+            row += temp.shape[0]
+
+    return

scipy/optimize/_spectral.py

@@ -107,7 +107,7 @@ def _root_df_sane(func, x0, args=(), ftol=1e-8, fatol=1e-300, maxfev=1000,
         F_k_norm = fnorm(F_k)
 
         if disp:
-            print("iter %d: ||F|| = %g, sigma = %g" % (k, F_k_norm, sigma_k))
+            print(f"iter {k}: ||F|| = {F_k_norm:g}, sigma = {sigma_k:g}")
 
         if callback is not None:
             callback(x_k, F_k)

scipy/optimize/_tnc.py

@@ -287,6 +287,7 @@ def _minimize_tnc(fun, x0, args=(), jac=None, bounds=None,
                   maxCGit=-1, eta=-1, stepmx=0, accuracy=0,
                   minfev=0, ftol=-1, xtol=-1, gtol=-1, rescale=-1, disp=False,
                   callback=None, finite_diff_rel_step=None, maxfun=None,
+                  workers=None,
                   **unknown_options):
     """
     Minimize a scalar function of one or more variables using a truncated
@@ -351,6 +352,12 @@ def _minimize_tnc(fun, x0, args=(), jac=None, bounds=None,
     maxfun : int
         Maximum number of function evaluations. If None, `maxfun` is
         set to max(100, 10*len(x0)). Defaults to None.
+    workers : int, map-like callable, optional
+        A map-like callable, such as `multiprocessing.Pool.map` for evaluating
+        any numerical differentiation in parallel.
+        This evaluation is carried out as ``workers(fun, iterable)``.
+
+        .. versionadded:: 1.16.0
     """
     _check_unknown_options(unknown_options)
     fmin = minfev
@@ -381,7 +388,7 @@ def _minimize_tnc(fun, x0, args=(), jac=None, bounds=None,
 
     sf = _prepare_scalar_function(fun, x0, jac=jac, args=args, epsilon=eps,
                                   finite_diff_rel_step=finite_diff_rel_step,
-                                  bounds=new_bounds)
+                                  bounds=new_bounds, workers=workers)
     func_and_grad = sf.fun_and_grad
 
     """

scipy/optimize/_trustregion.py

@@ -119,7 +119,8 @@ def _minimize_trust_region(fun, x0, args=(), jac=None, hess=None, hessp=None,
                            subproblem=None, initial_trust_radius=1.0,
                            max_trust_radius=1000.0, eta=0.15, gtol=1e-4,
                            maxiter=None, disp=False, return_all=False,
-                           callback=None, inexact=True, **unknown_options):
+                           callback=None, inexact=True, workers=None,
+                           **unknown_options):
     """
     Minimization of scalar function of one or more variables using a
     trust-region algorithm.
@@ -142,6 +143,13 @@ def _minimize_trust_region(fun, x0, args=(), jac=None, hess=None, hessp=None,
             Accuracy to solve subproblems. If True requires less nonlinear
             iterations, but more vector products. Only effective for method
             trust-krylov.
+        workers : int, map-like callable, optional
+            A map-like callable, such as `multiprocessing.Pool.map` for evaluating
+            any numerical differentiation in parallel.
+            This evaluation is carried out as ``workers(fun, iterable)``.
+            Only for 'trust-krylov', 'trust-ncg'.
+
+            .. versionadded:: 1.16.0
 
     This function is called by the `minimize` function.
     It is not supposed to be called directly.
@@ -172,7 +180,13 @@ def _minimize_trust_region(fun, x0, args=(), jac=None, hess=None, hessp=None,
 
     # A ScalarFunction representing the problem. This caches calls to fun, jac,
     # hess.
-    sf = _prepare_scalar_function(fun, x0, jac=jac, hess=hess, args=args)
+    # the workers kwd only has an effect for trust-ncg, trust-krylov when
+    # estimating the Hessian with finite-differences. It's never used
+    # during calculation of jacobian, because callables are required for all
+    # methods.
+    sf = _prepare_scalar_function(
+        fun, x0, jac=jac, hess=hess, args=args, workers=workers
+    )
     fun = sf.fun
     jac = sf.grad
     if callable(hess):
@@ -285,10 +299,10 @@ def _minimize_trust_region(fun, x0, args=(), jac=None, hess=None, hessp=None,
         else:
             warnings.warn(status_messages[warnflag], RuntimeWarning, stacklevel=3)
         print(f"         Current function value: {m.fun:f}")
-        print("         Iterations: %d" % k)
-        print("         Function evaluations: %d" % sf.nfev)
-        print("         Gradient evaluations: %d" % sf.ngev)
-        print("         Hessian evaluations: %d" % (sf.nhev + nhessp[0]))
+        print(f"         Iterations: {k:d}")
+        print(f"         Function evaluations: {sf.nfev:d}")
+        print(f"         Gradient evaluations: {sf.ngev:d}")
+        print(f"         Hessian evaluations: {sf.nhev + nhessp[0]:d}")
 
     result = OptimizeResult(x=x, success=(warnflag == 0), status=warnflag,
                             fun=m.fun, jac=m.jac, nfev=sf.nfev, njev=sf.ngev,

scipy/optimize/_trustregion_constr/canonical_constraint.py

@@ -27,7 +27,7 @@ class CanonicalConstraint:
     jac : callable
         Function to evaluate the Jacobian of the constraint. The signature
         is ``jac(x) -> J_eq, J_ineq``, where ``J_eq`` and ``J_ineq`` are
-        either ndarray of csr_matrix of shapes (n_eq, n) and (n_ineq, n),
+        either ndarray of csr_array of shapes (n_eq, n) and (n_ineq, n),
         respectively.
     hess : callable
         Function to evaluate the Hessian of the constraints multiplied
@@ -77,7 +77,7 @@ class CanonicalConstraint:
         """
         empty_fun = np.empty(0)
         empty_jac = np.empty((0, n))
-        empty_hess = sps.csr_matrix((n, n))
+        empty_hess = sps.csr_array((n, n))
 
         def fun(x):
             return empty_fun, empty_fun
@@ -158,7 +158,7 @@ class CanonicalConstraint:
         keep_feasible = np.empty(0, dtype=bool)
 
         if cfun.sparse_jacobian:
-            empty_jac = sps.csr_matrix((0, n))
+            empty_jac = sps.csr_array((0, n))
         else:
             empty_jac = np.empty((0, n))
 
@@ -174,7 +174,7 @@ class CanonicalConstraint:
         empty_fun = np.empty(0)
         n = cfun.n
         if cfun.sparse_jacobian:
-            empty_jac = sps.csr_matrix((0, n))
+            empty_jac = sps.csr_array((0, n))
         else:
             empty_jac = np.empty((0, n))
 
@@ -185,7 +185,7 @@ class CanonicalConstraint:
         empty_fun = np.empty(0)
         n = cfun.n
         if cfun.sparse_jacobian:
-            empty_jac = sps.csr_matrix((0, n))
+            empty_jac = sps.csr_array((0, n))
         else:
             empty_jac = np.empty((0, n))
 
@@ -225,7 +225,7 @@ class CanonicalConstraint:
         empty_fun = np.empty(0)
         n = cfun.n
         if cfun.sparse_jacobian:
-            empty_jac = sps.csr_matrix((0, n))
+            empty_jac = sps.csr_array((0, n))
         else:
             empty_jac = np.empty((0, n))
 
@@ -379,7 +379,7 @@ def initial_constraints_as_canonical(n, prepared_constraints, sparse_jacobian):
 
     if sparse_jacobian:
         vstack = sps.vstack
-        empty = sps.csr_matrix((0, n))
+        empty = sps.csr_array((0, n))
     else:
         vstack = np.vstack
         empty = np.empty((0, n))

scipy/optimize/_trustregion_constr/equality_constrained_sqp.py

@@ -1,6 +1,6 @@
 """Byrd-Omojokun Trust-Region SQP method."""
 
-from scipy.sparse import eye as speye
+from scipy.sparse import eye_array as speye
 from .projections import projections
 from .qp_subproblem import modified_dogleg, projected_cg, box_intersections
 import numpy as np