Skip to main content
`Ctrl`+`K`
scipy.sparse.linalg.

# cgs

scipy.sparse.linalg.cgs(A, b, x0=None, *, rtol=1e-05, atol=0.0, maxiter=None, M=None, callback=None)

  Solve `Ax = b` with the Conjugate Gradient Squared method.

  Parameters:
    A{sparse array, ndarray, LinearOperator}

      The real-valued N-by-N matrix of the linear system. Alternatively, A can be a linear operator which can produce `Ax` using, e.g., `scipy.sparse.linalg.LinearOperator`.

    b ndarray

      Right hand side of the linear system. Has shape (N,) or (N,1).

    x0 ndarray

      Starting guess for the solution.

    rtol, atol float, optional

      Parameters for the convergence test. For convergence, `norm(b - A @ x) <= max(rtol*norm(b), atol)` should be satisfied. The default is `atol=0.` and `rtol=1e-5`.

    maxiter integer

      Maximum number of iterations. Iteration will stop after maxiter steps even if the specified tolerance has not been achieved.

    M{sparse array, ndarray, LinearOperator}

      Preconditioner for `A`. It should approximate the inverse of A (see Notes). Effective preconditioning dramatically improves the rate of convergence, which implies that fewer iterations are needed to reach a given error tolerance.

    callback function

      User-supplied function to call after each iteration. It is called as `callback(xk)`, where `xk` is the current solution vector.

  Returns:
    x ndarray

      The converged solution.

    info integer
      Provides convergence information:

        0 : successful exit >0 : convergence to tolerance not achieved, number of iterations <0 : parameter breakdown

  Notes

  The preconditioner M should be a matrix such that `M @ A` has a smaller condition number than A, see [1].

  References

  [1]

  “Preconditioner”, Wikipedia, https://en.wikipedia.org/wiki/Preconditioner

  [2]

  “Conjugate gradient squared”, Wikipedia, https://en.wikipedia.org/wiki/Conjugate_gradient_squared_method

  Examples

      >>> import numpy as np
      >>> from scipy.sparse import csc_array
      >>> from scipy.sparse.linalg import cgs
      >>> R = np.array([[4, 2, 0, 1],
      ...               [3, 0, 0, 2],
      ...               [0, 1, 1, 1],
      ...               [0, 2, 1, 0]])
      >>> A = csc_array(R)
      >>> b = np.array([-1, -0.5, -1, 2])
      >>> x, exit_code = cgs(A, b)
      >>> print(exit_code)  # 0 indicates successful convergence
      0
      >>> np.allclose(A.dot(x), b)
      True