Eigen::ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > Class Template Reference

A conjugate gradient solver for sparse (or dense) self-adjoint problems. More...

#include <src/eigen/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h>

Inheritance diagram for Eigen::ConjugateGradient< _MatrixType, _UpLo, _Preconditioner >:

Collaboration diagram for Eigen::ConjugateGradient< _MatrixType, _UpLo, _Preconditioner >:

Public Types
enum	{ UpLo = _UpLo }
typedef _MatrixType	MatrixType
typedef MatrixType::Scalar	Scalar
typedef MatrixType::RealScalar	RealScalar
typedef _Preconditioner	Preconditioner
enum
typedef MatrixType::StorageIndex	StorageIndex

Public Member Functions
	ConjugateGradient ()
template<typename MatrixDerived >
	ConjugateGradient (const EigenBase< MatrixDerived > &A)
	~ConjugateGradient ()
template<typename Rhs , typename Dest >
void	_solve_with_guess_impl (const Rhs &b, Dest &x) const
template<typename Rhs , typename Dest >
void	_solve_impl (const MatrixBase< Rhs > &b, Dest &x) const
template<typename Rhs , typename DestDerived >
void	_solve_impl (const Rhs &b, SparseMatrixBase< DestDerived > &aDest) const
ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > &	analyzePattern (const EigenBase< MatrixDerived > &A)
ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > &	factorize (const EigenBase< MatrixDerived > &A)
ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > &	compute (const EigenBase< MatrixDerived > &A)
Index	rows () const
Index	cols () const
RealScalar	tolerance () const
ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > &	setTolerance (const RealScalar &tolerance)
Preconditioner &	preconditioner ()
const Preconditioner &	preconditioner () const
Index	maxIterations () const
ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > &	setMaxIterations (Index maxIters)
Index	iterations () const
RealScalar	error () const
const SolveWithGuess< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner >, Rhs, Guess >	solveWithGuess (const MatrixBase< Rhs > &b, const Guess &x0) const
ComputationInfo	info () const
template<typename Rhs , typename Dest >
void	_solve_impl (const SparseMatrixBase< Rhs > &b, SparseMatrixBase< Dest > &dest) const
ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > &	derived ()
const ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > &	derived () const
template<typename Rhs >
const Solve< Derived, Rhs >	solve (const MatrixBase< Rhs > &b) const
template<typename Rhs >
const Solve< Derived, Rhs >	solve (const SparseMatrixBase< Rhs > &b) const

Protected Types
typedef internal::generic_matrix_wrapper< MatrixType >	MatrixWrapper
typedef MatrixWrapper::ActualMatrixType	ActualMatrixType

Protected Member Functions
void	init ()
void	grab (const InputType &A)

Protected Attributes
MatrixWrapper	m_matrixWrapper
Preconditioner	m_preconditioner
Index	m_maxIterations
RealScalar	m_tolerance
bool	m_analysisIsOk
bool	m_factorizationIsOk
bool	m_isInitialized

Private Types
typedef IterativeSolverBase< ConjugateGradient >	Base

Private Member Functions
const ActualMatrixType &	matrix () const

Private Attributes
RealScalar	m_error
Index	m_iterations
ComputationInfo	m_info

Detailed Description

template<typename _MatrixType, int _UpLo, typename _Preconditioner>
class Eigen::ConjugateGradient< _MatrixType, _UpLo, _Preconditioner >

A conjugate gradient solver for sparse (or dense) self-adjoint problems.

This class allows to solve for A.x = b linear problems using an iterative conjugate gradient algorithm. The matrix A must be selfadjoint. The matrix A and the vectors x and b can be either dense or sparse.

Template Parameters

_MatrixType	the type of the matrix A, can be a dense or a sparse matrix.
_UpLo	the triangular part that will be used for the computations. It can be Lower, Upper, or Lower|Upper in which the full matrix entries will be considered. Default is Lower, best performance is Lower|Upper.
_Preconditioner	the type of the preconditioner. Default is DiagonalPreconditioner

\implsparsesolverconcept

The maximal number of iterations and tolerance value can be controlled via the setMaxIterations() and setTolerance() methods. The defaults are the size of the problem for the maximal number of iterations and NumTraits<Scalar>::epsilon() for the tolerance.

The tolerance corresponds to the relative residual error: |Ax-b|/|b|

Performance: Even though the default value of _UpLo is Lower, significantly higher performance is achieved when using a complete matrix and Lower|Upper as the _UpLo template parameter. Moreover, in this case multi-threading can be exploited if the user code is compiled with OpenMP enabled. See TopicMultiThreading for details.

