A Restarted GMRES with deflation. This class implements a modification of the GMRES solver for sparse linear systems. The basis is built with modified Gram-Schmidt. At each restart, a few approximated eigenvectors corresponding to the smallest eigenvalues are used to build a preconditioner for the next cycle. This preconditioner for deflation can be combined with any other preconditioner, the IncompleteLUT for instance. The preconditioner is applied at right of the matrix and the combination is multiplicative. More...

Inheritance diagram for Eigen::DGMRES< MatrixType_, Preconditioner_ >:

Public Types
typedef Matrix< std::complex< RealScalar >, Dynamic, 1 >	ComplexVector

typedef Matrix< Scalar, Dynamic, Dynamic >	DenseMatrix

typedef Matrix< RealScalar, Dynamic, Dynamic >	DenseRealMatrix

typedef Matrix< RealScalar, Dynamic, 1 >	DenseRealVector

typedef Matrix< Scalar, Dynamic, 1 >	DenseVector

typedef MatrixType_	MatrixType

typedef Preconditioner_	Preconditioner

typedef MatrixType::RealScalar	RealScalar

typedef MatrixType::Scalar	Scalar

typedef MatrixType::StorageIndex	StorageIndex

Public Types inherited from Eigen::IterativeSolverBase< DGMRES< MatrixType_, Preconditioner_ > >
typedef internal::traits< Derived >::MatrixType	MatrixType

typedef internal::traits< Derived >::Preconditioner	Preconditioner

typedef MatrixType::RealScalar	RealScalar

typedef MatrixType::Scalar	Scalar

typedef MatrixType::StorageIndex	StorageIndex

Public Member Functions
void	_solve_impl (const Rhs &b, Dest &x) const

template<typename Rhs , typename Dest >
void	_solve_vector_with_guess_impl (const Rhs &b, Dest &x) const

std::enable_if_t< Rhs::ColsAtCompileTime!=1 &&DestDerived::ColsAtCompileTime!=1 >	_solve_with_guess_impl (const Rhs &b, MatrixBase< DestDerived > &aDest) const

std::enable_if_t< Rhs::ColsAtCompileTime==1\|\|DestDerived::ColsAtCompileTime==1 >	_solve_with_guess_impl (const Rhs &b, MatrixBase< DestDerived > &dest) const

void	_solve_with_guess_impl (const Rhs &b, SparseMatrixBase< DestDerived > &aDest) const

Index	deflSize ()

	DGMRES ()

template<typename MatrixDerived >
	DGMRES (const EigenBase< MatrixDerived > &A)

Index	restart ()

void	set_restart (const Index restart)

void	setEigenv (const Index neig)

void	setMaxEigenv (const Index maxNeig)

	~DGMRES ()

Public Member Functions inherited from Eigen::IterativeSolverBase< DGMRES< MatrixType_, Preconditioner_ > >
void	_solve_impl (const Rhs &b, Dest &x) const

std::enable_if_t< Rhs::ColsAtCompileTime!=1 &&DestDerived::ColsAtCompileTime!=1 >	_solve_with_guess_impl (const Rhs &b, MatrixBase< DestDerived > &aDest) const

std::enable_if_t< Rhs::ColsAtCompileTime==1\|\|DestDerived::ColsAtCompileTime==1 >	_solve_with_guess_impl (const Rhs &b, MatrixBase< DestDerived > &dest) const

void	_solve_with_guess_impl (const Rhs &b, SparseMatrixBase< DestDerived > &aDest) const

Derived &	analyzePattern (const EigenBase< MatrixDerived > &A)

EIGEN_CONSTEXPR Index	cols () const EIGEN_NOEXCEPT

Derived &	compute (const EigenBase< MatrixDerived > &A)

Derived &	derived ()

const Derived &	derived () const

RealScalar	error () const

Derived &	factorize (const EigenBase< MatrixDerived > &A)

ComputationInfo	info () const

Index	iterations () const

	IterativeSolverBase ()

	IterativeSolverBase (const EigenBase< MatrixDerived > &A)

	IterativeSolverBase (IterativeSolverBase &&)=default

Index	maxIterations () const

Preconditioner &	preconditioner ()

const Preconditioner &	preconditioner () const

EIGEN_CONSTEXPR Index	rows () const EIGEN_NOEXCEPT

Derived &	setMaxIterations (Index maxIters)

Derived &	setTolerance (const RealScalar &tolerance)

const SolveWithGuess< Derived, Rhs, Guess >	solveWithGuess (const MatrixBase< Rhs > &b, const Guess &x0) const

RealScalar	tolerance () const

	~IterativeSolverBase ()

Public Member Functions inherited from Eigen::SparseSolverBase< class >
Derived &	derived ()

const Derived &	derived () const

