Gmres Class Reference

#include <gmres.h>

Inheritance diagram for Gmres:

Collaboration diagram for Gmres:

Public Member Functions
	Gmres (const Preconditioner::PrecondType PType, const integer iPStep, doublereal ITol, integer MaxIt, doublereal etaMx, doublereal T, const NonlinearSolverOptions &options)
	~Gmres (void)
virtual void	Solve (const NonlinearProblem *NLP, Solver *pS, const integer iMaxIter, const doublereal &Tol, integer &iIterCnt, doublereal &dErr, const doublereal &SolTol, doublereal &dSolErr)
Public Member Functions inherited from MatrixFreeSolver
	MatrixFreeSolver (const Preconditioner::PrecondType PType, const integer iPStep, doublereal ITol, integer MaxIt, doublereal etaMx, doublereal T, const NonlinearSolverOptions &options)
	~MatrixFreeSolver (void)
Public Member Functions inherited from NonlinearSolver
	NonlinearSolver (const NonlinearSolverOptions &options)
virtual void	SetTest (NonlinearSolverTest *pr, NonlinearSolverTest *ps)
virtual	~NonlinearSolver (void)
virtual bool	MakeResTest (Solver *pS, const NonlinearProblem *pNLP, const VectorHandler &Vec, const doublereal &dTol, doublereal &dTest, doublereal &dTestDiff)
virtual integer	TotalAssembledJacobian (void)
virtual NonlinearSolverTest *	pGetResTest (void)
virtual NonlinearSolverTest *	pGetSolTest (void)
Public Member Functions inherited from SolverDiagnostics
	SolverDiagnostics (unsigned OF=OUTPUT_DEFAULT, DriveCaller *pOM=0)
virtual	~SolverDiagnostics (void)
void	SetNoOutput (void)
void	SetOutputMeter (DriveCaller *pOM)
void	SetOutputDriveHandler (const DriveHandler *pDH)
void	SetOutputFlags (unsigned OF)
void	AddOutputFlags (unsigned OF)
void	DelOutputFlags (unsigned OF)
MatrixHandler::Norm_t	GetCondMatNorm (void) const
bool	outputMeter (void) const
bool	outputIters (void) const
bool	outputRes (void) const
bool	outputSol (void) const
bool	outputJac (void) const
bool	outputStep (void) const
bool	outputBailout (void) const
bool	outputCounter (void) const
bool	outputMatrixConditionNumber (void) const
bool	outputSolverConditionNumber (void) const
bool	outputSolverConditionStat (void) const
bool	outputCPUTime (void) const
bool	outputMsg (void) const

Private Member Functions
void	GeneratePlaneRotation (const doublereal &dx, const doublereal &dy, doublereal &cs, doublereal &sn) const
void	ApplyPlaneRotation (doublereal &dx, doublereal &dy, const doublereal &cs, const doublereal &sn) const
void	Backsolve (VectorHandler &x, integer sz, VectorHandler &s, MyVectorHandler *v)

Private Attributes
MyVectorHandler *	v
MyVectorHandler	s
MyVectorHandler	cs
MyVectorHandler	sn
MyVectorHandler	w
MyVectorHandler	vHat
MyVectorHandler	dx
FullMatrixHandler	H