This class can be used as the direct solver classes. Here is a typical usage example:

int n = 10000;
VectorXd x(n), b(n);
SparseMatrix<double> A(n,n);
// fill A and b
ConjugateGradient<SparseMatrix<double>, Lower|Upper> cg;
cg.compute(A);
x = cg.solve(b);
std::cout << "#iterations:     " << cg.iterations() << std::endl;
std::cout << "estimated error: " << cg.error()      << std::endl;
// update b, and solve again
x = cg.solve(b);

By default the iterations start with x=0 as an initial guess of the solution. One can control the start using the solveWithGuess() method.

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

See also

class LeastSquaresConjugateGradient, class SimplicialCholesky, DiagonalPreconditioner, IdentityPreconditioner

Member Typedef Documentation

ActualMatrixType

typedef MatrixWrapper::ActualMatrixType Eigen::IterativeSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::ActualMatrixType

protectedinherited

Base

template<typename _MatrixType , int _UpLo, typename _Preconditioner >

typedef IterativeSolverBase<ConjugateGradient> Eigen::ConjugateGradient< _MatrixType, _UpLo, _Preconditioner >::Base

private

MatrixType

template<typename _MatrixType , int _UpLo, typename _Preconditioner >

typedef _MatrixType Eigen::ConjugateGradient< _MatrixType, _UpLo, _Preconditioner >::MatrixType

MatrixWrapper

typedef internal::generic_matrix_wrapper<MatrixType> Eigen::IterativeSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::MatrixWrapper

protectedinherited

Preconditioner

template<typename _MatrixType , int _UpLo, typename _Preconditioner >

typedef _Preconditioner Eigen::ConjugateGradient< _MatrixType, _UpLo, _Preconditioner >::Preconditioner

RealScalar

template<typename _MatrixType , int _UpLo, typename _Preconditioner >

typedef MatrixType::RealScalar Eigen::ConjugateGradient< _MatrixType, _UpLo, _Preconditioner >::RealScalar

Scalar

template<typename _MatrixType , int _UpLo, typename _Preconditioner >

typedef MatrixType::Scalar Eigen::ConjugateGradient< _MatrixType, _UpLo, _Preconditioner >::Scalar

StorageIndex

typedef MatrixType::StorageIndex Eigen::IterativeSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::StorageIndex

inherited

Member Enumeration Documentation

anonymous enum

template<typename _MatrixType , int _UpLo, typename _Preconditioner >

anonymous enum

Enumerator
UpLo

       {
    UpLo = _UpLo
  };

anonymous enum

anonymous enum

inherited

       {
    ColsAtCompileTime = MatrixType::ColsAtCompileTime,
    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
  };

Constructor & Destructor Documentation

ConjugateGradient() [1/2]

template<typename _MatrixType , int _UpLo, typename _Preconditioner >

Eigen::ConjugateGradient< _MatrixType, _UpLo, _Preconditioner >::ConjugateGradient ( )

inline

Default constructor.

: Base() {}

ConjugateGradient() [2/2]

template<typename _MatrixType , int _UpLo, typename _Preconditioner >

template<typename MatrixDerived >

