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

scipy/optimize/_trustregion_constr/minimize_trustregion_constr.py

@@ -125,7 +125,8 @@ def _minimize_trustregion_constr(fun, x0, args, grad,
                                  initial_barrier_parameter=0.1,
                                  initial_barrier_tolerance=0.1,
                                  factorization_method=None,
-                                 disp=False):
+                                 disp=False,
+                                 workers=None):
     """Minimize a scalar function subject to constraints.
 
     Parameters
@@ -224,6 +225,12 @@ def _minimize_trustregion_constr(fun, x0, args, grad,
 
     disp : bool, optional
         If True (default), then `verbose` will be set to 1 if it was 0.
+    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
     -------
@@ -265,7 +272,7 @@ def _minimize_trustregion_constr(fun, x0, args, grad,
         Optimization method used.
     constr : list of ndarray
         List of constraint values at the solution.
-    jac : list of {ndarray, sparse matrix}
+    jac : list of {ndarray, sparse array}
         List of the Jacobian matrices of the constraints at the solution.
     v : list of ndarray
         List of the Lagrange multipliers for the constraints at the solution.
@@ -343,7 +350,8 @@ def _minimize_trustregion_constr(fun, x0, args, grad,
 
     # Define Objective Function
     objective = ScalarFunction(fun, x0, args, grad, hess,
-                               finite_diff_rel_step, finite_diff_bounds)
+                               finite_diff_rel_step, finite_diff_bounds,
+                               workers=workers)
 
     # Put constraints in list format when needed.
     if isinstance(constraints, (NonlinearConstraint | LinearConstraint)):

scipy/optimize/_trustregion_constr/projections.py

@@ -1,17 +1,17 @@
 """Basic linear factorizations needed by the solver."""
 
-from scipy.sparse import (bmat, csc_matrix, eye, issparse)
+from scipy.sparse import block_array, csc_array, eye_array, issparse
 from scipy.sparse.linalg import LinearOperator
 import scipy.linalg
 import scipy.sparse.linalg
 try:
-    from sksparse.cholmod import cholesky_AAt
+    from sksparse.cholmod import cholesky_AAt, CholmodTypeConversionWarning
     sksparse_available = True
 except ImportError:
     import warnings
     sksparse_available = False
 import numpy as np
-from warnings import warn
+from warnings import warn, catch_warnings
 
 __all__ = [
     'orthogonality',
@@ -58,7 +58,11 @@ def normal_equation_projections(A, m, n, orth_tol, max_refin, tol):
     """Return linear operators for matrix A using ``NormalEquation`` approach.
     """
     # Cholesky factorization
-    factor = cholesky_AAt(A)
+    # TODO: revert this once the warning bug fix in sksparse is merged/released
+    # Add suppression of spurious warning bug from sksparse with csc_array gh-22089
+    # factor = cholesky_AAt(A)
+    with catch_warnings(action='ignore', category=CholmodTypeConversionWarning):
+        factor = cholesky_AAt(A)
 
     # z = x - A.T inv(A A.T) A x
     def null_space(x):
@@ -92,7 +96,7 @@ def normal_equation_projections(A, m, n, orth_tol, max_refin, tol):
 def augmented_system_projections(A, m, n, orth_tol, max_refin, tol):
     """Return linear operators for matrix A - ``AugmentedSystem``."""
     # Form augmented system
-    K = csc_matrix(bmat([[eye(n), A.T], [A, None]]))
+    K = block_array([[eye_array(n), A.T], [A, None]], format="csc")
     # LU factorization
     # TODO: Use a symmetric indefinite factorization
     #       to solve the system twice as fast (because
@@ -293,7 +297,7 @@ def projections(A, method=None, orth_tol=1e-12, max_refin=3, tol=1e-15):
 
     Parameters
     ----------
-    A : sparse matrix (or ndarray), shape (m, n)
+    A : sparse array (or ndarray), shape (m, n)
         Matrix ``A`` used in the projection.
     method : string, optional
         Method used for compute the given linear
@@ -367,14 +371,14 @@ def projections(A, method=None, orth_tol=1e-12, max_refin=3, tol=1e-15):
     # The factorization of an empty matrix
     # only works for the sparse representation.
     if m*n == 0:
-        A = csc_matrix(A)
+        A = csc_array(A)
 
     # Check Argument
     if issparse(A):
         if method is None:
             method = "AugmentedSystem"
         if method not in ("NormalEquation", "AugmentedSystem"):
-            raise ValueError("Method not allowed for sparse matrix.")
+            raise ValueError("Method not allowed for sparse array.")
         if method == "NormalEquation" and not sksparse_available:
             warnings.warn("Only accepts 'NormalEquation' option when "
                           "scikit-sparse is available. Using "

scipy/optimize/_trustregion_constr/qp_subproblem.py

@@ -1,6 +1,6 @@
 """Equality-constrained quadratic programming solvers."""
 
-from scipy.sparse import (linalg, bmat, csc_matrix)
+from scipy.sparse import linalg, block_array
 from math import copysign
 import numpy as np
 from numpy.linalg import norm
@@ -25,11 +25,11 @@ def eqp_kktfact(H, c, A, b):
 
     Parameters
     ----------
-    H : sparse matrix, shape (n, n)
+    H : sparse array, shape (n, n)
         Hessian matrix of the EQP problem.
     c : array_like, shape (n,)
         Gradient of the quadratic objective function.
-    A : sparse matrix
+    A : sparse array
         Jacobian matrix of the EQP problem.
     b : array_like, shape (m,)
         Right-hand side of the constraint equation.
@@ -47,7 +47,7 @@ def eqp_kktfact(H, c, A, b):
     # Karush-Kuhn-Tucker matrix of coefficients.
     # Defined as in Nocedal/Wright "Numerical
     # Optimization" p.452 in Eq. (16.4).
-    kkt_matrix = csc_matrix(bmat([[H, A.T], [A, None]]))
+    kkt_matrix = block_array([[H, A.T], [A, None]], format="csc")
     # Vector of coefficients.
     kkt_vec = np.hstack([-c, -b])
 
@@ -321,10 +321,10 @@ def modified_dogleg(A, Y, b, trust_radius, lb, ub):
 
     Parameters
     ----------
-    A : LinearOperator (or sparse matrix or ndarray), shape (m, n)
+    A : LinearOperator (or sparse array or ndarray), shape (m, n)
         Matrix ``A`` in the minimization problem. It should have
         dimension ``(m, n)`` such that ``m < n``.
-    Y : LinearOperator (or sparse matrix or ndarray), shape (n, m)
+    Y : LinearOperator (or sparse array or ndarray), shape (n, m)
         LinearOperator that apply the projection matrix
         ``Q = A.T inv(A A.T)`` to the vector. The obtained vector
         ``y = Q x`` being the minimum norm solution of ``A y = x``.
@@ -421,13 +421,13 @@ def projected_cg(H, c, Z, Y, b, trust_radius=np.inf,
 
     Parameters
     ----------
-    H : LinearOperator (or sparse matrix or ndarray), shape (n, n)
+    H : LinearOperator (or sparse array or ndarray), shape (n, n)
         Operator for computing ``H v``.
     c : array_like, shape (n,)
         Gradient of the quadratic objective function.
-    Z : LinearOperator (or sparse matrix or ndarray), shape (n, n)
+    Z : LinearOperator (or sparse array or ndarray), shape (n, n)
         Operator for projecting ``x`` into the null space of A.
-    Y : LinearOperator,  sparse matrix, ndarray, shape (n, m)
+    Y : LinearOperator,  sparse array, ndarray, shape (n, m)
         Operator that, for a given a vector ``b``, compute smallest
         norm solution of ``A x + b = 0``.
     b : array_like, shape (m,)

scipy/optimize/_trustregion_constr/tests/test_projections.py

@@ -1,6 +1,6 @@
 import numpy as np
 import scipy.linalg
-from scipy.sparse import csc_matrix
+from scipy.sparse import csc_array
 from scipy.optimize._trustregion_constr.projections \
     import projections, orthogonality
 from numpy.testing import (TestCase, assert_array_almost_equal,
@@ -23,7 +23,7 @@ class TestProjections(TestCase):
                             [0, 8, 7, 0, 1, 5, 9, 0],
                             [1, 0, 0, 0, 0, 1, 2, 3]])
         At_dense = A_dense.T
-        A = csc_matrix(A_dense)
+        A = csc_array(A_dense)
         test_points = ([1, 2, 3, 4, 5, 6, 7, 8],
                        [1, 10, 3, 0, 1, 6, 7, 8],
                        [1.12, 10, 0, 0, 100000, 6, 0.7, 8])
@@ -45,7 +45,7 @@ class TestProjections(TestCase):
         A_dense = np.array([[1, 2, 3, 4, 0, 5, 0, 7],
                             [0, 8, 7, 0, 1, 5, 9, 0],
                             [1, 0, 0, 0, 0, 1, 2, 3]])
-        A = csc_matrix(A_dense)
+        A = csc_array(A_dense)
         test_points = ([1, 2, 3, 4, 5, 6, 7, 8],
                        [1, 10, 3, 0, 1, 6, 7, 8],
                        [1.12, 10, 0, 0, 100000, 6, 0.7, 8],
@@ -65,7 +65,7 @@ class TestProjections(TestCase):
         A_dense = np.array([[1, 2, 3, 4, 0, 5, 0, 7],
                             [0, 8, 7, 0, 1, 5, 9, 0],
                             [1, 0, 0, 0, 0, 1, 2, 3]])
-        A = csc_matrix(A_dense)
+        A = csc_array(A_dense)
         test_points = ([1, 2, 3],
                        [1, 10, 3],
                        [1.12, 10, 0])
@@ -106,7 +106,7 @@ class TestProjections(TestCase):
     def test_compare_dense_and_sparse(self):
         D = np.diag(range(1, 101))
         A = np.hstack([D, D, D, D])
-        A_sparse = csc_matrix(A)
+        A_sparse = csc_array(A)
         np.random.seed(0)
 
         Z, LS, Y = projections(A)
@@ -123,7 +123,7 @@ class TestProjections(TestCase):
         D2 = np.diag([1, -0.6, -0.3])
         D3 = np.diag([-0.3, -1.5, 2])
         A = np.hstack([D1, D2, D3])
-        A_sparse = csc_matrix(A)
+        A_sparse = csc_array(A)
         np.random.seed(0)
 
         Z, LS, Y = projections(A)
@@ -197,7 +197,7 @@ class TestOrthogonality(TestCase):
         A = np.array([[1, 2, 3, 4, 0, 5, 0, 7],
                       [0, 8, 7, 0, 1, 5, 9, 0],
                       [1, 0, 0, 0, 0, 1, 2, 3]])
-        A = csc_matrix(A)
+        A = csc_array(A)
         test_vectors = ([-1.98931144, -1.56363389,
                          -0.84115584, 2.2864762,
                          5.599141, 0.09286976,

scipy/optimize/_trustregion_constr/tests/test_qp_subproblem.py

@@ -1,5 +1,5 @@
 import numpy as np
-from scipy.sparse import csc_matrix
+from scipy.sparse import csc_array
 from scipy.optimize._trustregion_constr.qp_subproblem \
     import (eqp_kktfact,
             projected_cg,
@@ -18,11 +18,11 @@ class TestEQPDirectFactorization(TestCase):
     # From Example 16.2 Nocedal/Wright "Numerical
     # Optimization" p.452.
     def test_nocedal_example(self):
-        H = csc_matrix([[6, 2, 1],
-                        [2, 5, 2],
-                        [1, 2, 4]])
-        A = csc_matrix([[1, 0, 1],
-                        [0, 1, 1]])
+        H = csc_array([[6, 2, 1],
+                       [2, 5, 2],
+                       [1, 2, 4]])
+        A = csc_array([[1, 0, 1],
+                       [0, 1, 1]])
         c = np.array([-8, -3, -3])
         b = -np.array([3, 0])
         x, lagrange_multipliers = eqp_kktfact(H, c, A, b)
@@ -424,11 +424,11 @@ class TestProjectCG(TestCase):
     # From Example 16.2 Nocedal/Wright "Numerical
     # Optimization" p.452.
     def test_nocedal_example(self):
-        H = csc_matrix([[6, 2, 1],
-                        [2, 5, 2],
-                        [1, 2, 4]])
-        A = csc_matrix([[1, 0, 1],
-                        [0, 1, 1]])
+        H = csc_array([[6, 2, 1],
+                       [2, 5, 2],
+                       [1, 2, 4]])
+        A = csc_array([[1, 0, 1],
+                       [0, 1, 1]])
         c = np.array([-8, -3, -3])
         b = -np.array([3, 0])
         Z, _, Y = projections(A)
@@ -438,12 +438,12 @@ class TestProjectCG(TestCase):
         assert_array_almost_equal(x, [2, -1, 1])
 
     def test_compare_with_direct_fact(self):
-        H = csc_matrix([[6, 2, 1, 3],
-                        [2, 5, 2, 4],
-                        [1, 2, 4, 5],
-                        [3, 4, 5, 7]])
-        A = csc_matrix([[1, 0, 1, 0],
-                        [0, 1, 1, 1]])
+        H = csc_array([[6, 2, 1, 3],
+                       [2, 5, 2, 4],
+                       [1, 2, 4, 5],
+                       [3, 4, 5, 7]])
+        A = csc_array([[1, 0, 1, 0],
+                       [0, 1, 1, 1]])
         c = np.array([-2, -3, -3, 1])
         b = -np.array([3, 0])
         Z, _, Y = projections(A)
@@ -454,12 +454,12 @@ class TestProjectCG(TestCase):
         assert_array_almost_equal(x, x_kkt)
 
     def test_trust_region_infeasible(self):
-        H = csc_matrix([[6, 2, 1, 3],
-                        [2, 5, 2, 4],
-                        [1, 2, 4, 5],
-                        [3, 4, 5, 7]])
-        A = csc_matrix([[1, 0, 1, 0],
-                        [0, 1, 1, 1]])
+        H = csc_array([[6, 2, 1, 3],
+                       [2, 5, 2, 4],
+                       [1, 2, 4, 5],
+                       [3, 4, 5, 7]])
+        A = csc_array([[1, 0, 1, 0],
+                       [0, 1, 1, 1]])
         c = np.array([-2, -3, -3, 1])
         b = -np.array([3, 0])
         trust_radius = 1
@@ -468,12 +468,12 @@ class TestProjectCG(TestCase):
             projected_cg(H, c, Z, Y, b, trust_radius=trust_radius)
 
     def test_trust_region_barely_feasible(self):
-        H = csc_matrix([[6, 2, 1, 3],
-                        [2, 5, 2, 4],
-                        [1, 2, 4, 5],
-                        [3, 4, 5, 7]])
-        A = csc_matrix([[1, 0, 1, 0],
-                        [0, 1, 1, 1]])
+        H = csc_array([[6, 2, 1, 3],
+                       [2, 5, 2, 4],
+                       [1, 2, 4, 5],
+                       [3, 4, 5, 7]])
+        A = csc_array([[1, 0, 1, 0],
+                       [0, 1, 1, 1]])
         c = np.array([-2, -3, -3, 1])
         b = -np.array([3, 0])
         trust_radius = 2.32379000772445021283
@@ -487,12 +487,12 @@ class TestProjectCG(TestCase):
         assert_array_almost_equal(x, -Y.dot(b))
 
     def test_hits_boundary(self):
-        H = csc_matrix([[6, 2, 1, 3],
-                        [2, 5, 2, 4],
-                        [1, 2, 4, 5],
-                        [3, 4, 5, 7]])
-        A = csc_matrix([[1, 0, 1, 0],
-                        [0, 1, 1, 1]])
+        H = csc_array([[6, 2, 1, 3],
+                       [2, 5, 2, 4],
+                       [1, 2, 4, 5],
+                       [3, 4, 5, 7]])
+        A = csc_array([[1, 0, 1, 0],
+                       [0, 1, 1, 1]])
         c = np.array([-2, -3, -3, 1])
         b = -np.array([3, 0])
         trust_radius = 3
@@ -505,12 +505,12 @@ class TestProjectCG(TestCase):
         assert_array_almost_equal(np.linalg.norm(x), trust_radius)
 
     def test_negative_curvature_unconstrained(self):
-        H = csc_matrix([[1, 2, 1, 3],
-                        [2, 0, 2, 4],
-                        [1, 2, 0, 2],
-                        [3, 4, 2, 0]])
-        A = csc_matrix([[1, 0, 1, 0],
-                        [0, 1, 0, 1]])
+        H = csc_array([[1, 2, 1, 3],
+                       [2, 0, 2, 4],
+                       [1, 2, 0, 2],
+                       [3, 4, 2, 0]])
+        A = csc_array([[1, 0, 1, 0],
+                       [0, 1, 0, 1]])
         c = np.array([-2, -3, -3, 1])
         b = -np.array([3, 0])
         Z, _, Y = projections(A)
@@ -518,12 +518,12 @@ class TestProjectCG(TestCase):
             projected_cg(H, c, Z, Y, b, tol=0)
 
     def test_negative_curvature(self):
-        H = csc_matrix([[1, 2, 1, 3],
-                        [2, 0, 2, 4],
-                        [1, 2, 0, 2],
-                        [3, 4, 2, 0]])
-        A = csc_matrix([[1, 0, 1, 0],
-                        [0, 1, 0, 1]])
+        H = csc_array([[1, 2, 1, 3],
+                       [2, 0, 2, 4],
+                       [1, 2, 0, 2],
+                       [3, 4, 2, 0]])
+        A = csc_array([[1, 0, 1, 0],
+                       [0, 1, 0, 1]])
         c = np.array([-2, -3, -3, 1])
         b = -np.array([3, 0])
         Z, _, Y = projections(A)
@@ -538,12 +538,12 @@ class TestProjectCG(TestCase):
     # The box constraints are inactive at the solution but
     # are active during the iterations.
     def test_inactive_box_constraints(self):
-        H = csc_matrix([[6, 2, 1, 3],
-                        [2, 5, 2, 4],
-                        [1, 2, 4, 5],
-                        [3, 4, 5, 7]])
-        A = csc_matrix([[1, 0, 1, 0],
-                        [0, 1, 1, 1]])
+        H = csc_array([[6, 2, 1, 3],
+                       [2, 5, 2, 4],
+                       [1, 2, 4, 5],
+                       [3, 4, 5, 7]])
+        A = csc_array([[1, 0, 1, 0],
+                       [0, 1, 1, 1]])
         c = np.array([-2, -3, -3, 1])
         b = -np.array([3, 0])
         Z, _, Y = projections(A)
@@ -560,12 +560,12 @@ class TestProjectCG(TestCase):
     # The box constraints active and the termination is
     # by maximum iterations (infeasible interaction).
     def test_active_box_constraints_maximum_iterations_reached(self):
-        H = csc_matrix([[6, 2, 1, 3],
-                        [2, 5, 2, 4],
-                        [1, 2, 4, 5],
-                        [3, 4, 5, 7]])
-        A = csc_matrix([[1, 0, 1, 0],
-                        [0, 1, 1, 1]])
+        H = csc_array([[6, 2, 1, 3],
+                       [2, 5, 2, 4],
+                       [1, 2, 4, 5],
+                       [3, 4, 5, 7]])
+        A = csc_array([[1, 0, 1, 0],
+                       [0, 1, 1, 1]])
         c = np.array([-2, -3, -3, 1])
         b = -np.array([3, 0])
         Z, _, Y = projections(A)
@@ -582,12 +582,12 @@ class TestProjectCG(TestCase):
     # The box constraints are active and the termination is
     # because it hits boundary (without infeasible interaction).
     def test_active_box_constraints_hits_boundaries(self):
-        H = csc_matrix([[6, 2, 1, 3],
-                        [2, 5, 2, 4],
-                        [1, 2, 4, 5],
-                        [3, 4, 5, 7]])
-        A = csc_matrix([[1, 0, 1, 0],
-                        [0, 1, 1, 1]])
+        H = csc_array([[6, 2, 1, 3],
+                       [2, 5, 2, 4],
+                       [1, 2, 4, 5],
+                       [3, 4, 5, 7]])
+        A = csc_array([[1, 0, 1, 0],
+                       [0, 1, 1, 1]])
         c = np.array([-2, -3, -3, 1])
         b = -np.array([3, 0])
         trust_radius = 3
@@ -604,12 +604,12 @@ class TestProjectCG(TestCase):
     # The box constraints are active and the termination is
     # because it hits boundary (infeasible interaction).
     def test_active_box_constraints_hits_boundaries_infeasible_iter(self):
-        H = csc_matrix([[6, 2, 1, 3],
-                        [2, 5, 2, 4],
-                        [1, 2, 4, 5],
-                        [3, 4, 5, 7]])
-        A = csc_matrix([[1, 0, 1, 0],
-                        [0, 1, 1, 1]])
+        H = csc_array([[6, 2, 1, 3],
+                       [2, 5, 2, 4],
+                       [1, 2, 4, 5],
+                       [3, 4, 5, 7]])
+        A = csc_array([[1, 0, 1, 0],
+                       [0, 1, 1, 1]])
         c = np.array([-2, -3, -3, 1])
         b = -np.array([3, 0])
         trust_radius = 4
@@ -626,12 +626,12 @@ class TestProjectCG(TestCase):
     # The box constraints are active and the termination is
     # because it hits boundary (no infeasible interaction).
     def test_active_box_constraints_negative_curvature(self):
-        H = csc_matrix([[1, 2, 1, 3],
-                        [2, 0, 2, 4],
-                        [1, 2, 0, 2],
-                        [3, 4, 2, 0]])
-        A = csc_matrix([[1, 0, 1, 0],
-                        [0, 1, 0, 1]])
+        H = csc_array([[1, 2, 1, 3],
+                       [2, 0, 2, 4],
+                       [1, 2, 0, 2],
+                       [3, 4, 2, 0]])
+        A = csc_array([[1, 0, 1, 0],
+                       [0, 1, 0, 1]])
         c = np.array([-2, -3, -3, 1])
         b = -np.array([3, 0])
         Z, _, Y = projections(A)

scipy/optimize/_trustregion_constr/tr_interior_point.py

@@ -158,11 +158,11 @@ class BarrierSubproblem:
         else:
             if sps.issparse(J_eq) or sps.issparse(J_ineq):
                 # It is expected that J_eq and J_ineq
-                # are already `csr_matrix` because of
+                # are already `csr_array` because of
                 # the way ``BoxConstraint``, ``NonlinearConstraint``
                 # and ``LinearConstraint`` are defined.
-                J_eq = sps.csr_matrix(J_eq)
-                J_ineq = sps.csr_matrix(J_ineq)
+                J_eq = sps.csr_array(J_eq)
+                J_ineq = sps.csr_array(J_ineq)
                 return self._assemble_sparse_jacobian(J_eq, J_ineq, s)
             else:
                 S = np.diag(s)
@@ -203,8 +203,8 @@ class BarrierSubproblem:
         new_indices[~mask] = indices
         new_data[mask] = s
         new_data[~mask] = data
-        J = sps.csr_matrix((new_data, new_indices, new_indptr),
-                           (n_eq + n_ineq, n_vars + n_ineq))
+        J = sps.csr_array((new_data, new_indices, new_indptr),
+                          (n_eq + n_ineq, n_vars + n_ineq))
         return J
 
     def lagrangian_hessian_x(self, z, v):

scipy/optimize/_trustregion_exact.py

@@ -29,7 +29,6 @@ def _minimize_trustregion_exact(fun, x0, args=(), jac=None, hess=None,
         Gradient norm must be less than ``gtol`` before successful
         termination.
     """
-
     if jac is None:
         raise ValueError('Jacobian is required for trust region '
                          'exact minimization.')