Additional Inherited Members
Public Types inherited from MatrixFreeSolver
enum	SolverType {   UNKNOWN = -1, BICGSTAB, GMRES, DEFAULT = GMRES,   LAST }
Public Types inherited from NonlinearSolver
enum	Type {   UNKNOWN = -1, NEWTONRAPHSON, MATRIXFREE, LINESEARCH,   DEFAULT = NEWTONRAPHSON, LASTSOLVERTYPE }
Protected Types inherited from NonlinearSolver
enum	CPUTimeType { CPU_RESIDUAL, CPU_JACOBIAN, CPU_LINEAR_SOLVER, CPU_LAST_TYPE }
Protected Types inherited from SolverDiagnostics
enum	{   OUTPUT_NONE = 0x0000, OUTPUT_ITERS = 0x0001, OUTPUT_RES = 0x0002, OUTPUT_SOL = 0x0004,   OUTPUT_JAC = 0x0008, OUTPUT_BAILOUT = 0x0010, OUTPUT_MSG = 0x0020, OUTPUT_COUNTER = 0x0040,   OUTPUT_MAT_COND_NUM_1 = 0x0080, OUTPUT_MAT_COND_NUM_INF = 0x0100, OUTPUT_SOLVER_COND_NUM = 0x0200, OUTPUT_SOLVER_COND_STAT = 0x400,   OUTPUT_CPU_TIME = 0x800, OUTPUT_MAT_COND_NUM = OUTPUT_MAT_COND_NUM_1 | OUTPUT_MAT_COND_NUM_INF, OUTPUT_DEFAULT = OUTPUT_MSG, OUTPUT_STEP = (OUTPUT_ITERS | OUTPUT_RES | OUTPUT_SOL | OUTPUT_JAC | OUTPUT_MAT_COND_NUM | OUTPUT_SOLVER_COND_NUM),   OUTPUT_MASK = 0x07FF }
Protected Types inherited from NonlinearSolverOptions
enum	ScaleFlags { SCALE_ALGEBRAIC_EQUATIONS_NO = 0, SCALE_ALGEBRAIC_EQUATIONS_YES = 1 }
Protected Member Functions inherited from NonlinearSolver
virtual bool	MakeSolTest (Solver *pS, const VectorHandler &Vec, const doublereal &dTol, doublereal &dTest)
doublereal	dGetCondMax () const
doublereal	dGetCondMin () const
doublereal	dGetCondAvg () const
doublereal	dGetTimeCPU (CPUTimeType eType) const
void	AddCond (doublereal dCond)
void	AddTimeCPU (doublereal dTime, CPUTimeType eType)
Protected Member Functions inherited from NonlinearSolverOptions
	NonlinearSolverOptions (bool bHonorJacRequest=false, enum ScaleFlags eScaleFlags=SCALE_ALGEBRAIC_EQUATIONS_NO, doublereal dScaleAlgebraic=1.)
Protected Attributes inherited from MatrixFreeSolver
Preconditioner *	pPM
VectorHandler *	pRes
doublereal	IterTol
integer	MaxLinIt
doublereal	Tau
doublereal	gamma
doublereal	etaMax
integer	PrecondIter
bool	bBuildMat
const NonlinearProblem *	pPrevNLP
Protected Attributes inherited from NonlinearSolver
integer	Size
integer	TotJac
NonlinearSolverTest *	pResTest
NonlinearSolverTest *	pSolTest
Protected Attributes inherited from SolverDiagnostics
unsigned	OutputFlags
DriveCaller *	pOutputMeter
Protected Attributes inherited from NonlinearSolverOptions
bool	bHonorJacRequest
enum NonlinearSolverOptions::ScaleFlags	eScaleFlags
doublereal	dScaleAlgebraic

Detailed Description

Definition at line 46 of file gmres.h.

Constructor & Destructor Documentation

Gmres::Gmres	(	const Preconditioner::PrecondType	PType,
		const integer	iPStep,
		doublereal	ITol,
		integer	MaxIt,
		doublereal	etaMx,
		doublereal	T,
		const NonlinearSolverOptions &	options
	)

Definition at line 57 of file gmres.cc.

References MatrixFreeSolver::MaxLinIt, SAFENEWARRNOFILL, and v.

: MatrixFreeSolver(PType, iPStep, ITol, MaxIt, etaMx, T, options),
v(NULL),
s(MaxLinIt + 1), cs(MaxLinIt + 1), sn(MaxLinIt + 1)
{
        SAFENEWARRNOFILL(v, MyVectorHandler, MaxLinIt + 1); 
}

Gmres::~Gmres

(

void

)

Definition at line 71 of file gmres.cc.

References MyVectorHandler::Detach(), MatrixFreeSolver::MaxLinIt, SAFEDELETEARR, and v.

{
        for (int i = 0; i < MaxLinIt + 1; i++) {
                v[i].Detach();
        }

        SAFEDELETEARR(v);
}

Here is the call graph for this function:

Member Function Documentation

void Gmres::ApplyPlaneRotation ( doublereal &  dx, doublereal &  dy, const doublereal &  cs, const doublereal &  sn  ) const

private

Definition at line 101 of file gmres.cc.

Referenced by Solve().

{ 
        doublereal temp = cs * dx + sn * dy; 
        dy = -sn * dx + cs * dy;
        dx = temp;
}

void Gmres::Backsolve ( VectorHandler &  x, integer  sz, VectorHandler &  s, MyVectorHandler *  v  )

private

Definition at line 110 of file gmres.cc.

References VectorHandler::DecCoef(), H, VectorHandler::PutCoef(), s, and VectorHandler::ScalarAddMul().

Referenced by Solve().