Eigen::ConjugateGradient< _MatrixType, _UpLo, _Preconditioner >::ConjugateGradient ( 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.

: Base(A.derived()) {}

~ConjugateGradient()

template<typename _MatrixType , int _UpLo, typename _Preconditioner >

Eigen::ConjugateGradient< _MatrixType, _UpLo, _Preconditioner >::~ConjugateGradient ( )

inline

{}

Member Function Documentation

_solve_impl() [1/3]

template<typename _MatrixType , int _UpLo, typename _Preconditioner >

template<typename Rhs , typename Dest >

void Eigen::ConjugateGradient< _MatrixType, _UpLo, _Preconditioner >::_solve_impl ( const MatrixBase< Rhs > &  b, Dest &  x  ) const

inline

  {
    x.setZero();
    _solve_with_guess_impl(b.derived(),x);
  }

References Eigen::ConjugateGradient< _MatrixType, _UpLo, _Preconditioner >::_solve_with_guess_impl().

Here is the call graph for this function:

_solve_impl() [2/3]

template<typename _MatrixType , int _UpLo, typename _Preconditioner >

template<typename Rhs , typename DestDerived >

void Eigen::IterativeSolverBase< Derived >::_solve_impl ( const Rhs &  b, SparseMatrixBase< DestDerived > &  aDest  ) const

inline

  {
    eigen_assert(rows()==b.rows());
    
    Index rhsCols = b.cols();
    Index size = b.rows();
    DestDerived& dest(aDest.derived());
    typedef typename DestDerived::Scalar DestScalar;
    Eigen::Matrix<DestScalar,Dynamic,1> tb(size);
    Eigen::Matrix<DestScalar,Dynamic,1> tx(cols());
    // We do not directly fill dest because sparse expressions have to be free of aliasing issue.
    // For non square least-square problems, b and dest might not have the same size whereas they might alias each-other.
    typename DestDerived::PlainObject tmp(cols(),rhsCols);
    for(Index k=0; k<rhsCols; ++k)
    {
      tb = b.col(k);
      tx = derived().solve(tb);
      tmp.col(k) = tx.sparseView(0);
    }
    dest.swap(tmp);
  }

_solve_impl() [3/3]

template<typename Derived >

template<typename Rhs , typename Dest >

void Eigen::SparseSolverBase< Derived >::_solve_impl ( const SparseMatrixBase< Rhs > &  b, SparseMatrixBase< Dest > &  dest  ) const

inlineinherited

    {
      internal::solve_sparse_through_dense_panels(derived(), b.derived(), dest.derived());
    }

References Eigen::SparseSolverBase< Derived >::derived(), Eigen::SparseMatrixBase< Derived >::derived(), and Eigen::internal::solve_sparse_through_dense_panels().

Here is the call graph for this function:

_solve_with_guess_impl()

template<typename _MatrixType , int _UpLo, typename _Preconditioner >

template<typename Rhs , typename Dest >

void Eigen::ConjugateGradient< _MatrixType, _UpLo, _Preconditioner >::_solve_with_guess_impl ( const Rhs &  b, Dest &  x  ) const

inline

  {
    typedef typename Base::MatrixWrapper MatrixWrapper;
    typedef typename Base::ActualMatrixType ActualMatrixType;
    enum {
      TransposeInput  =   (!MatrixWrapper::MatrixFree)
                      &&  (UpLo==(Lower|Upper))
                      &&  (!MatrixType::IsRowMajor)
                      &&  (!NumTraits<Scalar>::IsComplex)
    };
    typedef typename internal::conditional<TransposeInput,Transpose<const ActualMatrixType>, ActualMatrixType const&>::type RowMajorWrapper;
    EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(MatrixWrapper::MatrixFree,UpLo==(Lower|Upper)),MATRIX_FREE_CONJUGATE_GRADIENT_IS_COMPATIBLE_WITH_UPPER_UNION_LOWER_MODE_ONLY);
    typedef typename internal::conditional<UpLo==(Lower|Upper),
                                           RowMajorWrapper,
                                           typename MatrixWrapper::template ConstSelfAdjointViewReturnType<UpLo>::Type
                                          >::type SelfAdjointWrapper;
    m_iterations = Base::maxIterations();
    m_error = Base::m_tolerance;
 
    for(Index j=0; j<b.cols(); ++j)
    {
      m_iterations = Base::maxIterations();
      m_error = Base::m_tolerance;
 
      typename Dest::ColXpr xj(x,j);
      RowMajorWrapper row_mat(matrix());
      internal::conjugate_gradient(SelfAdjointWrapper(row_mat), b.col(j), xj, Base::m_preconditioner, m_iterations, m_error);
    }
 
    m_isInitialized = true;
    m_info = m_error <= Base::m_tolerance ? Success : NoConvergence;
  }

References Eigen::internal::conjugate_gradient(), EIGEN_IMPLIES, EIGEN_STATIC_ASSERT, Eigen::Lower, Eigen::ConjugateGradient< _MatrixType, _UpLo, _Preconditioner >::m_error, Eigen::ConjugateGradient< _MatrixType, _UpLo, _Preconditioner >::m_info, Eigen::IterativeSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::m_isInitialized, Eigen::ConjugateGradient< _MatrixType, _UpLo, _Preconditioner >::m_iterations, Eigen::IterativeSolverBase< Derived >::m_preconditioner, Eigen::IterativeSolverBase< Derived >::m_tolerance, Eigen::ConjugateGradient< _MatrixType, _UpLo, _Preconditioner >::matrix(), Eigen::IterativeSolverBase< Derived >::maxIterations(), Eigen::NoConvergence, Eigen::Success, Eigen::ConjugateGradient< _MatrixType, _UpLo, _Preconditioner >::UpLo, and Eigen::Upper.

Referenced by Eigen::ConjugateGradient< _MatrixType, _UpLo, _Preconditioner >::_solve_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

analyzePattern()

ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > & Eigen::IterativeSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::analyzePattern ( const EigenBase< MatrixDerived > &  A )

inlineinherited