const Solve< Derived, Rhs >	solve (const MatrixBase< Rhs > &b) const

const Solve< Derived, Rhs >	solve (const SparseMatrixBase< Rhs > &b) const

	SparseSolverBase ()

	SparseSolverBase (SparseSolverBase &&other)

	~SparseSolverBase ()

Protected Member Functions
template<typename Rhs , typename Dest >
void	dgmres (const MatrixType &mat, const Rhs &rhs, Dest &x, const Preconditioner &precond) const
	Perform several cycles of restarted GMRES with modified Gram Schmidt,. More...

template<typename RhsType , typename DestType >
Index	dgmresApplyDeflation (const RhsType &In, DestType &Out) const

Index	dgmresComputeDeflationData (const MatrixType &mat, const Preconditioner &precond, const Index &it, StorageIndex &neig) const

template<typename Dest >
Index	dgmresCycle (const MatrixType &mat, const Preconditioner &precond, Dest &x, DenseVector &r0, RealScalar &beta, const RealScalar &normRhs, Index &nbIts) const
	Perform one restart cycle of DGMRES. More...

void	dgmresInitDeflation (Index &rows) const

ComplexVector	schurValues (const ComplexSchur< DenseMatrix > &schurofH) const

ComplexVector	schurValues (const RealSchur< DenseMatrix > &schurofH) const

Protected Member Functions inherited from Eigen::IterativeSolverBase< DGMRES< MatrixType_, Preconditioner_ > >
void	grab (const InputType &A)

void	init ()

const ActualMatrixType &	matrix () const

Protected Attributes
bool	m_force

DenseMatrix	m_H

DenseMatrix	m_Hes

bool	m_isDeflAllocated

bool	m_isDeflInitialized

RealScalar	m_lambdaN

PartialPivLU< DenseMatrix >	m_luT

Index	m_maxNeig

DenseMatrix	m_MU

StorageIndex	m_neig

Index	m_r

Index	m_restart

RealScalar	m_smv

DenseMatrix	m_T

DenseMatrix	m_U

DenseMatrix	m_V

Protected Attributes inherited from Eigen::IterativeSolverBase< DGMRES< MatrixType_, Preconditioner_ > >
bool	m_analysisIsOk

RealScalar	m_error

bool	m_factorizationIsOk

ComputationInfo	m_info

bool	m_isInitialized

Index	m_iterations

MatrixWrapper	m_matrixWrapper

Index	m_maxIterations

Preconditioner	m_preconditioner

RealScalar	m_tolerance

Protected Attributes inherited from Eigen::SparseSolverBase< class >
bool	m_isInitialized

Private Types
typedef IterativeSolverBase< DGMRES >	Base

Private Member Functions
const ActualMatrixType &	matrix () const

Private Attributes
RealScalar	m_error

ComputationInfo	m_info

bool	m_isInitialized

Index	m_iterations

RealScalar	m_tolerance

Additional Inherited Members
Public Attributes inherited from Eigen::IterativeSolverBase< DGMRES< MatrixType_, Preconditioner_ > >
	ColsAtCompileTime

	MaxColsAtCompileTime

Protected Types inherited from Eigen::IterativeSolverBase< DGMRES< MatrixType_, Preconditioner_ > >
typedef MatrixWrapper::ActualMatrixType	ActualMatrixType

typedef SparseSolverBase< Derived >	Base

typedef internal::generic_matrix_wrapper< MatrixType >	MatrixWrapper

Detailed Description

template<typename MatrixType_, typename Preconditioner_>
class Eigen::DGMRES< MatrixType_, Preconditioner_ >

A Restarted GMRES with deflation. This class implements a modification of the GMRES solver for sparse linear systems. The basis is built with modified Gram-Schmidt. At each restart, a few approximated eigenvectors corresponding to the smallest eigenvalues are used to build a preconditioner for the next cycle. This preconditioner for deflation can be combined with any other preconditioner, the IncompleteLUT for instance. The preconditioner is applied at right of the matrix and the combination is multiplicative.

Template Parameters

MatrixType_ the type of the sparse matrix A, can be a dense or a sparse matrix.

Preconditioner_

the type of the preconditioner. Default is DiagonalPreconditioner Typical usage :

SparseMatrix<double> A;
VectorXd x, b; 
//Fill A and b ...
DGMRES<SparseMatrix<double> > solver;
solver.set_restart(30); // Set restarting value
solver.setEigenv(1); // Set the number of eigenvalues to deflate
solver.compute(A);
x = solver.solve(b);

DGMRES can also be used in a matrix-free context, see the following example .

