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

scipy/sparse/linalg/_eigen/arpack/arpack.py

@@ -284,6 +284,7 @@ class ArpackError(RuntimeError):
         super().__init__(f"ARPACK error {info}: {msg}")
 
 
+
 class ArpackNoConvergence(ArpackError):
     """
     ARPACK iteration did not converge
@@ -315,12 +316,12 @@ class _ArpackParams:
     def __init__(self, n, k, tp, mode=1, sigma=None,
                  ncv=None, v0=None, maxiter=None, which="LM", tol=0):
         if k <= 0:
-            raise ValueError("k must be positive, k=%d" % k)
+            raise ValueError(f"k must be positive, k={k}")
 
         if maxiter is None:
             maxiter = n * 10
         if maxiter <= 0:
-            raise ValueError("maxiter must be positive, maxiter=%d" % maxiter)
+            raise ValueError(f"maxiter must be positive, maxiter={maxiter}")
 
         if tp not in 'fdFD':
             # Use `float64` libraries from integer dtypes.
@@ -510,12 +511,12 @@ class _SymmetricArpackParams(_ArpackParams):
                 self.B = M_matvec
                 self.bmat = 'G'
         else:
-            raise ValueError("mode=%i not implemented" % mode)
+            raise ValueError(f"mode={mode} not implemented")
 
         if which not in _SEUPD_WHICH:
             raise ValueError(f"which must be one of {' '.join(_SEUPD_WHICH)}")
         if k >= n:
-            raise ValueError("k must be less than ndim(A), k=%d" % k)
+            raise ValueError(f"k must be less than ndim(A), k={k}")
 
         _ArpackParams.__init__(self, n, k, tp, mode, sigma,
                                ncv, v0, maxiter, which, tol)
@@ -692,12 +693,12 @@ class _UnsymmetricArpackParams(_ArpackParams):
                 self.bmat = 'G'
                 self.OP = lambda x: self.OPa(M_matvec(x))
         else:
-            raise ValueError("mode=%i not implemented" % mode)
+            raise ValueError(f"mode={mode} not implemented")
 
         if which not in _NEUPD_WHICH:
             raise ValueError(f"Parameter which must be one of {' '.join(_NEUPD_WHICH)}")
         if k >= n - 1:
-            raise ValueError("k must be less than ndim(A)-1, k=%d" % k)
+            raise ValueError(f"k must be less than ndim(A)-1, k={k}")
 
         _ArpackParams.__init__(self, n, k, tp, mode, sigma,
                                ncv, v0, maxiter, which, tol)
@@ -979,9 +980,10 @@ class IterInv(LinearOperator):
     def _matvec(self, x):
         b, info = self.ifunc(self.M, x, tol=self.tol)
         if info != 0:
-            raise ValueError("Error in inverting M: function "
-                             "%s did not converge (info = %i)."
-                             % (self.ifunc.__name__, info))
+            raise ValueError(
+                f"Error in inverting M: function {self.ifunc.__name__} "
+                f"did not converge (info = {info})."
+            )
         return b
 
 
@@ -1026,9 +1028,10 @@ class IterOpInv(LinearOperator):
     def _matvec(self, x):
         b, info = self.ifunc(self.OP, x, tol=self.tol)
         if info != 0:
-            raise ValueError("Error in inverting [A-sigma*M]: function "
-                             "%s did not converge (info = %i)."
-                             % (self.ifunc.__name__, info))
+            raise ValueError(
+                f"Error in inverting [A-sigma*M]: function {self.ifunc.__name__} "
+                f"did not converge (info = {info})."
+            )
         return b
 
     @property
@@ -1268,7 +1271,7 @@ def eigs(A, k=6, M=None, sigma=None, which='LM', v0=None,
     n = A.shape[0]
 
     if k <= 0:
-        raise ValueError("k=%d must be greater than 0." % k)
+        raise ValueError(f"k={k} must be greater than 0.")
 
     if k >= n - 1:
         warnings.warn("k >= N - 1 for N * N square matrix. "
@@ -1424,16 +1427,19 @@ def eigsh(A, k=6, M=None, sigma=None, which='LM', v0=None,
         unspecified.  This is computed internally via a (sparse) LU
         decomposition for explicit matrices A & M, or via an iterative
         solver if either A or M is a general linear operator.
-        Alternatively, the user can supply the matrix or operator OPinv,
+        Alternatively, the user can supply the matrix or operator `OPinv`,
         which gives ``x = OPinv @ b = [A - sigma * M]^-1 @ b``.
+        Regardless of the selected mode (normal, cayley, or buckling),
+        `OPinv` should always be supplied as ``OPinv = [A - sigma * M]^-1``.
+
         Note that when sigma is specified, the keyword 'which' refers to
         the shifted eigenvalues ``w'[i]`` where:
 
-            if mode == 'normal', ``w'[i] = 1 / (w[i] - sigma)``.
+            if ``mode == 'normal'``: ``w'[i] = 1 / (w[i] - sigma)``.
 
-            if mode == 'cayley', ``w'[i] = (w[i] + sigma) / (w[i] - sigma)``.
+            if ``mode == 'cayley'``:  ``w'[i] = (w[i] + sigma) / (w[i] - sigma)``.
 
-            if mode == 'buckling', ``w'[i] = w[i] / (w[i] - sigma)``.
+            if ``mode == 'buckling'``: ``w'[i] = w[i] / (w[i] - sigma)``.
 
         (see further discussion in 'mode' below)
     v0 : ndarray, optional

scipy/sparse/linalg/_eigen/lobpcg/lobpcg.py

@@ -307,7 +307,7 @@ def lobpcg(
     ``A x = lambda x`` without constraints or preconditioning.
 
     >>> import numpy as np
-    >>> from scipy.sparse import spdiags
+    >>> from scipy.sparse import diags_array
     >>> from scipy.sparse.linalg import LinearOperator, aslinearoperator
     >>> from scipy.sparse.linalg import lobpcg
 
@@ -323,7 +323,7 @@ def lobpcg(
     the sparse diagonal matrix `A`
     of the eigenvalue problem ``A x = lambda x`` to solve.
 
-    >>> A = spdiags(vals, 0, n, n)
+    >>> A = diags_array(vals, offsets=0, shape=(n, n))
     >>> A = A.astype(np.int16)
     >>> A.toarray()
     array([[  1,   0,   0, ...,   0,   0,   0],
@@ -507,15 +507,15 @@ def lobpcg(
         if M is None:
             aux += "out"
         aux += " preconditioning\n\n"
-        aux += "matrix size %d\n" % n
-        aux += "block size %d\n\n" % sizeX
+        aux += f"matrix size {n}\n"
+        aux += f"block size {sizeX}\n\n"
         if blockVectorY is None:
             aux += "No constraints\n\n"
         else:
             if sizeY > 1:
-                aux += "%d constraints\n\n" % sizeY
+                aux += f"{sizeY} constraints\n\n"
             else:
-                aux += "%d constraint\n\n" % sizeY
+                aux += f"{sizeY} constraint\n\n"
         print(aux)
 
     if (n - sizeY) < (5 * sizeX):

scipy/sparse/linalg/_interface.py

@@ -55,14 +55,14 @@ __all__ = ['LinearOperator', 'aslinearoperator']
 class LinearOperator:
     """Common interface for performing matrix vector products
 