Initializes the iterative solver for the sparsity pattern of the matrix A for further solving Ax=b problems.

Currently, this function mostly calls analyzePattern on the preconditioner. In the future we might, for instance, implement column reordering for faster matrix vector products.

  {
    grab(A.derived());
    m_preconditioner.analyzePattern(matrix());
    m_isInitialized = true;
    m_analysisIsOk = true;
    m_info = m_preconditioner.info();
    return derived();
  }

cols()

Index Eigen::IterativeSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::cols ( ) const

inlineinherited

{ return matrix().cols(); }

compute()

ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > & Eigen::IterativeSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::compute ( const EigenBase< MatrixDerived > &  A )

inlineinherited

Initializes the iterative solver with the matrix A for further solving Ax=b problems.

Currently, this function mostly initializes/computes the preconditioner. In the future we might, for instance, implement column reordering for faster matrix vector products.

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.

  {
    grab(A.derived());
    m_preconditioner.compute(matrix());
    m_isInitialized = true;
    m_analysisIsOk = true;
    m_factorizationIsOk = true;
    m_info = m_preconditioner.info();
    return derived();
  }

derived() [1/2]

ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > & Eigen::SparseSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::derived ( )

inlineinherited

{ return *static_cast<Derived*>(this); }

derived() [2/2]

const ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > & Eigen::SparseSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::derived ( ) const

inlineinherited

{ return *static_cast<const Derived*>(this); }

error()

RealScalar Eigen::IterativeSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::error ( ) const

inlineinherited

Returns

the tolerance error reached during the last solve. It is a close approximation of the true relative residual error |Ax-b|/|b|.

  {
    eigen_assert(m_isInitialized && "ConjugateGradient is not initialized.");
    return m_error;
  }

factorize()

ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > & Eigen::IterativeSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::factorize ( const EigenBase< MatrixDerived > &  A )

inlineinherited

Initializes the iterative solver with the numerical values of the matrix A for further solving Ax=b problems.

Currently, this function mostly calls factorize on the preconditioner.

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.

  {
    eigen_assert(m_analysisIsOk && "You must first call analyzePattern()"); 
    grab(A.derived());
    m_preconditioner.factorize(matrix());
    m_factorizationIsOk = true;
    m_info = m_preconditioner.info();
    return derived();
  }

grab()

void Eigen::IterativeSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::grab ( const InputType &  A )

inlineprotectedinherited

  {
    m_matrixWrapper.grab(A);
  }

info()

ComputationInfo Eigen::IterativeSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::info ( ) const

inlineinherited

Returns

Success if the iterations converged, and NoConvergence otherwise.

  {
    eigen_assert(m_isInitialized && "IterativeSolverBase is not initialized.");
    return m_info;
  }

init()

void Eigen::IterativeSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::init ( )

inlineprotectedinherited

  {
    m_isInitialized = false;
    m_analysisIsOk = false;
    m_factorizationIsOk = false;
    m_maxIterations = -1;
    m_tolerance = NumTraits<Scalar>::epsilon();
  }

iterations()

Index Eigen::IterativeSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::iterations ( ) const

inlineinherited

Returns

the number of iterations performed during the last solve

  {
    eigen_assert(m_isInitialized && "ConjugateGradient is not initialized.");
    return m_iterations;
  }

matrix()

template<typename _MatrixType , int _UpLo, typename _Preconditioner >

const ActualMatrixType & Eigen::IterativeSolverBase< Derived >::matrix ( ) const

inlineprivate

  {
    return m_matrixWrapper.matrix();
  }

Referenced by Eigen::ConjugateGradient< _MatrixType, _UpLo, _Preconditioner >::_solve_with_guess_impl().

Here is the caller graph for this function:

maxIterations()

Index Eigen::IterativeSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::maxIterations ( ) const

inlineinherited

Returns

the max number of iterations. It is either the value setted by setMaxIterations or, by default, twice the number of columns of the matrix.

  {
    return (m_maxIterations<0) ? 2*matrix().cols() : m_maxIterations;
  }

preconditioner() [1/2]

Preconditioner & Eigen::IterativeSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::preconditioner ( )

inlineinherited

Returns

a read-write reference to the preconditioner for custom configuration.

{ return m_preconditioner; }

preconditioner() [2/2]

const Preconditioner & Eigen::IterativeSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::preconditioner ( ) const

inlineinherited

Returns

a read-only reference to the preconditioner.

{ return m_preconditioner; }

rows()

Index Eigen::IterativeSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::rows ( ) const

inlineinherited

{ return matrix().rows(); }

