Eigen::DiagonalPreconditioner< Scalar_ > Class Template Reference

A preconditioner based on the digonal entries. More...

#include <BasicPreconditioners.h>

Inheritance diagram for Eigen::DiagonalPreconditioner< Scalar_ >:

Public Types
enum	{ ColsAtCompileTime = Dynamic , MaxColsAtCompileTime = Dynamic }
typedef Vector::StorageIndex	StorageIndex

Public Member Functions
	DiagonalPreconditioner ()
template<typename MatType >
	DiagonalPreconditioner (const MatType &mat)
EIGEN_CONSTEXPR Index	rows () const EIGEN_NOEXCEPT
EIGEN_CONSTEXPR Index	cols () const EIGEN_NOEXCEPT
template<typename MatType >
DiagonalPreconditioner &	analyzePattern (const MatType &)
template<typename MatType >
DiagonalPreconditioner &	factorize (const MatType &mat)
template<typename MatType >
DiagonalPreconditioner &	compute (const MatType &mat)
template<typename Rhs , typename Dest >
void	_solve_impl (const Rhs &b, Dest &x) const
template<typename Rhs >
const Solve< DiagonalPreconditioner, Rhs >	solve (const MatrixBase< Rhs > &b) const
ComputationInfo	info ()

Protected Attributes
Vector	m_invdiag
bool	m_isInitialized

Private Types
typedef Scalar_	Scalar
typedef Matrix< Scalar, Dynamic, 1 >	Vector

Detailed Description

template<typename Scalar_>
class Eigen::DiagonalPreconditioner< Scalar_ >

A preconditioner based on the digonal entries.

This class allows to approximately solve for A.x = b problems assuming A is a diagonal matrix. In other words, this preconditioner neglects all off diagonal entries and, in Eigen's language, solves for:

A.diagonal().asDiagonal() . x = b

Template Parameters

Scalar_

the type of the scalar.

\implsparsesolverconcept

This preconditioner is suitable for both selfadjoint and general problems. The diagonal entries are pre-inverted and stored into a dense vector.

Note

A variant that has yet to be implemented would attempt to preserve the norm of each column.

See also

class LeastSquareDiagonalPreconditioner, class ConjugateGradient

Member Typedef Documentation

Scalar

template<typename Scalar_ >

typedef Scalar_ Eigen::DiagonalPreconditioner< Scalar_ >::Scalar

private

StorageIndex

template<typename Scalar_ >

typedef Vector::StorageIndex Eigen::DiagonalPreconditioner< Scalar_ >::StorageIndex

Vector

template<typename Scalar_ >

typedef Matrix<Scalar, Dynamic, 1> Eigen::DiagonalPreconditioner< Scalar_ >::Vector

private

Member Enumeration Documentation

anonymous enum

template<typename Scalar_ >

anonymous enum

Enumerator
ColsAtCompileTime
MaxColsAtCompileTime

{ ColsAtCompileTime = Dynamic, MaxColsAtCompileTime = Dynamic };

Constructor & Destructor Documentation

DiagonalPreconditioner() [1/2]

template<typename Scalar_ >

Eigen::DiagonalPreconditioner< Scalar_ >::DiagonalPreconditioner ( )

inline

: m_isInitialized(false) {}

DiagonalPreconditioner() [2/2]

template<typename Scalar_ >

template<typename MatType >

Eigen::DiagonalPreconditioner< Scalar_ >::DiagonalPreconditioner ( const MatType &  mat )

inlineexplicit

                                                      : m_invdiag(mat.cols()) {
    compute(mat);
  }

References Eigen::DiagonalPreconditioner< Scalar_ >::compute().

Member Function Documentation

_solve_impl()

template<typename Scalar_ >

template<typename Rhs , typename Dest >

void Eigen::DiagonalPreconditioner< Scalar_ >::_solve_impl ( const Rhs &  b, Dest &  x  ) const

inline

                                                {
    x = m_invdiag.array() * b.array();
  }

References b, Eigen::DiagonalPreconditioner< Scalar_ >::m_invdiag, and plotDoE::x.

analyzePattern()

template<typename Scalar_ >

template<typename MatType >

DiagonalPreconditioner& Eigen::DiagonalPreconditioner< Scalar_ >::analyzePattern ( const MatType &  )

inline

                                                         {
    return *this;
  }