-    Many iterative methods (e.g. cg, gmres) do not need to know the
-    individual entries of a matrix to solve a linear system A@x=b.
+    Many iterative methods (e.g. `cg`, `gmres`) do not need to know the
+    individual entries of a matrix to solve a linear system ``A@x = b``.
     Such solvers only require the computation of matrix vector
-    products, A@v where v is a dense vector.  This class serves as
+    products, ``A@v`` where ``v`` is a dense vector.  This class serves as
     an abstract interface between iterative solvers and matrix-like
     objects.
 
-    To construct a concrete LinearOperator, either pass appropriate
+    To construct a concrete `LinearOperator`, either pass appropriate
     callables to the constructor of this class, or subclass it.
 
     A subclass must implement either one of the methods ``_matvec``
@@ -82,17 +82,17 @@ class LinearOperator:
     Parameters
     ----------
     shape : tuple
-        Matrix dimensions (M, N).
+        Matrix dimensions ``(M, N)``.
     matvec : callable f(v)
-        Returns returns A @ v.
+        Returns returns ``A @ v``.
     rmatvec : callable f(v)
-        Returns A^H @ v, where A^H is the conjugate transpose of A.
+        Returns ``A^H @ v``, where ``A^H`` is the conjugate transpose of ``A``.
     matmat : callable f(V)