References : [1] D. NUENTSA WAKAM and F. PACULL, Memory Efficient Hybrid Algebraic Solvers for Linear Systems Arising from Compressible Flows, Computers and Fluids, In Press, https://doi.org/10.1016/j.compfluid.2012.03.023
[2] K. Burrage and J. Erhel, On the performance of various adaptive preconditioned GMRES strategies, 5(1998), 101-121. [3] J. Erhel, K. Burrage and B. Pohl, Restarted GMRES preconditioned by deflation,J. Computational and Applied Mathematics, 69(1996), 303-318.

Definition at line 103 of file DGMRES.h.

Member Typedef Documentation

◆ Base

template<typename MatrixType_ , typename Preconditioner_ >

typedef IterativeSolverBase<DGMRES> Eigen::DGMRES< MatrixType_, Preconditioner_ >::Base

private

Definition at line 105 of file DGMRES.h.

◆ ComplexVector

template<typename MatrixType_ , typename Preconditioner_ >

typedef Matrix<std::complex<RealScalar>, Dynamic, 1> Eigen::DGMRES< MatrixType_, Preconditioner_ >::ComplexVector

Definition at line 124 of file DGMRES.h.

◆ DenseMatrix

template<typename MatrixType_ , typename Preconditioner_ >

typedef Matrix<Scalar,Dynamic,Dynamic> Eigen::DGMRES< MatrixType_, Preconditioner_ >::DenseMatrix

Definition at line 120 of file DGMRES.h.

◆ DenseRealMatrix

template<typename MatrixType_ , typename Preconditioner_ >

typedef Matrix<RealScalar,Dynamic,Dynamic> Eigen::DGMRES< MatrixType_, Preconditioner_ >::DenseRealMatrix

Definition at line 121 of file DGMRES.h.

◆ DenseRealVector

template<typename MatrixType_ , typename Preconditioner_ >

typedef Matrix<RealScalar,Dynamic,1> Eigen::DGMRES< MatrixType_, Preconditioner_ >::DenseRealVector

Definition at line 123 of file DGMRES.h.

◆ DenseVector

template<typename MatrixType_ , typename Preconditioner_ >

typedef Matrix<Scalar,Dynamic,1> Eigen::DGMRES< MatrixType_, Preconditioner_ >::DenseVector

Definition at line 122 of file DGMRES.h.

◆ MatrixType

template<typename MatrixType_ , typename Preconditioner_ >

typedef MatrixType_ Eigen::DGMRES< MatrixType_, Preconditioner_ >::MatrixType

Definition at line 115 of file DGMRES.h.

◆ Preconditioner

template<typename MatrixType_ , typename Preconditioner_ >

typedef Preconditioner_ Eigen::DGMRES< MatrixType_, Preconditioner_ >::Preconditioner

Definition at line 119 of file DGMRES.h.

◆ RealScalar

template<typename MatrixType_ , typename Preconditioner_ >

typedef MatrixType::RealScalar Eigen::DGMRES< MatrixType_, Preconditioner_ >::RealScalar

Definition at line 118 of file DGMRES.h.

◆ Scalar

template<typename MatrixType_ , typename Preconditioner_ >

typedef MatrixType::Scalar Eigen::DGMRES< MatrixType_, Preconditioner_ >::Scalar

Definition at line 116 of file DGMRES.h.

◆ StorageIndex

template<typename MatrixType_ , typename Preconditioner_ >

typedef MatrixType::StorageIndex Eigen::DGMRES< MatrixType_, Preconditioner_ >::StorageIndex

Definition at line 117 of file DGMRES.h.

Constructor & Destructor Documentation

◆ DGMRES() [1/2]

template<typename MatrixType_ , typename Preconditioner_ >

Eigen::DGMRES< MatrixType_, Preconditioner_ >::DGMRES ( )

inline

Default constructor.

Definition at line 128 of file DGMRES.h.

128 : Base(),m_restart(30),m_neig(0),m_r(0),m_maxNeig(5),m_isDeflAllocated(false),m_isDeflInitialized(false) {}

Eigen::DGMRES::Base

IterativeSolverBase< DGMRES > Base

Definition: DGMRES.h:105

Eigen::DGMRES::m_neig

StorageIndex m_neig

Definition: DGMRES.h:210

Eigen::DGMRES::m_isDeflAllocated

bool m_isDeflAllocated

Definition: DGMRES.h:214

Eigen::DGMRES::m_restart

Index m_restart

Definition: DGMRES.h:205

Eigen::DGMRES::m_maxNeig

Index m_maxNeig

Definition: DGMRES.h:212

Eigen::DGMRES::m_r

Index m_r

Definition: DGMRES.h:211

Eigen::DGMRES::m_isDeflInitialized

bool m_isDeflInitialized

Definition: DGMRES.h:215

◆ DGMRES() [2/2]

template<typename MatrixType_ , typename Preconditioner_ >

template<typename MatrixDerived >

Eigen::DGMRES< MatrixType_, Preconditioner_ >::DGMRES ( const EigenBase< MatrixDerived > & A )