{ 
        for (int i = sz+1; i > 0; i--) {
                s.PutCoef(i, s(i) / H(i, i));
                for (int j = i - 1; j > 0; j--) {
                        s.DecCoef(j, H(j, i) * s(i));
                }
        }

        for (int j = 0; j <= sz; j++) {
                x.ScalarAddMul(v[j], s(j+1));
        }
}

Here is the call graph for this function:

void Gmres::GeneratePlaneRotation ( const doublereal &  dx, const doublereal &  dy, doublereal &  cs, doublereal &  sn  ) const

private

Definition at line 81 of file gmres.cc.

References cs, dx, grad::fabs(), sn, and grad::sqrt().

Referenced by Solve().

{
        if (fabs(dy) < std::numeric_limits<doublereal>::epsilon()) {
                cs = 1.0;
                sn = 0.0;

        } else if (fabs(dy) > fabs(dx)) {
                doublereal temp = dx / dy; 
                sn = 1.0 / sqrt( 1.0 + temp*temp );
                cs = temp * sn;

        } else {
                doublereal temp = dy / dx; 
                cs = 1.0 / sqrt( 1.0 + temp*temp );
                sn = temp * cs;
        }
}

Here is the call graph for this function:

void Gmres::Solve ( const NonlinearProblem *  NLP, Solver *  pS, const integer  iMaxIter, const doublereal &  Tol, integer &  iIterCnt, doublereal &  dErr, const doublereal &  SolTol, doublereal &  dSolErr  )

virtual

Implements NonlinearSolver.

Definition at line 126 of file gmres.cc.

References ApplyPlaneRotation(), ASSERT, Backsolve(), MatrixFreeSolver::bBuildMat, NonlinearSolverOptions::bHonorJacRequest, Solver::CheckTimeStepLimit(), cs, DEBUGCOUT, dx, MatrixFreeSolver::etaMax, NonlinearProblem::EvalProd(), grad::fabs(), MatrixFreeSolver::gamma, GeneratePlaneRotation(), H, VectorHandler::iGetSize(), VectorHandler::InnerProd(), NonlinearProblem::Jacobian(), NonlinearSolver::MakeResTest(), NonlinearSolver::MakeSolTest(), SolutionManager::MatrInitialize(), SolutionManager::MatrReset(), MatrixFreeSolver::MaxLinIt, MBDYN_EXCEPT_ARGS, mbdyn_stop_at_end_of_iteration(), VectorHandler::Norm(), SolverDiagnostics::outputBailout(), SolverDiagnostics::outputIters(), SolverDiagnostics::outputRes(), SolverDiagnostics::outputSol(), Solver::pGetSolutionManager(), SolutionManager::pMatHdl(), MatrixFreeSolver::pPM, MatrixFreeSolver::pPrevNLP, Preconditioner::Precond(), MatrixFreeSolver::PrecondIter, MatrixFreeSolver::pRes, SolutionManager::pResHdl(), Solver::PrintResidual(), Solver::PrintSolution(), MyVectorHandler::PutCoef(), VectorHandler::Reset(), MyVectorHandler::Reset(), NonlinearProblem::Residual(), FullMatrixHandler::Resize(), MyVectorHandler::Resize(), s, MyVectorHandler::ScalarAddMul(), MyVectorHandler::ScalarMul(), NonlinearSolver::Size, sn, MatrixFreeSolver::Tau, NonlinearSolver::TotJac, NonlinearProblem::Update(), v, vHat, and w.