setMaxIterations()

ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > & Eigen::IterativeSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::setMaxIterations ( Index  maxIters )

inlineinherited

Sets the max number of iterations. Default is twice the number of columns of the matrix.

  {
    m_maxIterations = maxIters;
    return derived();
  }

setTolerance()

ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > & Eigen::IterativeSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::setTolerance ( const RealScalar &  tolerance )

inlineinherited

Sets the tolerance threshold used by the stopping criteria.

This value is used as an upper bound to the relative residual error: |Ax-b|/|b|. The default value is the machine precision given by NumTraits<Scalar>::epsilon()

  {
    m_tolerance = tolerance;
    return derived();
  }

solve() [1/2]

template<typename Derived >

template<typename Rhs >

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

inlineinherited

Returns

an expression of the solution x of using the current decomposition of A.

See also

compute()

    {
      eigen_assert(m_isInitialized && "Solver is not initialized.");
      eigen_assert(derived().rows()==b.rows() && "solve(): invalid number of rows of the right hand side matrix b");
      return Solve<Derived, Rhs>(derived(), b.derived());
    }

References Eigen::SparseSolverBase< Derived >::derived(), eigen_assert, and Eigen::SparseSolverBase< Derived >::m_isInitialized.

Referenced by igl::embree::bone_heat(), igl::Frame_field_deformer::compute_optimal_positions(), igl::eigs(), igl::copyleft::comiso::FrameInterpolator::interpolateSymmetric(), igl::slim::solve_weighted_arap(), and igl::copyleft::comiso::NRosyField::solveNoRoundings().

Here is the call graph for this function:

Here is the caller graph for this function:

solve() [2/2]

template<typename Derived >

template<typename Rhs >

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

inlineinherited

Returns

an expression of the solution x of using the current decomposition of A.

See also

compute()

    {
      eigen_assert(m_isInitialized && "Solver is not initialized.");
      eigen_assert(derived().rows()==b.rows() && "solve(): invalid number of rows of the right hand side matrix b");
      return Solve<Derived, Rhs>(derived(), b.derived());
    }

solveWithGuess()

const SolveWithGuess< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > , Rhs, Guess > Eigen::IterativeSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::solveWithGuess ( const MatrixBase< Rhs > &  b, const Guess &  x0  ) const

inlineinherited

Returns

the solution x of using the current decomposition of A and x0 as an initial solution.

See also

solve(), compute()

  {
    eigen_assert(m_isInitialized && "Solver is not initialized.");
    eigen_assert(derived().rows()==b.rows() && "solve(): invalid number of rows of the right hand side matrix b");
    return SolveWithGuess<Derived, Rhs, Guess>(derived(), b.derived(), x0);
  }

tolerance()

RealScalar Eigen::IterativeSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::tolerance ( ) const

inlineinherited

Returns

the tolerance threshold used by the stopping criteria.

See also

setTolerance()

{ return m_tolerance; }

Member Data Documentation

m_analysisIsOk

bool Eigen::IterativeSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::m_analysisIsOk

mutableprotectedinherited

m_error

template<typename _MatrixType , int _UpLo, typename _Preconditioner >

RealScalar Eigen::IterativeSolverBase< Derived >::m_error

mutableprivate

Referenced by Eigen::ConjugateGradient< _MatrixType, _UpLo, _Preconditioner >::_solve_with_guess_impl().

m_factorizationIsOk

bool Eigen::IterativeSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::m_factorizationIsOk

protectedinherited

m_info

template<typename _MatrixType , int _UpLo, typename _Preconditioner >

ComputationInfo Eigen::IterativeSolverBase< Derived >::m_info

mutableprivate

Referenced by Eigen::ConjugateGradient< _MatrixType, _UpLo, _Preconditioner >::_solve_with_guess_impl().

m_isInitialized

bool Eigen::SparseSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::m_isInitialized

mutableprotectedinherited

m_iterations

template<typename _MatrixType , int _UpLo, typename _Preconditioner >

Index Eigen::IterativeSolverBase< Derived >::m_iterations

mutableprivate

Referenced by Eigen::ConjugateGradient< _MatrixType, _UpLo, _Preconditioner >::_solve_with_guess_impl().

m_matrixWrapper

MatrixWrapper Eigen::IterativeSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::m_matrixWrapper

protectedinherited

m_maxIterations

Index Eigen::IterativeSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::m_maxIterations

protectedinherited

m_preconditioner

Preconditioner Eigen::IterativeSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::m_preconditioner

protectedinherited

m_tolerance

RealScalar Eigen::IterativeSolverBase< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > >::m_tolerance

protectedinherited

---

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

• src/eigen/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h