inlineexplicit

Initialize the solver with matrix A for further Ax=b solving.

This constructor is a shortcut for the default constructor followed by a call to compute().

Warning: this class stores a reference to the matrix A as well as some precomputed values that depend on it. Therefore, if A is changed this class becomes invalid. Call compute() to update it with the new matrix A, or modify a copy of A.

Definition at line 141 of file DGMRES.h.

141 : Base(A.derived()), m_restart(30),m_neig(0),m_r(0),m_maxNeig(5),m_isDeflAllocated(false),m_isDeflInitialized(false) {}

EigenBase< SparseMatrix< double, Options_, StorageIndex_ > >::derived

SparseMatrix< double, Options_, StorageIndex_ > & derived()

◆ ~DGMRES()

template<typename MatrixType_ , typename Preconditioner_ >

Eigen::DGMRES< MatrixType_, Preconditioner_ >::~DGMRES ( )

inline

Definition at line 143 of file DGMRES.h.

143 {}

Member Function Documentation

◆ _solve_impl()

template<typename MatrixType_ , typename Preconditioner_ >

void Eigen::IterativeSolverBase< class >::_solve_impl

◆ _solve_vector_with_guess_impl()

template<typename MatrixType_ , typename Preconditioner_ >

template<typename Rhs , typename Dest >

void Eigen::DGMRES< MatrixType_, Preconditioner_ >::_solve_vector_with_guess_impl	(	const Rhs &	b,
		Dest &	x
	)		const

inline

Definition at line 147 of file DGMRES.h.

   {
     EIGEN_STATIC_ASSERT(Rhs::ColsAtCompileTime==1 || Dest::ColsAtCompileTime==1, YOU_TRIED_CALLING_A_VECTOR_METHOD_ON_A_MATRIX);
     
     m_iterations = Base::maxIterations();
     m_error = Base::m_tolerance;
     
     dgmres(matrix(), b, x, Base::m_preconditioner);
   }

◆ _solve_with_guess_impl() [1/3]

template<typename MatrixType_ , typename Preconditioner_ >

std::enable_if_t< Rhs::ColsAtCompileTime!=1 &&DestDerived::ColsAtCompileTime!=1 > Eigen::IterativeSolverBase< class >::_solve_with_guess_impl

◆ _solve_with_guess_impl() [2/3]

template<typename MatrixType_ , typename Preconditioner_ >

std::enable_if_t< Rhs::ColsAtCompileTime==1||DestDerived::ColsAtCompileTime==1 > Eigen::IterativeSolverBase< class >::_solve_with_guess_impl

◆ _solve_with_guess_impl() [3/3]

template<typename MatrixType_ , typename Preconditioner_ >

void Eigen::IterativeSolverBase< class >::_solve_with_guess_impl

◆ deflSize()

template<typename MatrixType_ , typename Preconditioner_ >

Index Eigen::DGMRES< MatrixType_, Preconditioner_ >::deflSize ( )

inline

Get the size of the deflation subspace size

Definition at line 179 of file DGMRES.h.

179 {return m_r; }

◆ dgmres()

template<typename MatrixType_ , typename Preconditioner_ >

template<typename Rhs , typename Dest >

void Eigen::DGMRES< MatrixType_, Preconditioner_ >::dgmres	(	const MatrixType &	mat,
		const Rhs &	rhs,
		Dest &	x,
		const Preconditioner &	precond
	)		const

protected

Perform several cycles of restarted GMRES with modified Gram Schmidt,.

A right preconditioner is used combined with deflation.

Definition at line 230 of file DGMRES.h.

 {
   const RealScalar considerAsZero = (std::numeric_limits<RealScalar>::min)();
  
   RealScalar normRhs = rhs.norm();
   if(normRhs <= considerAsZero) 
   {
     x.setZero();
     m_error = 0;
     return;
   }
  
   //Initialization
   m_isDeflInitialized = false;
   Index n = mat.rows(); 
   DenseVector r0(n); 
   Index nbIts = 0; 
   m_H.resize(m_restart+1, m_restart);
   m_Hes.resize(m_restart, m_restart);
   m_V.resize(n,m_restart+1);
   //Initial residual vector and initial norm
   if(x.squaredNorm()==0) 
     x = precond.solve(rhs);
   r0 = rhs - mat * x; 
   RealScalar beta = r0.norm(); 
   
   m_error = beta/normRhs; 
   if(m_error < m_tolerance)
     m_info = Success; 
   else
     m_info = NoConvergence;
   
   // Iterative process
   while (nbIts < m_iterations && m_info == NoConvergence)
   {
     dgmresCycle(mat, precond, x, r0, beta, normRhs, nbIts); 
     
     // Compute the new residual vector for the restart 
     if (nbIts < m_iterations && m_info == NoConvergence) {
       r0 = rhs - mat * x;
       beta = r0.norm();
     }
   }
 } 

