Class CGSolver

python/krylovspace.py:227–290

    
    
class CGSolver(LinearSolver):
    """Preconditioned conjugate gradient method

    Parameters
    ----------

""" + linear_solver_param_doc + """

conjugate : bool = False
  If set to True, then the complex inner product is used, else a pseudo inner product that makes CG work with complex symmetric matrices.
"""
    name = "CG"

    def __init__(self, *args,
                 conjugate : bool = False,
                 abstol : float = None,
                 maxsteps : int = None,
                 printing : bool = False,
                 **kwargs):
        if printing:
            print("WARNING: printing is deprecated, use printrates instead!")
            kwargs["printrates"] = printing
        if abstol is not None:
            print("WARNING: abstol is deprecated, use atol instead!")
            kwargs["abstol"] = abstol
        if maxsteps is not None:
            print("WARNING: maxsteps is deprecated, use maxiter instead!")
            kwargs["maxiter"] = maxsteps
        super().__init__(*args, **kwargs)
        self.conjugate = conjugate

    # for backward compatibility
    @property
    def errors(self):
        return self.residuals

    def _SolveImpl(self, rhs : BaseVector, sol : BaseVector):
        d, w, s = [sol.CreateVector() for i in range(3)]
        conjugate = self.conjugate
        d.data = rhs - self.mat * sol
        w.data = self.pre * d
        s.data = w
        wdn = w.InnerProduct(d, conjugate=conjugate)
        if self.CheckResidual(sqrt(abs(wdn))):
            return

        while True:
            w.data = self.mat * s
            wd = wdn
            as_s = s.InnerProduct(w, conjugate=conjugate)        
            if as_s == 0 or wd == 0: break
            alpha = wd / as_s
            sol.data += alpha * s
            d.data += (-alpha) * w

            w.data = self.pre * d

            wdn = w.InnerProduct(d, conjugate=conjugate)