scipy 1.15.2__cp312-cp312-win_amd64.whl → 1.16.0rc1__cp312-cp312-win_amd64.whl

scipy/sparse/linalg/_isolve/iterative.py

@@ -22,7 +22,8 @@ def _get_atol_rtol(name, b_norm, atol=0., rtol=1e-5):
 
 
 def bicg(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M=None, callback=None):
-    """Use BIConjugate Gradient iteration to solve ``Ax = b``.
+    """
+    Solve ``Ax = b`` with the BIConjugate Gradient method.
 
     Parameters
     ----------
@@ -86,13 +87,13 @@ def bicg(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M=None, callback=No
     >>> np.allclose(A.dot(x), b)
     True
     """
-    A, M, x, b, postprocess = make_system(A, M, x0, b)
+    A, M, x, b = make_system(A, M, x0, b)
     bnrm2 = np.linalg.norm(b)
 
     atol, _ = _get_atol_rtol('bicg', bnrm2, atol, rtol)
 
     if bnrm2 == 0:
-        return postprocess(b), 0
+        return b, 0
 
     n = len(b)
     dotprod = np.vdot if np.iscomplexobj(x) else np.dot
@@ -113,7 +114,7 @@ def bicg(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M=None, callback=No
 
     for iteration in range(maxiter):
         if np.linalg.norm(r) < atol:  # Are we done?
-            return postprocess(x), 0
+            return x, 0
 
         z = psolve(r)
         ztilde = rpsolve(rtilde)
@@ -121,7 +122,7 @@ def bicg(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M=None, callback=No
         rho_cur = dotprod(rtilde, z)
 
         if np.abs(rho_cur) < rhotol:  # Breakdown case
-            return postprocess, -10
+            return x, -10
 
         if iteration > 0:
             beta = rho_cur / rho_prev
@@ -138,7 +139,7 @@ def bicg(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M=None, callback=No
         rv = dotprod(ptilde, q)
 
         if rv == 0:
-            return postprocess(x), -11
+            return x, -11
 
         alpha = rho_cur / rv
         x += alpha*p
@@ -151,12 +152,13 @@ def bicg(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M=None, callback=No
 
     else:  # for loop exhausted
         # Return incomplete progress
-        return postprocess(x), maxiter
+        return x, maxiter
 
 
 def bicgstab(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M=None,
              callback=None):
-    """Use BIConjugate Gradient STABilized iteration to solve ``Ax = b``.
+    """
+    Solve ``Ax = b`` with the BIConjugate Gradient STABilized method.
 
     Parameters
     ----------
@@ -224,13 +226,13 @@ def bicgstab(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M=None,
     >>> np.allclose(A.dot(x), b)
     True
     """
-    A, M, x, b, postprocess = make_system(A, M, x0, b)
+    A, M, x, b = make_system(A, M, x0, b)
     bnrm2 = np.linalg.norm(b)
 
     atol, _ = _get_atol_rtol('bicgstab', bnrm2, atol, rtol)
 
     if bnrm2 == 0:
-        return postprocess(b), 0
+        return b, 0
 
     n = len(b)
 
@@ -255,15 +257,15 @@ def bicgstab(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M=None,
 
     for iteration in range(maxiter):
         if np.linalg.norm(r) < atol:  # Are we done?
-            return postprocess(x), 0
+            return x, 0
 
         rho = dotprod(rtilde, r)
         if np.abs(rho) < rhotol:  # rho breakdown
-            return postprocess(x), -10
+            return x, -10
 
         if iteration > 0:
             if np.abs(omega) < omegatol:  # omega breakdown
-                return postprocess(x), -11
+                return x, -11
 
             beta = (rho / rho_prev) * (alpha / omega)
             p -= omega*v
@@ -277,14 +279,14 @@ def bicgstab(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M=None,
         v = matvec(phat)
         rv = dotprod(rtilde, v)
         if rv == 0:
-            return postprocess(x), -11
+            return x, -11
         alpha = rho / rv
         r -= alpha*v
         s[:] = r[:]
 
         if np.linalg.norm(s) < atol:
             x += alpha*phat
-            return postprocess(x), 0
+            return x, 0
 
         shat = psolve(s)
         t = matvec(shat)
@@ -299,11 +301,13 @@ def bicgstab(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M=None,
 
     else:  # for loop exhausted
         # Return incomplete progress
-        return postprocess(x), maxiter
+        return x, maxiter
 
 
 def cg(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M=None, callback=None):
-    """Use Conjugate Gradient iteration to solve ``Ax = b``.
+    """
+    Solve ``Ax = b`` with the Conjugate Gradient method, for a symmetric,
+    positive-definite `A`.
 
     Parameters
     ----------
@@ -372,13 +376,13 @@ def cg(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M=None, callback=None
     >>> np.allclose(A.dot(x), b)
     True
     """
-    A, M, x, b, postprocess = make_system(A, M, x0, b)
+    A, M, x, b = make_system(A, M, x0, b)
     bnrm2 = np.linalg.norm(b)
 
     atol, _ = _get_atol_rtol('cg', bnrm2, atol, rtol)
 
     if bnrm2 == 0:
-        return postprocess(b), 0
+        return b, 0
 
     n = len(b)
 
@@ -396,7 +400,7 @@ def cg(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M=None, callback=None
 
     for iteration in range(maxiter):
         if np.linalg.norm(r) < atol:  # Are we done?
-            return postprocess(x), 0
+            return x, 0
 
         z = psolve(r)
         rho_cur = dotprod(r, z)
@@ -419,11 +423,12 @@ def cg(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M=None, callback=None
 
     else:  # for loop exhausted
         # Return incomplete progress
-        return postprocess(x), maxiter
+        return x, maxiter
 
 
 def cgs(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M=None, callback=None):
-    """Use Conjugate Gradient Squared iteration to solve ``Ax = b``.
+    """
+    Solve ``Ax = b`` with the Conjugate Gradient Squared method.
 
     Parameters
     ----------
@@ -491,13 +496,13 @@ def cgs(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M=None, callback=Non
     >>> np.allclose(A.dot(x), b)
     True
     """
-    A, M, x, b, postprocess = make_system(A, M, x0, b)
+    A, M, x, b = make_system(A, M, x0, b)
     bnrm2 = np.linalg.norm(b)
 
     atol, _ = _get_atol_rtol('cgs', bnrm2, atol, rtol)
 
     if bnrm2 == 0:
-        return postprocess(b), 0
+        return b, 0
 
     n = len(b)
 
@@ -524,11 +529,11 @@ def cgs(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M=None, callback=Non
     for iteration in range(maxiter):
         rnorm = np.linalg.norm(r)
         if rnorm < atol:  # Are we done?
-            return postprocess(x), 0
+            return x, 0
 
         rho_cur = dotprod(rtilde, r)
         if np.abs(rho_cur) < rhotol:  # Breakdown case
-            return postprocess, -10
+            return x, -10
 
         if iteration > 0:
             beta = rho_cur / rho_prev
@@ -553,7 +558,7 @@ def cgs(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M=None, callback=Non
         rv = dotprod(rtilde, vhat)
 
         if rv == 0:  # Dot product breakdown
-            return postprocess(x), -11
+            return x, -11
 
         alpha = rho_cur / rv
         q[:] = u[:]
@@ -576,13 +581,13 @@ def cgs(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M=None, callback=Non
 
     else:  # for loop exhausted
         # Return incomplete progress
-        return postprocess(x), maxiter
+        return x, maxiter
 
 
 def gmres(A, b, x0=None, *, rtol=1e-5, atol=0., restart=None, maxiter=None, M=None,
           callback=None, callback_type=None):
     """
-    Use Generalized Minimal RESidual iteration to solve ``Ax = b``.
+    Solve ``Ax = b`` with the Generalized Minimal RESidual method.
 
     Parameters
     ----------
@@ -689,7 +694,7 @@ def gmres(A, b, x0=None, *, rtol=1e-5, atol=0., restart=None, maxiter=None, M=No
     if callback is None:
         callback_type = None
 
-    A, M, x, b, postprocess = make_system(A, M, x0, b)
+    A, M, x, b = make_system(A, M, x0, b)
     matvec = A.matvec
     psolve = M.matvec
     n = len(b)
@@ -698,7 +703,7 @@ def gmres(A, b, x0=None, *, rtol=1e-5, atol=0., restart=None, maxiter=None, M=No
     atol, _ = _get_atol_rtol('gmres', bnrm2, atol, rtol)
 
     if bnrm2 == 0:
-        return postprocess(b), 0
+        return b, 0
 
     eps = np.finfo(x.dtype.char).eps
 
@@ -737,7 +742,7 @@ def gmres(A, b, x0=None, *, rtol=1e-5, atol=0., restart=None, maxiter=None, M=No
         if iteration == 0:
             r = b - matvec(x) if x.any() else b.copy()
             if np.linalg.norm(r) < atol:  # Are we done?
-                return postprocess(x), 0
+                return x, 0
 
         v[0, :] = psolve(r)
         tmp = np.linalg.norm(v[0, :])
@@ -818,7 +823,7 @@ def gmres(A, b, x0=None, *, rtol=1e-5, atol=0., restart=None, maxiter=None, M=No
 
         # Legacy exit
         if callback_type == 'legacy' and inner_iter == maxiter:
-            return postprocess(x), 0 if rnorm <= atol else maxiter
+            return x, 0 if rnorm <= atol else maxiter
 
         if callback_type == 'x':
             callback(x)
@@ -838,12 +843,13 @@ def gmres(A, b, x0=None, *, rtol=1e-5, atol=0., restart=None, maxiter=None, M=No
         ptol = presid * min(ptol_max_factor, atol / rnorm)
 
     info = 0 if (rnorm <= atol) else maxiter
-    return postprocess(x), info
+    return x, info
 
 
 def qmr(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M1=None, M2=None,
         callback=None):
-    """Use Quasi-Minimal Residual iteration to solve ``Ax = b``.
+    """
+    Solve ``Ax = b`` with the Quasi-Minimal Residual method.
 
     Parameters
     ----------
@@ -901,13 +907,13 @@ def qmr(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M1=None, M2=None,
     True
     """
     A_ = A
-    A, M, x, b, postprocess = make_system(A, None, x0, b)
+    A, M, x, b = make_system(A, None, x0, b)
     bnrm2 = np.linalg.norm(b)
 
     atol, _ = _get_atol_rtol('qmr', bnrm2, atol, rtol)
 
     if bnrm2 == 0:
-        return postprocess(b), 0
+        return b, 0
 
     if M1 is None and M2 is None:
         if hasattr(A_, 'psolve'):
@@ -964,11 +970,11 @@ def qmr(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M1=None, M2=None,
 
     for iteration in range(maxiter):
         if np.linalg.norm(r) < atol:  # Are we done?
-            return postprocess(x), 0
+            return x, 0
         if np.abs(rho) < rhotol:  # rho breakdown
-            return postprocess(x), -10
+            return x, -10
         if np.abs(xi) < xitol:  # xi breakdown
-            return postprocess(x), -15
+            return x, -15
 
         v[:] = vtilde[:]
         v *= (1 / rho)
@@ -979,7 +985,7 @@ def qmr(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M1=None, M2=None,
         delta = dotprod(z, y)
 
         if np.abs(delta) < deltatol:  # delta breakdown
-            return postprocess(x), -13
+            return x, -13
 
         ytilde = M2.matvec(y)
         ztilde = M1.rmatvec(z)
@@ -996,11 +1002,11 @@ def qmr(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M1=None, M2=None,
         ptilde = A.matvec(p)
         epsilon = dotprod(q, ptilde)
         if np.abs(epsilon) < epsilontol:  # epsilon breakdown
-            return postprocess(x), -14
+            return x, -14
 
         beta = epsilon / delta
         if np.abs(beta) < betatol:  # beta breakdown
-            return postprocess(x), -11
+            return x, -11
 
         vtilde[:] = ptilde[:]
         vtilde -= beta*v
@@ -1019,7 +1025,7 @@ def qmr(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M1=None, M2=None,
         gamma = 1 / np.sqrt(1 + theta**2)
 
         if np.abs(gamma) < gammatol:  # gamma breakdown
-            return postprocess(x), -12
+            return x, -12
 
         eta *= -(rho_prev / beta) * (gamma / gamma_prev)**2
 
@@ -1042,4 +1048,4 @@ def qmr(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M1=None, M2=None,
 
     else:  # for loop exhausted
         # Return incomplete progress
-        return postprocess(x), maxiter
+        return x, maxiter

scipy/sparse/linalg/_isolve/lgmres.py

@@ -16,7 +16,7 @@ def lgmres(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=1000, M=None, callback=
            inner_m=30, outer_k=3, outer_v=None, store_outer_Av=True,
            prepend_outer_v=False):
     """
-    Solve a matrix equation using the LGMRES algorithm.
+    Solve ``Ax = b`` with the LGMRES algorithm.
 
     The LGMRES algorithm [1]_ [2]_ is designed to avoid some problems
     in the convergence in restarted GMRES, and often converges in fewer
@@ -119,7 +119,7 @@ def lgmres(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=1000, M=None, callback=
     >>> np.allclose(A.dot(x), b)
     True
     """
-    A,M,x,b,postprocess = make_system(A,M,x0,b)
+    A,M,x,b = make_system(A,M,x0,b)
 
     if not np.isfinite(b).all():
         raise ValueError("RHS must contain only finite numbers")
@@ -140,7 +140,7 @@ def lgmres(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=1000, M=None, callback=
 
     if b_norm == 0:
         x = b
-        return (postprocess(x), 0)
+        return (x, 0)
 
     ptol_max_factor = 1.0
 
@@ -192,7 +192,7 @@ def lgmres(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=1000, M=None, callback=
         except LinAlgError:
             # Floating point over/underflow, non-finite result from
             # matmul etc. -- report failure.
-            return postprocess(x), k_outer + 1
+            return x, k_outer + 1
 
         # Inner loop tolerance control
         if pres > ptol:
@@ -225,6 +225,6 @@ def lgmres(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=1000, M=None, callback=
         x += dx
     else:
         # didn't converge ...
-        return postprocess(x), maxiter
+        return x, maxiter
 
-    return postprocess(x), 0
+    return x, 0

scipy/sparse/linalg/_isolve/minres.py

@@ -10,7 +10,7 @@ __all__ = ['minres']
 def minres(A, b, x0=None, *, rtol=1e-5, shift=0.0, maxiter=None,
            M=None, callback=None, show=False, check=False):
     """
-    Use MINimum RESidual iteration to solve Ax=b
+    Solve ``Ax = b`` with the MINimum RESidual method, for a symmetric `A`.
 
     MINRES minimizes norm(Ax - b) for a real symmetric matrix A.  Unlike
     the Conjugate Gradient method, A can be indefinite or singular.
@@ -89,7 +89,7 @@ def minres(A, b, x0=None, *, rtol=1e-5, shift=0.0, maxiter=None,
         https://web.stanford.edu/group/SOL/software/minres/minres-matlab.zip
 
     """
-    A, M, x, b, postprocess = make_system(A, M, x0, b)
+    A, M, x, b = make_system(A, M, x0, b)
 
     matvec = A.matvec
     psolve = M.matvec
@@ -146,12 +146,12 @@ def minres(A, b, x0=None, *, rtol=1e-5, shift=0.0, maxiter=None,
     if beta1 < 0:
         raise ValueError('indefinite preconditioner')
     elif beta1 == 0:
-        return (postprocess(x), 0)
+        return (x, 0)
 
     bnorm = norm(b)
     if bnorm == 0:
         x = b
-        return (postprocess(x), 0)
+        return (x, 0)
 
     beta1 = sqrt(beta1)
 
@@ -369,4 +369,4 @@ def minres(A, b, x0=None, *, rtol=1e-5, shift=0.0, maxiter=None,
     else:
         info = 0
 
-    return (postprocess(x),info)
+    return (x,info)

scipy/sparse/linalg/_isolve/tfqmr.py

@@ -9,7 +9,7 @@ __all__ = ['tfqmr']
 def tfqmr(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M=None,
           callback=None, show=False):
     """
-    Use Transpose-Free Quasi-Minimal Residual iteration to solve ``Ax = b``.
+    Solve ``Ax = b`` with the Transpose-Free Quasi-Minimal Residual method.
 
     Parameters
     ----------
@@ -97,12 +97,12 @@ def tfqmr(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M=None,
     if np.issubdtype(b.dtype, np.int64):
         b = b.astype(dtype)
 
-    A, M, x, b, postprocess = make_system(A, M, x0, b)
+    A, M, x, b = make_system(A, M, x0, b)
 
     # Check if the R.H.S is a zero vector
     if np.linalg.norm(b) == 0.:
         x = b.copy()
-        return (postprocess(x), 0)
+        return (x, 0)
 
     ndofs = A.shape[0]
     if maxiter is None:
@@ -125,7 +125,7 @@ def tfqmr(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M=None,
     r0norm = np.sqrt(rho)
     tau = r0norm
     if r0norm == 0:
-        return (postprocess(x), 0)
+        return (x, 0)
 
     # we call this to get the right atol and raise errors as necessary
     atol, _ = _get_atol_rtol('tfqmr', r0norm, atol, rtol)
@@ -136,7 +136,7 @@ def tfqmr(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M=None,
             vtrstar = np.inner(rstar.conjugate(), v)
             # Check breakdown
             if vtrstar == 0.:
-                return (postprocess(x), -1)
+                return (x, -1)
             alpha = rho / vtrstar
             uNext = u - alpha * v  # [1]-(5.6)
         w -= alpha * uhat  # [1]-(5.8)
@@ -158,7 +158,7 @@ def tfqmr(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M=None,
             if (show):
                 print("TFQMR: Linear solve converged due to reach TOL "
                       f"iterations {iter+1}")
-            return (postprocess(x), 0)
+            return (x, 0)
 
         if (not even):
             # [1]-(5.7)
@@ -176,4 +176,4 @@ def tfqmr(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=None, M=None,
     if (show):
         print("TFQMR: Linear solve not converged due to reach MAXIT "
               f"iterations {iter+1}")
-    return (postprocess(x), maxiter)
+    return (x, maxiter)

scipy/sparse/linalg/_isolve/utils.py

@@ -47,7 +47,7 @@ def make_system(A, M, x0, b):
 
     Returns
     -------
-    (A, M, x, b, postprocess)
+    (A, M, x, b)
         A : LinearOperator
             matrix of the linear system
         M : LinearOperator
@@ -56,9 +56,6 @@ def make_system(A, M, x0, b):
             initial guess
         b : rank 1 ndarray
             right hand side
-        postprocess : function
-            converts the solution vector to the appropriate
-            type and dimensions (e.g. (N,1) matrix)
 
     """
     A_ = A
@@ -78,9 +75,6 @@ def make_system(A, M, x0, b):
     if b.dtype.char not in 'fdFD':
         b = b.astype('d')  # upcast non-FP types to double
 
-    def postprocess(x):
-        return x
-
     if hasattr(A,'dtype'):
         xtype = A.dtype.char
     else:
@@ -124,4 +118,4 @@ def make_system(A, M, x0, b):
                              f'x0 {x.shape} are incompatible')
         x = x.ravel()
 
-    return A, M, x, b, postprocess
+    return A, M, x, b

scipy/sparse/linalg/_matfuncs.py

@@ -596,7 +596,7 @@ def _expm(A, use_exact_onenorm):
     # algorithms.
 
     # Avoid indiscriminate asarray() to allow sparse or other strange arrays.
-    if isinstance(A, (list, tuple, np.matrix)):
+    if isinstance(A, list | tuple | np.matrix):
         A = np.asarray(A)
     if len(A.shape) != 2 or A.shape[0] != A.shape[1]:
         raise ValueError('expected a square matrix')

scipy/sparse/linalg/_norm.py

@@ -107,7 +107,7 @@ def norm(x, ord=None, axis=None):
     The matrix 2-norm or the spectral norm is the largest singular
     value, computed approximately and with limitations.
 
-    >>> b = diags_array([-1, 1], [0, 1], shape=(9, 10))
+    >>> b = diags_array([-1, 1], offsets=[0, 1], shape=(9, 10))
     >>> norm(b, 2)
     1.9753...
     """