◆ dgmresApplyDeflation()

template<typename MatrixType_ , typename Preconditioner_ >

template<typename RhsType , typename DestType >

Index Eigen::DGMRES< MatrixType_, Preconditioner_ >::dgmresApplyDeflation	(	const RhsType &	In,
		DestType &	Out
	)		const

protected

Definition at line 505 of file DGMRES.h.

 {
   DenseVector x1 = m_U.leftCols(m_r).transpose() * x; 
   y = x + m_U.leftCols(m_r) * ( m_lambdaN * m_luT.solve(x1) - x1);
   return 0; 
 }

◆ dgmresComputeDeflationData()

template<typename MatrixType_ , typename Preconditioner_ >

Index Eigen::DGMRES< MatrixType_, Preconditioner_ >::dgmresComputeDeflationData	(	const MatrixType &	mat,
		const Preconditioner &	precond,
		const Index &	it,
		StorageIndex &	neig
	)		const

protected

Definition at line 421 of file DGMRES.h.

 {
   // First, find the Schur form of the Hessenberg matrix H
   std::conditional_t<NumTraits<Scalar>::IsComplex, ComplexSchur<DenseMatrix>, RealSchur<DenseMatrix> > schurofH;
   bool computeU = true;
   DenseMatrix matrixQ(it,it); 
   matrixQ.setIdentity();
   schurofH.computeFromHessenberg(m_Hes.topLeftCorner(it,it), matrixQ, computeU); 
   
   ComplexVector eig(it);
   Matrix<StorageIndex,Dynamic,1>perm(it);
   eig = this->schurValues(schurofH);
   
   // Reorder the absolute values of Schur values
   DenseRealVector modulEig(it); 
   for (Index j=0; j<it; ++j) modulEig(j) = std::abs(eig(j)); 
   perm.setLinSpaced(it,0,internal::convert_index<StorageIndex>(it-1));
   internal::sortWithPermutation(modulEig, perm, neig);
   
   if (!m_lambdaN)
   {
     m_lambdaN = (std::max)(modulEig.maxCoeff(), m_lambdaN);
   }
   //Count the real number of extracted eigenvalues (with complex conjugates)
   Index nbrEig = 0; 
   while (nbrEig < neig)
   {
     if(eig(perm(it-nbrEig-1)).imag() == RealScalar(0)) nbrEig++; 
     else nbrEig += 2; 
   }
   // Extract the  Schur vectors corresponding to the smallest Ritz values
   DenseMatrix Sr(it, nbrEig); 
   Sr.setZero();
   for (Index j = 0; j < nbrEig; j++)
   {
     Sr.col(j) = schurofH.matrixU().col(perm(it-j-1));
   }
   
   // Form the Schur vectors of the initial matrix using the Krylov basis
   DenseMatrix X; 
   X = m_V.leftCols(it) * Sr;
   if (m_r)
   {
    // Orthogonalize X against m_U using modified Gram-Schmidt
    for (Index j = 0; j < nbrEig; j++)
      for (Index k =0; k < m_r; k++)
       X.col(j) = X.col(j) - (m_U.col(k).dot(X.col(j)))*m_U.col(k); 
   }
   
   // Compute m_MX = A * M^-1 * X
   Index m = m_V.rows();
   if (!m_isDeflAllocated) 
     dgmresInitDeflation(m); 
   DenseMatrix MX(m, nbrEig);
   DenseVector tv1(m);
   for (Index j = 0; j < nbrEig; j++)
   {
     tv1 = mat * X.col(j);
     MX.col(j) = precond.solve(tv1);
   }
   
   //Update m_T = [U'MU U'MX; X'MU X'MX]
   m_T.block(m_r, m_r, nbrEig, nbrEig) = X.transpose() * MX; 
   if(m_r)
   {
     m_T.block(0, m_r, m_r, nbrEig) = m_U.leftCols(m_r).transpose() * MX; 
     m_T.block(m_r, 0, nbrEig, m_r) = X.transpose() * m_MU.leftCols(m_r);
   }
   
   // Save X into m_U and m_MX in m_MU
   for (Index j = 0; j < nbrEig; j++) m_U.col(m_r+j) = X.col(j);
   for (Index j = 0; j < nbrEig; j++) m_MU.col(m_r+j) = MX.col(j);
   // Increase the size of the invariant subspace
   m_r += nbrEig; 
   
   // Factorize m_T into m_luT
   m_luT.compute(m_T.topLeftCorner(m_r, m_r));
   
   //FIXME CHeck if the factorization was correctly done (nonsingular matrix)
   m_isDeflInitialized = true;
   return 0; 
 }

◆ dgmresCycle()