{
        ASSERT(pNLP != NULL);
        ASSERT(pS != NULL);

        SolutionManager *pSM = pS->pGetSolutionManager();
        
        iIterCnt = 0;
        dSolErr = 0.;
        doublereal dErrDiff = 0.;

        /* external nonlinear iteration */      
        
        /* riassembla sempre lo jacobiano se l'integratore e' nuovo */
        if (pNLP != pPrevNLP) {
                bBuildMat = true;
        }
        
        pPrevNLP = pNLP;
        
        pRes = pSM->pResHdl();
        Size = pRes->iGetSize();

        doublereal eta = etaMax;
        doublereal rateo = 0.;
        doublereal Fnorm = 1.;
        doublereal resid;
        doublereal norm1, norm2;
        VectorHandler* pr;

        /*
         * these will be resized (actually allocated)
         * only the first time they're used, unless
         * the size of the problem changes
         *
         * FIXME: need to review this code.
         */
        w.Resize(Size);
        vHat.Resize(Size);
        dx.Resize(Size);

        H.Resize(Size, MaxLinIt + 1);

        integer TotalIter = 0;

#ifdef DEBUG_ITERATIVE
        std::cout << " Gmres New Step " << std::endl;
#endif /* DEBUG_ITERATIVE */

        doublereal dOldErr = 0.;
        doublereal dErrFactor = 1.;
        while (true) {

#ifdef  USE_EXTERNAL    
                SendExternal();
#endif /* USE_EXTERNAL */
                pRes->Reset();
                try {
                        pNLP->Residual(pRes);
                }
                catch (SolutionDataManager::ChangedEquationStructure) {
                        if (bHonorJacRequest) {
                                bBuildMat = true;
                        }
                }
                
                if (outputRes()) {
                        pS->PrintResidual(*pRes, iIterCnt);
                }

                bool bTest = MakeResTest(pS, pNLP, *pRes, Tol, dErr, dErrDiff);
                if (iIterCnt > 0) {
                        dErrFactor *= dErr/dOldErr;
                }
                dOldErr = dErr;

#ifdef DEBUG_ITERATIVE
                std::cerr << "dErr " << dErr << std::endl;
#endif /* DEBUG_ITERATIVE */

                if (outputIters()) {
#ifdef USE_MPI
                        if (!bParallel || MBDynComm.Get_rank() == 0)
#endif /* USE_MPI */
                        {
                                silent_cout("\tIteration(" << iIterCnt << ") " << dErr);
                                if (bBuildMat && !bTest) {
                                        silent_cout(" J");
                                }
                                silent_cout(std::endl);
                        }
                }
                
                pS->CheckTimeStepLimit(dErr, dErrDiff);

                if (bTest) {
                        return;
                }
                if (!std::isfinite(dErr)) {
                        throw ErrSimulationDiverged(MBDYN_EXCEPT_ARGS);
                }
                if (iIterCnt >= std::abs(iMaxIter)) {
                        if (iMaxIter < 0 && dErrFactor < 1.) {
                                return;
                        }
                        if (outputBailout()) {
                                pS->PrintResidual(*pRes, iIterCnt);
                        }
                        throw NoConvergence(MBDYN_EXCEPT_ARGS);
                }
                rateo = dErr*dErr/Fnorm;

#ifdef DEBUG_ITERATIVE
                std::cerr << "rateo " << rateo << std::endl;
#endif /* DEBUG_ITERATIVE */

                Fnorm = dErr*dErr;
                
                iIterCnt++;

                /* inner iteration to solve the linear system */        
        
                /* Gmres(m) Iterative solver */
                DEBUGCOUT("Using Gmres(m) iterative solver" << std::endl);

                /* r0 = b- A*x0  but we choose  (x0 = 0)   => r0 = b */
                /* N.B. *pRes = -F(0) */ 
                
                pr = pRes;
                doublereal LocTol = eta * dErr;
 
#ifdef DEBUG_ITERATIVE          
                std::cerr << "LocTol " << LocTol << std::endl;
#endif /* DEBUG_ITERATIVE */
        
                resid = dErr;
                dx.Reset();
                
                if (bBuildMat) {
                        pSM->MatrReset();

rebuild_matrix:;
                        try {
                                pNLP->Jacobian(pSM->pMatHdl());

                        } catch (MatrixHandler::ErrRebuildMatrix) {
                                silent_cout("NewtonRaphsonSolver: "
                                                "rebuilding matrix..."
                                                << std::endl);

                                /* need to rebuild the matrix... */
                                pSM->MatrInitialize();
                                goto rebuild_matrix;

                        } catch (...) {
                                throw;
                        }

                        bBuildMat = false;
                        TotalIter = 0;
                        TotJac++;
                        
#ifdef DEBUG_ITERATIVE
                        std::cerr << "Jacobian " << std::endl;
#endif /* DEBUG_ITERATIVE */

                }

                int i = 0;
                v[0].Resize(Size);
                v[0].ScalarMul(*pr, 1./resid);
                s.Reset();
                cs.Reset();
                sn.Reset();
                s.PutCoef(1, resid);
                while ((i < MaxLinIt)) {

#ifdef DEBUG_ITERATIVE
                        std::cout << "v[i]:" << i << std::endl;
                        for (int iTmpCnt = 1; iTmpCnt <= Size; iTmpCnt++) {
                                std::cout << "Dof" << std::setw(4) << iTmpCnt << ": " 
                                        << v[i](iTmpCnt) << std::endl;
                        }
#endif /* DEBUG_ITERATIVE */

                        pPM->Precond(v[i], vHat, pSM); 

#ifdef DEBUG_ITERATIVE
                        std::cout << "vHat:" << std::endl;
                        for (int iTmpCnt = 1; iTmpCnt <= Size; iTmpCnt++) {
                                std::cout << "Dof" << std::setw(4) << iTmpCnt << ": " 
                                        << vHat(iTmpCnt) << std::endl;
                        }
#endif /* DEBUG_ITERATIVE */

                        pNLP->EvalProd(Tau, *pr, vHat, w);
                        
#if 0
                        (pSM->pMatHdl())->MatVecMul(w, vHat);
#endif

#ifdef DEBUG_ITERATIVE
                        std::cout << "w:" << std::endl;
                        for (int iTmpCnt = 1; iTmpCnt <= Size; iTmpCnt++) {
                                std::cout << "Dof" << std::setw(4) << iTmpCnt << ": " 
                                        << w(iTmpCnt) << std::endl;
                        }
#endif /* DEBUG_ITERATIVE */

                        norm1 = w.Norm();

#ifdef DEBUG_ITERATIVE
                        std::cerr << "norm1: " << norm1 << std::endl; 
#endif /* DEBUG_ITERATIVE */

                        for (int k = 0; k <= i; k++) {
                                H(k+1, i+1) = w.InnerProd(v[k]);

#ifdef DEBUG_ITERATIVE
                                std::cerr << "H(k, i): " << k+1 << " " << i+1 << " "<< H(k+1, i+1) << std::endl; 
#endif /* DEBUG_ITERATIVE */

                                w.ScalarAddMul(v[k], -H(k+1, i+1));
                        }
                        H(i+2, i+1) = w.Norm();

#ifdef DEBUG_ITERATIVE
                        std::cerr << "w.Norm(): " << w.Norm() << std::endl;
                        std::cerr << "H(i+1, i): " << i+2 << " " << i+1 << " " << H(i+2, i+1) << std::endl;
#endif /* DEBUG_ITERATIVE */

                        norm2 = H(i+2, i+1); 

#ifdef DEBUG_ITERATIVE
                        std::cerr << "norm2: " << norm2 << std::endl;
#endif /* DEBUG_ITERATIVE */

                        v[i+1].Resize(Size);
                        
                        /*  Reorthogonalize? */
                        if  (.001*norm2/norm1 < std::numeric_limits<doublereal>::epsilon()) {
                                for (int k = 0;  k <= i; k++) {       
                                        doublereal hr = v[k].InnerProd(w);
                                        H(k+1, i+1) += hr;
                                        w.ScalarAddMul(v[k], -hr);

#ifdef DEBUG_ITERATIVE
                                        std::cerr << "Reorthogonalize: "  << std::endl;
#endif /* DEBUG_ITERATIVE */

                                }
                                H(i+2, i+1) = w.Norm();
                        }
                        if (fabs(H(i+2, i+1)) > std::numeric_limits<doublereal>::epsilon()) { 
                                v[i+1].ScalarMul(w, 1./H(i+2, i+1));

#ifdef DEBUG_ITERATIVE
                                std::cout << "v[i+1]:" << i+1 << std::endl;

                                for (int iTmpCnt = 1; iTmpCnt <= Size; iTmpCnt++) {
                                        std::cout << "Dof" << std::setw(4) << iTmpCnt << ": " 
                                                << v[i+1](iTmpCnt) << std::endl;
                                }
#endif /* DEBUG_ITERATIVE */
                        } else {
                                /* happy breakdown !! */

#ifdef DEBUG_ITERATIVE
                                std::cerr << "happy breakdown: "  << std::endl;
#endif /* DEBUG_ITERATIVE */

                                v[i+1].Reset();
                        } 
                        for (int k = 0; k < i; k++) {
                                ApplyPlaneRotation(H(k+1, i+1), H(k+2, i+1),
                                                cs(k+1),
                                                sn(k+1));

#ifdef DEBUG_ITERATIVE
                                std::cerr << "H(k, i): " << k+1 << " " << i+1 << " " << H(k+1, i+1) << std::endl;
                                std::cerr << "H(k+1, i): " << k+2 << " " << i+1 << " " << H(k+2, i+1) << std::endl;
#endif /* DEBUG_ITERATIVE */

                        }
                                                        
                        GeneratePlaneRotation(H(i+1, i+1), H(i+2, i+1),
                                        cs(i+1), sn(i+1));

#ifdef DEBUG_ITERATIVE
                        std::cerr << "cs(i): " << cs(i+1) << std::endl;
                        std::cerr << "sn(i): " << sn(i+1) << std::endl;
#endif /* DEBUG_ITERATIVE */

                        ApplyPlaneRotation(H(i+1, i+1), H(i+2, i+1),
                                        cs(i+1), sn(i+1));
                        ApplyPlaneRotation(s(i+1), s(i+2), cs(i+1), sn(i+1));
                        if ((resid = fabs(s(i+2))) < LocTol) {

#ifdef DEBUG_ITERATIVE
                                std::cerr << "resid 1: " << resid  << std::endl;
#endif /* DEBUG_ITERATIVE */

                                Backsolve(dx, i, s, v);
                                pPM->Precond(dx, dx, pSM); 

#ifdef DEBUG_ITERATIVE
                                std::cout << "dx:" << std::endl;
                                for (int iTmpCnt = 1; iTmpCnt <= Size; iTmpCnt++) {
                                        std::cout << "Dof" << std::setw(4) << iTmpCnt << ": " 
                                                << dx(iTmpCnt) << std::endl;
                                }
#endif /* DEBUG_ITERATIVE */

                                break;
                        }

#ifdef DEBUG_ITERATIVE
                        std::cerr << "resid 2 : " << resid << std::endl;
#endif /* DEBUG_ITERATIVE */

                        TotalIter++;
                        i++;
                }
                if (i == MaxLinIt) {
                        Backsolve(dx, MaxLinIt-1, s, v);
                        pPM->Precond(dx, dx, pSM);                              
                        silent_cerr("Iterative inner solver didn't converge."
                                << " Continuing..." << std::endl);
                }

                /* se ha impiegato troppi passi riassembla lo jacobiano */
                
                if (TotalIter >= PrecondIter) {
                        bBuildMat = true;
                }
                /* calcola il nuovo eta */
                doublereal etaNew = gamma * rateo;
                doublereal etaBis;
                if ((etaBis = gamma*eta*eta) > .1) {
                        etaNew = (etaNew > etaBis) ? etaNew : etaBis;
                }
                eta = (etaNew < etaMax) ? etaNew : etaMax;
                /* prevent oversolving */
                etaBis = .5*Tol/dErr;
                eta = (eta > etaBis) ? eta : etaBis;

#ifdef DEBUG_ITERATIVE
                std::cerr << "eta " << eta << std::endl;
#endif /* DEBUG_ITERATIVE */
                
                if (outputSol()) {
                        pS->PrintSolution(dx, iIterCnt);
                }               
                
                pNLP->Update(&dx);
                
                bTest = MakeSolTest(pS, dx, SolTol, dSolErr);
                if (outputIters()) {
#ifdef USE_MPI
                        if (!bParallel || MBDynComm.Get_rank() == 0)
#endif /* USE_MPI */
                        {
                                silent_cout("\t\tSolErr "
                                        << dSolErr << std::endl);
                        }
                }

                if (bTest) {
                        throw ConvergenceOnSolution(MBDYN_EXCEPT_ARGS);
                }

                // allow to bail out in case of multiple CTRL^C
                if (mbdyn_stop_at_end_of_iteration()) {
                        throw ErrInterrupted(MBDYN_EXCEPT_ARGS);
                }
        }
}

Here is the call graph for this function:

Member Data Documentation

MyVectorHandler Gmres::cs

private

Definition at line 50 of file gmres.h.

Referenced by GeneratePlaneRotation(), and Solve().

MyVectorHandler Gmres::dx

private

Definition at line 50 of file gmres.h.

Referenced by GeneratePlaneRotation(), and Solve().

FullMatrixHandler Gmres::H

private

Definition at line 51 of file gmres.h.

Referenced by Backsolve(), and Solve().

MyVectorHandler Gmres::s

private

Definition at line 50 of file gmres.h.

Referenced by Backsolve(), and Solve().

MyVectorHandler Gmres::sn

private

Definition at line 50 of file gmres.h.

Referenced by GeneratePlaneRotation(), and Solve().

MyVectorHandler* Gmres::v

private

Definition at line 49 of file gmres.h.

Referenced by Gmres(), Solve(), and ~Gmres().

MyVectorHandler Gmres::vHat

private

Definition at line 50 of file gmres.h.

Referenced by Solve().

MyVectorHandler Gmres::w

private

Definition at line 50 of file gmres.h.

Referenced by Solve().

---

The documentation for this class was generated from the following files:

• gmres.h
• gmres.cc