-        Returns A @ V, where V is a dense matrix with dimensions (N, K).
+        Returns ``A @ V``, where ``V`` is a dense matrix with dimensions ``(N, K)``.
     dtype : dtype
         Data type of the matrix.
     rmatmat : callable f(V)
-        Returns A^H @ V, where V is a dense matrix with dimensions (M, K).
+        Returns ``A^H @ V``, where ``V`` is a dense matrix with dimensions ``(M, K)``.
 
     Attributes
     ----------
@@ -108,17 +108,17 @@ class LinearOperator:
 
     Notes
     -----
-    The user-defined matvec() function must properly handle the case
-    where v has shape (N,) as well as the (N,1) case.  The shape of
-    the return type is handled internally by LinearOperator.
+    The user-defined `matvec` function must properly handle the case
+    where ``v`` has shape ``(N,)`` as well as the ``(N,1)`` case.  The shape of
+    the return type is handled internally by `LinearOperator`.
 
     It is highly recommended to explicitly specify the `dtype`, otherwise
     it is determined automatically at the cost of a single matvec application
-    on `int8` zero vector using the promoted `dtype` of the output.
-    Python `int` could be difficult to automatically cast to numpy integers
+    on ``int8`` zero vector using the promoted `dtype` of the output.
+    Python ``int`` could be difficult to automatically cast to numpy integers
     in the definition of the `matvec` so the determination may be inaccurate.
     It is assumed that `matmat`, `rmatvec`, and `rmatmat` would result in
-    the same dtype of the output given an `int8` input as `matvec`.
+    the same dtype of the output given an ``int8`` input as `matvec`.
 
     LinearOperator instances can also be multiplied, added with each
     other and exponentiated, all lazily: the result of these operations
@@ -403,8 +403,7 @@ class LinearOperator:
             X = np.asanyarray(X)
 
         if X.ndim != 2:
-            raise ValueError('expected 2-d ndarray or matrix, not %d-d'
-                             % X.ndim)
+            raise ValueError(f'expected 2-d ndarray or matrix, not {X.ndim}-d')
 
         if X.shape[0] != self.shape[0]:
             raise ValueError(f'dimension mismatch: {self.shape}, {X.shape}')
@@ -552,7 +551,7 @@ class LinearOperator:
         else:
             dt = 'dtype=' + str(self.dtype)
 
-        return '<%dx%d %s with %s>' % (M, N, self.__class__.__name__, dt)
+        return f'<{M}x{N} {self.__class__.__name__} with {dt}>'
 
     def adjoint(self):
         """Hermitian adjoint.

scipy/sparse/linalg/_isolve/_gcrotmk.py

@@ -184,7 +184,7 @@ def _fgmres(matvec, v0, m, atol, lpsolve=None, rpsolve=None, cs=(), outer_v=(),
 def gcrotmk(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=1000, M=None, callback=None,
             m=20, k=None, CU=None, discard_C=False, truncate='oldest'):
     """
-    Solve a matrix equation using flexible GCROT(m,k) algorithm.
+    Solve ``Ax = b`` with the flexible GCROT(m,k) algorithm.
 
     Parameters
     ----------
@@ -273,7 +273,7 @@ def gcrotmk(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=1000, M=None, callback
     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")
@@ -306,7 +306,7 @@ def gcrotmk(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)
 
     if discard_C:
         CU[:] = [(None, u) for c, u in CU]
@@ -500,4 +500,4 @@ def gcrotmk(A, b, x0=None, *, rtol=1e-5, atol=0., maxiter=1000, M=None, callback
     if discard_C:
         CU[:] = [(None, uz) for cz, uz in CU]
 
-    return postprocess(x), j_outer + 1
+    return x, j_outer + 1

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