template<typename MatrixType_ , typename Preconditioner_ >

template<typename Dest >

Index Eigen::DGMRES< MatrixType_, Preconditioner_ >::dgmresCycle	(	const MatrixType &	mat,
		const Preconditioner &	precond,
		Dest &	x,
		DenseVector &	r0,
		RealScalar &	beta,
		const RealScalar &	normRhs,
		Index &	nbIts
	)		const

protected

Perform one restart cycle of DGMRES.

Parameters

mat	The coefficient matrix
precond	The preconditioner
x	the new approximated solution
r0	The initial residual vector
beta	The norm of the residual computed so far
normRhs	The norm of the right hand side vector
nbIts	The number of iterations

Definition at line 288 of file DGMRES.h.

 {
   //Initialization 
   DenseVector g(m_restart+1); // Right hand side of the least square problem
   g.setZero();  
   g(0) = Scalar(beta); 
   m_V.col(0) = r0/beta; 
   m_info = NoConvergence; 
   std::vector<JacobiRotation<Scalar> >gr(m_restart); // Givens rotations
   Index it = 0; // Number of inner iterations 
   Index n = mat.rows();
   DenseVector tv1(n), tv2(n);  //Temporary vectors
   while (m_info == NoConvergence && it < m_restart && nbIts < m_iterations)
   {    
     // Apply preconditioner(s) at right
     if (m_isDeflInitialized )
     {
       dgmresApplyDeflation(m_V.col(it), tv1); // Deflation
       tv2 = precond.solve(tv1); 
     }
     else
     {
       tv2 = precond.solve(m_V.col(it)); // User's selected preconditioner
     }
     tv1 = mat * tv2; 
    
     // Orthogonalize it with the previous basis in the basis using modified Gram-Schmidt
     Scalar coef; 
     for (Index i = 0; i <= it; ++i)
     { 
       coef = tv1.dot(m_V.col(i));
       tv1 = tv1 - coef * m_V.col(i); 
       m_H(i,it) = coef; 
       m_Hes(i,it) = coef; 
     }
     // Normalize the vector 
     coef = tv1.norm(); 
     m_V.col(it+1) = tv1/coef;
     m_H(it+1, it) = coef;
 //     m_Hes(it+1,it) = coef; 
     
     // FIXME Check for happy breakdown 
     
     // Update Hessenberg matrix with Givens rotations
     for (Index i = 1; i <= it; ++i) 
     {
       m_H.col(it).applyOnTheLeft(i-1,i,gr[i-1].adjoint());
     }
     // Compute the new plane rotation 
     gr[it].makeGivens(m_H(it, it), m_H(it+1,it)); 
     // Apply the new rotation
     m_H.col(it).applyOnTheLeft(it,it+1,gr[it].adjoint());
     g.applyOnTheLeft(it,it+1, gr[it].adjoint()); 
     
     beta = std::abs(g(it+1));
     m_error = beta/normRhs; 
     // std::cerr << nbIts << " Relative Residual Norm " << m_error << std::endl;
     it++; nbIts++; 
     
     if (m_error < m_tolerance)
     {
       // The method has converged
       m_info = Success;
       break;
     }
   }
   
   // Compute the new coefficients by solving the least square problem
 //   it++;
   //FIXME  Check first if the matrix is singular ... zero diagonal
   DenseVector nrs(m_restart); 
   nrs = m_H.topLeftCorner(it,it).template triangularView<Upper>().solve(g.head(it)); 
   
   // Form the new solution
   if (m_isDeflInitialized)
   {
     tv1 = m_V.leftCols(it) * nrs; 
     dgmresApplyDeflation(tv1, tv2); 
     x = x + precond.solve(tv2);
   }
   else
     x = x + precond.solve(m_V.leftCols(it) * nrs); 
   
   // Go for a new cycle and compute data for deflation
   if(nbIts < m_iterations && m_info == NoConvergence && m_neig > 0 && (m_r+m_neig) < m_maxNeig)
     dgmresComputeDeflationData(mat, precond, it, m_neig); 
   return 0; 
   
 }

◆ dgmresInitDeflation()

template<typename MatrixType_ , typename Preconditioner_ >

void Eigen::DGMRES< MatrixType_, Preconditioner_ >::dgmresInitDeflation ( Index & rows ) const

protected

Definition at line 380 of file DGMRES.h.

 {
   m_U.resize(rows, m_maxNeig);
   m_MU.resize(rows, m_maxNeig); 
   m_T.resize(m_maxNeig, m_maxNeig);
   m_lambdaN = 0.0; 
   m_isDeflAllocated = true; 
 }

◆ matrix()

template<typename MatrixType_ , typename Preconditioner_ >

const ActualMatrixType & Eigen::IterativeSolverBase< class >::matrix

private

◆ restart()

