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

scipy/optimize/_differentialevolution.py

@@ -5,14 +5,15 @@ Added by Andrew Nelson 2014
 import warnings
 
 import numpy as np
+
 from scipy.optimize import OptimizeResult, minimize
+from scipy.optimize._constraints import (Bounds, new_bounds_to_old,
+                                         NonlinearConstraint, LinearConstraint)
 from scipy.optimize._optimize import _status_message, _wrap_callback
 from scipy._lib._util import (check_random_state, MapWrapper, _FunctionWrapper,
                               rng_integers, _transition_to_rng)
+from scipy._lib._sparse import issparse
 
-from scipy.optimize._constraints import (Bounds, new_bounds_to_old,
-                                         NonlinearConstraint, LinearConstraint)
-from scipy.sparse import issparse
 
 __all__ = ['differential_evolution']
 

scipy/optimize/_dual_annealing.py

@@ -599,7 +599,7 @@ def dual_annealing(func, bounds, args=(), maxiter=1000,
     References
     ----------
     .. [1] Tsallis C. Possible generalization of Boltzmann-Gibbs
-        statistics. Journal of Statistical Physics, 52, 479-487 (1998).
+        statistics. Journal of Statistical Physics, 52, 479-487 (1988).
     .. [2] Tsallis C, Stariolo DA. Generalized Simulated Annealing.
         Physica A, 233, 395-406 (1996).
     .. [3] Xiang Y, Sun DY, Fan W, Gong XG. Generalized Simulated

scipy/optimize/_elementwise.py

@@ -342,12 +342,9 @@ def find_minimum(f, init, /, *, args=(), tolerances=None, maxiter=100, callback=
     (where one of the inequalities is strict) are the values of `f` evaluated
     at those points, then the algorithm is considered to have converged when:
 
-    - ``xr - xl <= abs(xm)*xrtol + xatol`` or
+    - ``abs(xr - xm)/2 <= abs(xm)*xrtol + xatol`` or
     - ``(fl - 2*fm + fr)/2 <= abs(fm)*frtol + fatol``.
 
-    Note that first of these differs from the termination conditions described
-    in [1]_.
-
     The default value of `xrtol` is the square root of the precision of the
     appropriate dtype, and ``xatol = fatol = frtol`` is the smallest normal
     number of the appropriate dtype.

scipy/optimize/_lbfgsb_py.py

@@ -291,7 +291,8 @@ def _minimize_lbfgsb(fun, x0, args=(), jac=None, bounds=None,
                      disp=None, maxcor=10, ftol=2.2204460492503131e-09,
                      gtol=1e-5, eps=1e-8, maxfun=15000, maxiter=15000,
                      iprint=-1, callback=None, maxls=20,
-                     finite_diff_rel_step=None, **unknown_options):
+                     finite_diff_rel_step=None, workers=None,
+                     **unknown_options):
     """
     Minimize a scalar function of one or more variables using the L-BFGS-B
     algorithm.
@@ -322,11 +323,11 @@ def _minimize_lbfgsb(fun, x0, args=(), jac=None, bounds=None,
         If `jac is None` the absolute step size used for numerical
         approximation of the jacobian via forward differences.
     maxfun : int
-        Maximum number of function evaluations. Note that this function
-        may violate the limit because of evaluating gradients by numerical
-        differentiation.
+        Maximum number of function evaluations before minimization terminates.
+        Note that this function may violate the limit if the gradients
+        are evaluated by numerical differentiation.
     maxiter : int
-        Maximum number of iterations.
+        Maximum number of algorithm iterations.
     iprint : int, optional
         Deprecated option that previously controlled the text printed on the
         screen during the problem solution. Now the code does not emit any
@@ -344,6 +345,12 @@ def _minimize_lbfgsb(fun, 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
 
     Notes
     -----
@@ -352,6 +359,11 @@ def _minimize_lbfgsb(fun, x0, args=(), jac=None, bounds=None,
     relationship between the two is ``ftol = factr * numpy.finfo(float).eps``.
     I.e., `factr` multiplies the default machine floating-point precision to
     arrive at `ftol`.
+    If the minimization is slow to converge the optimizer may halt if the
+    total number of function evaluations exceeds `maxfun`, or the number of
+    algorithm iterations has reached `maxiter` (whichever comes first). If
+    this is the case then ``result.success=False``, and an appropriate
+    error message is contained in ``result.message``.
 
     """
     _check_unknown_options(unknown_options)
@@ -385,7 +397,8 @@ def _minimize_lbfgsb(fun, x0, args=(), jac=None, bounds=None,
     # _prepare_scalar_function can use bounds=None to represent no bounds
     sf = _prepare_scalar_function(fun, x0, jac=jac, args=args, epsilon=eps,
                                   bounds=bounds,
-                                  finite_diff_rel_step=finite_diff_rel_step)
+                                  finite_diff_rel_step=finite_diff_rel_step,
+                                  workers=workers)
 
     func_and_grad = sf.fun_and_grad
 
@@ -555,6 +568,43 @@ class LbfgsInvHessProduct(LinearOperator):
 
         return r
 
+    def _matmat(self, X):
+        """Efficient matrix-matrix multiply with the BFGS matrices.
+
+        This calculation is described in Section (4) of [1].
+
+        Parameters
+        ----------
+        X : ndarray
+            An array with shape (n,m)
+
+        Returns
+        -------
+        Y : ndarray
+            The matrix-matrix product
+
+        Notes
+        -----
+        This implementation is written starting from _matvec and broadcasting
+        all expressions along the second axis of X.
+
+        """
+        s, y, n_corrs, rho = self.sk, self.yk, self.n_corrs, self.rho
+        Q = np.array(X, dtype=self.dtype, copy=True)
+
+        alpha = np.empty((n_corrs, Q.shape[1]))
+
+        for i in range(n_corrs-1, -1, -1):
+            alpha[i] = rho[i] * np.dot(s[i], Q)
+            Q -= alpha[i]*y[i][:, np.newaxis]
+
+        R = Q
+        for i in range(n_corrs):
+            beta = rho[i] * np.dot(y[i], R)
+            R += s[i][:, np.newaxis] * (alpha[i] - beta)
+
+        return R
+
     def todense(self):
         """Return a dense array representation of this operator.
 
@@ -565,14 +615,5 @@ class LbfgsInvHessProduct(LinearOperator):
             the same data represented by this `LinearOperator`.
 
         """
-        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
+        return self._matmat(I_arr)

scipy/optimize/_linprog_doc.py

@@ -867,12 +867,12 @@ def _linprog_ip_doc(c, A_ub=None, b_ub=None, A_eq=None, b_eq=None,
         when Mehrota's predictor-corrector is not in use (uncommon).
     sparse : bool (default: False)
         Set to ``True`` if the problem is to be treated as sparse after
-        presolve. If either ``A_eq`` or ``A_ub`` is a sparse matrix,
+        presolve. If either ``A_eq`` or ``A_ub`` is sparse,
         this option will automatically be set ``True``, and the problem
         will be treated as sparse even during presolve. If your constraint
         matrices contain mostly zeros and the problem is not very small (less
         than about 100 constraints or variables), consider setting ``True``
-        or providing ``A_eq`` and ``A_ub`` as sparse matrices.
+        or providing ``A_eq`` and ``A_ub`` as sparse arrays.
     lstsq : bool (default: ``False``)
         Set to ``True`` if the problem is expected to be very poorly
         conditioned. This should always be left ``False`` unless severe

scipy/optimize/_linprog_highs.py

@@ -25,7 +25,7 @@ from ._highspy._core import(
     HighsModelStatus,
     simplex_constants as s_c,  # [1]
 )
-from scipy.sparse import csc_matrix, vstack, issparse
+from scipy.sparse import csc_array, vstack, issparse
 
 # [1]: Directly importing from "._highspy._core.simplex_constants"
 # causes problems when reloading.
@@ -318,7 +318,7 @@ def _linprog_highs(lp, solver, time_limit=None, presolve=True,
         A = vstack((A_ub, A_eq))
     else:
         A = np.vstack((A_ub, A_eq))
-    A = csc_matrix(A)
+    A = csc_array(A)
 
     options = {
         'presolve': presolve,

scipy/optimize/_linprog_ip.py

@@ -31,6 +31,8 @@ try:
     import sksparse  # noqa: F401
     from sksparse.cholmod import cholesky as cholmod  # noqa: F401
     from sksparse.cholmod import analyze as cholmod_analyze
+    from sksparse.cholmod import CholmodTypeConversionWarning
+    from warnings import catch_warnings
 except ImportError:
     has_cholmod = False
 try:
@@ -87,13 +89,26 @@ def _get_solver(M, sparse=False, lstsq=False, sym_pos=True,
                 def solve(r, sym_pos=False):
                     return sps.linalg.lsqr(M, r)[0]
             elif cholesky:
-                try:
-                    # Will raise an exception in the first call,
-                    # or when the matrix changes due to a new problem
-                    _get_solver.cholmod_factor.cholesky_inplace(M)
-                except Exception:
-                    _get_solver.cholmod_factor = cholmod_analyze(M)
-                    _get_solver.cholmod_factor.cholesky_inplace(M)
+                # TODO: revert this suppress_warning once the warning bug fix in
+                # sksparse is merged/released
+                # Suppress spurious warning bug from sksparse with csc_array gh-22089
+                # try:
+                #     # Will raise an exception in the first call,
+                #     # or when the matrix changes due to a new problem
+                #     _get_solver.cholmod_factor.cholesky_inplace(M)
+                # except Exception:
+                #     _get_solver.cholmod_factor = cholmod_analyze(M)
+                #     _get_solver.cholmod_factor.cholesky_inplace(M)
+                with catch_warnings(
+                    action='ignore', category=CholmodTypeConversionWarning
+                ):
+                    try:
+                        # Will raise an exception in the first call,
+                        # or when the matrix changes due to a new problem
+                        _get_solver.cholmod_factor.cholesky_inplace(M)
+                    except Exception:
+                        _get_solver.cholmod_factor = cholmod_analyze(M)
+                        _get_solver.cholmod_factor.cholesky_inplace(M)
                 solve = _get_solver.cholmod_factor
             else:
                 if has_umfpack and sym_pos:
@@ -199,7 +214,7 @@ def _get_delta(A, b, c, x, y, z, tau, kappa, gamma, eta, sparse=False,
     if A.shape[0] == 0:
         # If there are no constraints, some solvers fail (understandably)
         # rather than returning empty solution. This gets the job done.
-        sparse, lstsq, sym_pos, cholesky = False, False, True, False
+        lstsq, sym_pos, cholesky = False, True, False
     n_x = len(x)
 
     # [4] Equation 8.8
@@ -212,7 +227,7 @@ def _get_delta(A, b, c, x, y, z, tau, kappa, gamma, eta, sparse=False,
     Dinv = x / z
 
     if sparse:
-        M = A.dot(sps.diags(Dinv, 0, format="csc").dot(A.T))
+        M = A.dot(sps.diags_array(Dinv, format="csc").dot(A.T))
     else:
         M = A.dot(Dinv.reshape(-1, 1) * A.T)
     solve = _get_solver(M, sparse, lstsq, sym_pos, cholesky, permc_spec)
@@ -723,7 +738,7 @@ def _ip_hsd(A, b, c, c0, alpha0, beta, maxiter, disp, tol, sparse, lstsq,
     message = "Optimization terminated successfully."
 
     if sparse:
-        A = sps.csc_matrix(A)
+        A = sps.csc_array(A)
 
     while go:
 

scipy/optimize/_linprog_util.py

@@ -136,9 +136,9 @@ def _check_sparse_inputs(options, meth, A_ub, A_eq):
     # This is an undocumented option for unit testing sparse presolve
     _sparse_presolve = options.pop('_sparse_presolve', False)
     if _sparse_presolve and A_eq is not None:
-        A_eq = sps.coo_matrix(A_eq)
+        A_eq = sps.coo_array(A_eq)
     if _sparse_presolve and A_ub is not None:
-        A_ub = sps.coo_matrix(A_ub)
+        A_ub = sps.coo_array(A_ub)
 
     sparse_constraint = sps.issparse(A_eq) or sps.issparse(A_ub)
 
@@ -169,17 +169,17 @@ def _format_A_constraints(A, n_x, sparse_lhs=False):
         The number of variables in the linear programming problem.
     sparse_lhs : bool
         Whether either of `A_ub` or `A_eq` are sparse. If true return a
-        coo_matrix instead of a numpy array.
+        coo_array instead of a numpy array.
 
     Returns
     -------
-    np.ndarray or sparse.coo_matrix
+    np.ndarray or sparse.coo_array
         2-D array such that ``A @ x`` gives the values of the upper-bound
         (in)equality constraints at ``x``.
 
     """
     if sparse_lhs:
-        return sps.coo_matrix(
+        return sps.coo_array(
             (0, n_x) if A is None else A, dtype=float, copy=True
         )
     elif A is None:
@@ -1116,8 +1116,8 @@ def _get_Abc(lp, c0):
 
     if sps.issparse(A_eq):
         sparse = True
-        A_eq = sps.csr_matrix(A_eq)
-        A_ub = sps.csr_matrix(A_ub)
+        A_eq = sps.csr_array(A_eq)
+        A_ub = sps.csr_array(A_ub)
 
         def hstack(blocks):
             return sps.hstack(blocks, format="csr")
@@ -1125,8 +1125,8 @@ def _get_Abc(lp, c0):
         def vstack(blocks):
             return sps.vstack(blocks, format="csr")
 
-        zeros = sps.csr_matrix
-        eye = sps.eye
+        zeros = sps.csr_array
+        eye = sps.eye_array
     else:
         sparse = False
         hstack = np.hstack
@@ -1175,8 +1175,8 @@ def _get_Abc(lp, c0):
         shape = (n_bounds, A_ub.shape[1])
         if sparse:
             idxs = (np.arange(n_bounds), i_newub)
-            A_ub = vstack((A_ub, sps.csr_matrix((np.ones(n_bounds), idxs),
-                                                shape=shape)))
+            A_ub = vstack((A_ub, sps.csr_array((np.ones(n_bounds), idxs),
+                                               shape=shape)))
         else:
             A_ub = vstack((A_ub, np.zeros(shape)))
             A_ub[np.arange(m_ub, A_ub.shape[0]), i_newub] = 1
@@ -1213,10 +1213,8 @@ def _get_Abc(lp, c0):
     lb_shift = lbs[lb_some].astype(float)
     c0 += np.sum(lb_shift * c[i_shift])
     if sparse:
-        b = b.reshape(-1, 1)
         A = A.tocsc()
-        b -= (A[:, i_shift] @ sps.diags(lb_shift)).sum(axis=1)
-        b = b.ravel()
+        b -= (A[:, i_shift] @ sps.diags_array(lb_shift)).sum(axis=1)
     else:
         b -= (A[:, i_shift] * lb_shift).sum(axis=1)
     if x0 is not None:
@@ -1249,7 +1247,7 @@ def _autoscale(A, b, c, x0):
             R = R.toarray().flatten()
         R[R == 0] = 1
         R = 1/_round_to_power_of_two(R)
-        A = sps.diags(R)@A if sps.issparse(A) else A*R.reshape(m, 1)
+        A = sps.diags_array(R)@A if sps.issparse(A) else A*R.reshape(m, 1)
         b = b*R
 
         C = np.max(np.abs(A), axis=0)
@@ -1257,7 +1255,7 @@ def _autoscale(A, b, c, x0):
             C = C.toarray().flatten()
         C[C == 0] = 1
         C = 1/_round_to_power_of_two(C)
-        A = A@sps.diags(C) if sps.issparse(A) else A*C
+        A = A@sps.diags_array(C) if sps.issparse(A) else A*C
         c = c*C
 
     b_scale = np.max(np.abs(b)) if b.size > 0 else 1

scipy/optimize/_lsq/common.py

@@ -5,8 +5,8 @@ import numpy as np
 from numpy.linalg import norm
 
 from scipy.linalg import cho_factor, cho_solve, LinAlgError
-from scipy.sparse import issparse
 from scipy.sparse.linalg import LinearOperator, aslinearoperator
+from scipy._lib._sparse import issparse
 
 
 EPS = np.finfo(float).eps
@@ -258,7 +258,7 @@ def build_quadratic_1d(J, g, s, diag=None, s0=None):
 
     Parameters
     ----------
-    J : ndarray, sparse matrix or LinearOperator shape (m, n)
+    J : ndarray, sparse array or LinearOperator shape (m, n)
         Jacobian matrix, affects the quadratic term.
     g : ndarray, shape (n,)
         Gradient, defines the linear term.
@@ -329,7 +329,7 @@ def evaluate_quadratic(J, g, s, diag=None):
 
     Parameters
     ----------
-    J : ndarray, sparse matrix or LinearOperator, shape (m, n)
+    J : ndarray, sparse array or LinearOperator, shape (m, n)
         Jacobian matrix, affects the quadratic term.
     g : ndarray, shape (n,)
         Gradient, defines the linear term.

scipy/optimize/_lsq/dogbox.py

@@ -45,6 +45,8 @@ from numpy.linalg import lstsq, norm
 
 from scipy.sparse.linalg import LinearOperator, aslinearoperator, lsmr
 from scipy.optimize import OptimizeResult
+from scipy._lib._util import _call_callback_maybe_halt
+
 
 from .common import (
     step_size_to_bound, in_bounds, update_tr_radius, evaluate_quadratic,
@@ -147,7 +149,7 @@ def dogleg_step(x, newton_step, g, a, b, tr_bounds, lb, ub):
 
 
 def dogbox(fun, jac, x0, f0, J0, lb, ub, ftol, xtol, gtol, max_nfev, x_scale,
-           loss_function, tr_solver, tr_options, verbose):
+           loss_function, tr_solver, tr_options, verbose, callback=None):
     f = f0
     f_true = f.copy()
     nfev = 1
@@ -306,7 +308,7 @@ def dogbox(fun, jac, x0, f0, J0, lb, ub, ftol, xtol, gtol, max_nfev, x_scale,
 
             cost = cost_new
 
-            J = jac(x, f)
+            J = jac(x)
             njev += 1
 
             if loss_function is not None:
@@ -322,6 +324,18 @@ def dogbox(fun, jac, x0, f0, J0, lb, ub, ftol, xtol, gtol, max_nfev, x_scale,
             actual_reduction = 0
 
         iteration += 1
+        
+        # Call callback function and possibly stop optimization
+        if callback is not None:
+            intermediate_result = OptimizeResult(
+                x=x, fun=f, nit=iteration, nfev=nfev)
+            intermediate_result["cost"] = cost_new
+
+            if _call_callback_maybe_halt(
+                callback, intermediate_result
+            ):
+                termination_status = -2
+                break
 
     if termination_status is None:
         termination_status = 0