cols()

template<typename Scalar_ >

EIGEN_CONSTEXPR Index Eigen::DiagonalPreconditioner< Scalar_ >::cols ( ) const

inline

{ return m_invdiag.size(); }

References Eigen::DiagonalPreconditioner< Scalar_ >::m_invdiag.

Referenced by gdb.printers._MatrixEntryIterator::__next__(), gdb.printers.EigenMatrixPrinter::children(), gdb.printers.EigenSparseMatrixPrinter::children(), gdb.printers.EigenMatrixPrinter::to_string(), and gdb.printers.EigenSparseMatrixPrinter::to_string().

compute()

template<typename Scalar_ >

template<typename MatType >

DiagonalPreconditioner& Eigen::DiagonalPreconditioner< Scalar_ >::compute ( const MatType &  mat )

inline

                                                      {
    return factorize(mat);
  }

References Eigen::DiagonalPreconditioner< Scalar_ >::factorize().

Referenced by Eigen::DiagonalPreconditioner< Scalar_ >::DiagonalPreconditioner().

factorize()

template<typename Scalar_ >

template<typename MatType >

DiagonalPreconditioner& Eigen::DiagonalPreconditioner< Scalar_ >::factorize ( const MatType &  mat )

inline

                                                        {
    m_invdiag.resize(mat.cols());
    for (int j = 0; j < mat.outerSize(); ++j) {
      typename MatType::InnerIterator it(mat, j);
      while (it && it.index() != j) ++it;
      if (it && it.index() == j && it.value() != Scalar(0))
        m_invdiag(j) = Scalar(1) / it.value();
      else
        m_invdiag(j) = Scalar(1);
    }
    m_isInitialized = true;
    return *this;
  }

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::cols(), j, Eigen::DiagonalPreconditioner< Scalar_ >::m_invdiag, Eigen::DiagonalPreconditioner< Scalar_ >::m_isInitialized, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::outerSize(), and Eigen::PlainObjectBase< Derived >::resize().

Referenced by Eigen::DiagonalPreconditioner< Scalar_ >::compute().

info()

template<typename Scalar_ >

ComputationInfo Eigen::DiagonalPreconditioner< Scalar_ >::info ( )

inline

{ return Success; }

References Eigen::Success.

rows()

template<typename Scalar_ >

EIGEN_CONSTEXPR Index Eigen::DiagonalPreconditioner< Scalar_ >::rows ( ) const

inline

{ return m_invdiag.size(); }

References Eigen::DiagonalPreconditioner< Scalar_ >::m_invdiag.

Referenced by gdb.printers._MatrixEntryIterator::__next__(), gdb.printers.EigenMatrixPrinter::children(), gdb.printers.EigenSparseMatrixPrinter::children(), gdb.printers.EigenMatrixPrinter::to_string(), and gdb.printers.EigenSparseMatrixPrinter::to_string().

solve()

template<typename Scalar_ >

template<typename Rhs >

const Solve<DiagonalPreconditioner, Rhs> Eigen::DiagonalPreconditioner< Scalar_ >::solve ( const MatrixBase< Rhs > &  b ) const

inline

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

References b, eigen_assert, Eigen::DiagonalPreconditioner< Scalar_ >::m_invdiag, and Eigen::DiagonalPreconditioner< Scalar_ >::m_isInitialized.

Member Data Documentation

m_invdiag

template<typename Scalar_ >

Vector Eigen::DiagonalPreconditioner< Scalar_ >::m_invdiag

protected

Referenced by Eigen::DiagonalPreconditioner< Scalar_ >::_solve_impl(), Eigen::DiagonalPreconditioner< Scalar_ >::cols(), Eigen::DiagonalPreconditioner< Scalar_ >::factorize(), Eigen::DiagonalPreconditioner< Scalar_ >::rows(), and Eigen::DiagonalPreconditioner< Scalar_ >::solve().

m_isInitialized

template<typename Scalar_ >

bool Eigen::DiagonalPreconditioner< Scalar_ >::m_isInitialized

protected

Referenced by Eigen::DiagonalPreconditioner< Scalar_ >::factorize(), Eigen::LeastSquareDiagonalPreconditioner< Scalar_ >::factorize(), and Eigen::DiagonalPreconditioner< Scalar_ >::solve().

---

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

• BasicPreconditioners.h