template<typename MatrixType_ , typename Preconditioner_ >

Index Eigen::DGMRES< MatrixType_, Preconditioner_ >::restart ( )

inline

Get the restart value

Definition at line 160 of file DGMRES.h.

160 { return m_restart; }

◆ schurValues() [1/2]

template<typename MatrixType_ , typename Preconditioner_ >

DGMRES< MatrixType_, Preconditioner_ >::ComplexVector Eigen::DGMRES< MatrixType_, Preconditioner_ >::schurValues ( const ComplexSchur< DenseMatrix > & schurofH ) const

inlineprotected

Definition at line 390 of file DGMRES.h.

 {
   return schurofH.matrixT().diagonal();
 }

◆ schurValues() [2/2]

template<typename MatrixType_ , typename Preconditioner_ >

DGMRES< MatrixType_, Preconditioner_ >::ComplexVector Eigen::DGMRES< MatrixType_, Preconditioner_ >::schurValues ( const RealSchur< DenseMatrix > & schurofH ) const

inlineprotected

Definition at line 396 of file DGMRES.h.

 {
   const DenseMatrix& T = schurofH.matrixT();
   Index it = T.rows();
   ComplexVector eig(it);
   Index j = 0;
   while (j < it-1)
   {
     if (T(j+1,j) ==Scalar(0))
     {
       eig(j) = std::complex<RealScalar>(T(j,j),RealScalar(0)); 
       j++; 
     }
     else
     {
       eig(j) = std::complex<RealScalar>(T(j,j),T(j+1,j)); 
       eig(j+1) = std::complex<RealScalar>(T(j,j+1),T(j+1,j+1));
       j++;
     }
   }
   if (j < it-1) eig(j) = std::complex<RealScalar>(T(j,j),RealScalar(0));
   return eig;
 }

◆ set_restart()

template<typename MatrixType_ , typename Preconditioner_ >

void Eigen::DGMRES< MatrixType_, Preconditioner_ >::set_restart ( const Index restart )

inline

Set the restart value (default is 30)

Definition at line 165 of file DGMRES.h.

165 { m_restart=restart; }

Eigen::DGMRES::restart

Index restart()

Definition: DGMRES.h:160

◆ setEigenv()

template<typename MatrixType_ , typename Preconditioner_ >

void Eigen::DGMRES< MatrixType_, Preconditioner_ >::setEigenv ( const Index neig )

inline

Set the number of eigenvalues to deflate at each restart

Definition at line 170 of file DGMRES.h.

   {
     m_neig = neig;
     if (neig+1 > m_maxNeig) m_maxNeig = neig+1; // To allow for complex conjugates
   }

◆ setMaxEigenv()

template<typename MatrixType_ , typename Preconditioner_ >

void Eigen::DGMRES< MatrixType_, Preconditioner_ >::setMaxEigenv ( const Index maxNeig )

inline

Set the maximum size of the deflation subspace

Definition at line 184 of file DGMRES.h.

184 { m_maxNeig = maxNeig; }

Member Data Documentation

◆ m_error

template<typename MatrixType_ , typename Preconditioner_ >

RealScalar Eigen::IterativeSolverBase< class >::m_error

private

◆ m_force

template<typename MatrixType_ , typename Preconditioner_ >

bool Eigen::DGMRES< MatrixType_, Preconditioner_ >::m_force

mutableprotected

Definition at line 219 of file DGMRES.h.

◆ m_H

template<typename MatrixType_ , typename Preconditioner_ >

DenseMatrix Eigen::DGMRES< MatrixType_, Preconditioner_ >::m_H

mutableprotected

Definition at line 203 of file DGMRES.h.

◆ m_Hes

template<typename MatrixType_ , typename Preconditioner_ >

DenseMatrix Eigen::DGMRES< MatrixType_, Preconditioner_ >::m_Hes

mutableprotected

Definition at line 204 of file DGMRES.h.

◆ m_info

template<typename MatrixType_ , typename Preconditioner_ >

ComputationInfo Eigen::IterativeSolverBase< class >::m_info

private

◆ m_isDeflAllocated

template<typename MatrixType_ , typename Preconditioner_ >

bool Eigen::DGMRES< MatrixType_, Preconditioner_ >::m_isDeflAllocated

mutableprotected

Definition at line 214 of file DGMRES.h.

◆ m_isDeflInitialized

template<typename MatrixType_ , typename Preconditioner_ >

bool Eigen::DGMRES< MatrixType_, Preconditioner_ >::m_isDeflInitialized

mutableprotected

Definition at line 215 of file DGMRES.h.

◆ m_isInitialized

template<typename MatrixType_ , typename Preconditioner_ >

bool Eigen::IterativeSolverBase< class >::m_isInitialized

private

◆ m_iterations

template<typename MatrixType_ , typename Preconditioner_ >

Index Eigen::IterativeSolverBase< class >::m_iterations

private

◆ m_lambdaN

template<typename MatrixType_ , typename Preconditioner_ >

RealScalar Eigen::DGMRES< MatrixType_, Preconditioner_ >::m_lambdaN

mutableprotected

Definition at line 213 of file DGMRES.h.

◆ m_luT

template<typename MatrixType_ , typename Preconditioner_ >

PartialPivLU<DenseMatrix> Eigen::DGMRES< MatrixType_, Preconditioner_ >::m_luT

mutableprotected

Definition at line 209 of file DGMRES.h.

◆ m_maxNeig

template<typename MatrixType_ , typename Preconditioner_ >

Index Eigen::DGMRES< MatrixType_, Preconditioner_ >::m_maxNeig

mutableprotected

Definition at line 212 of file DGMRES.h.

◆ m_MU

template<typename MatrixType_ , typename Preconditioner_ >

DenseMatrix Eigen::DGMRES< MatrixType_, Preconditioner_ >::m_MU

mutableprotected

Definition at line 207 of file DGMRES.h.

◆ m_neig

template<typename MatrixType_ , typename Preconditioner_ >

StorageIndex Eigen::DGMRES< MatrixType_, Preconditioner_ >::m_neig

mutableprotected

Definition at line 210 of file DGMRES.h.

◆ m_r

template<typename MatrixType_ , typename Preconditioner_ >

Index Eigen::DGMRES< MatrixType_, Preconditioner_ >::m_r

mutableprotected

Definition at line 211 of file DGMRES.h.

◆ m_restart

template<typename MatrixType_ , typename Preconditioner_ >

Index Eigen::DGMRES< MatrixType_, Preconditioner_ >::m_restart

mutableprotected

Definition at line 205 of file DGMRES.h.

◆ m_smv

template<typename MatrixType_ , typename Preconditioner_ >

RealScalar Eigen::DGMRES< MatrixType_, Preconditioner_ >::m_smv

mutableprotected

Definition at line 218 of file DGMRES.h.

◆ m_T

template<typename MatrixType_ , typename Preconditioner_ >

DenseMatrix Eigen::DGMRES< MatrixType_, Preconditioner_ >::m_T

mutableprotected

Definition at line 208 of file DGMRES.h.

◆ m_tolerance

template<typename MatrixType_ , typename Preconditioner_ >

RealScalar Eigen::IterativeSolverBase< class >::m_tolerance

private

◆ m_U

template<typename MatrixType_ , typename Preconditioner_ >

DenseMatrix Eigen::DGMRES< MatrixType_, Preconditioner_ >::m_U

mutableprotected

Definition at line 206 of file DGMRES.h.

◆ m_V

template<typename MatrixType_ , typename Preconditioner_ >

DenseMatrix Eigen::DGMRES< MatrixType_, Preconditioner_ >::m_V

mutableprotected

Definition at line 202 of file DGMRES.h.

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

DGMRES.h

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

template<typename MatrixType_, typename Preconditioner_> class Eigen::DGMRES< MatrixType_, Preconditioner_ >

Member Typedef Documentation

◆ Base

◆ ComplexVector

◆ DenseMatrix

◆ DenseRealMatrix

◆ DenseRealVector

◆ DenseVector

◆ MatrixType

◆ Preconditioner

◆ RealScalar

◆ Scalar

◆ StorageIndex

Constructor & Destructor Documentation

◆ DGMRES() [1/2]

◆ DGMRES() [2/2]

◆ ~DGMRES()

Member Function Documentation

◆ _solve_impl()

◆ _solve_vector_with_guess_impl()

◆ _solve_with_guess_impl() [1/3]

◆ _solve_with_guess_impl() [2/3]

◆ _solve_with_guess_impl() [3/3]

◆ deflSize()

◆ dgmres()

◆ dgmresApplyDeflation()

◆ dgmresComputeDeflationData()

◆ dgmresCycle()

◆ dgmresInitDeflation()

◆ matrix()

◆ restart()

◆ schurValues() [1/2]

◆ schurValues() [2/2]

◆ set_restart()

◆ setEigenv()

◆ setMaxEigenv()

Member Data Documentation

◆ m_error

◆ m_force

◆ m_H

◆ m_Hes

◆ m_info

◆ m_isDeflAllocated

◆ m_isDeflInitialized

◆ m_isInitialized

◆ m_iterations

◆ m_lambdaN

◆ m_luT

◆ m_maxNeig

◆ m_MU

◆ m_neig

◆ m_r

◆ m_restart

◆ m_smv

◆ m_T

◆ m_tolerance

◆ m_U

◆ m_V

template<typename MatrixType_, typename Preconditioner_>
class Eigen::DGMRES< MatrixType_, Preconditioner_ >