Eigen::LeastSquareDiagonalPreconditioner< _Scalar > Class Template Reference

Jacobi preconditioner for LeastSquaresConjugateGradient. More...

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

Inheritance diagram for Eigen::LeastSquareDiagonalPreconditioner< _Scalar >:

Collaboration diagram for Eigen::LeastSquareDiagonalPreconditioner< _Scalar >:

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

Public Member Functions
	LeastSquareDiagonalPreconditioner ()
template<typename MatType >
	LeastSquareDiagonalPreconditioner (const MatType &mat)
template<typename MatType >
LeastSquareDiagonalPreconditioner &	analyzePattern (const MatType &)
template<typename MatType >
LeastSquareDiagonalPreconditioner &	factorize (const MatType &mat)
template<typename MatType >
LeastSquareDiagonalPreconditioner &	compute (const MatType &mat)
ComputationInfo	info ()
Index	rows () const
Index	cols () const
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

Protected Attributes
bool	m_isInitialized

Private Types
typedef _Scalar	Scalar
typedef NumTraits< Scalar >::Real	RealScalar
typedef DiagonalPreconditioner< _Scalar >	Base
typedef Matrix< Scalar, Dynamic, 1 >	Vector

Private Attributes
Vector	m_invdiag

Detailed Description

template<typename _Scalar>
class Eigen::LeastSquareDiagonalPreconditioner< _Scalar >

Jacobi preconditioner for LeastSquaresConjugateGradient.

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

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

Template Parameters

_Scalar

the type of the scalar.

\implsparsesolverconcept

The diagonal entries are pre-inverted and stored into a dense vector.

See also

class LeastSquaresConjugateGradient, class DiagonalPreconditioner

Member Typedef Documentation

Base

template<typename _Scalar >

typedef DiagonalPreconditioner<_Scalar> Eigen::LeastSquareDiagonalPreconditioner< _Scalar >::Base

private

RealScalar

template<typename _Scalar >

typedef NumTraits<Scalar>::Real Eigen::LeastSquareDiagonalPreconditioner< _Scalar >::RealScalar

private

Scalar

template<typename _Scalar >

typedef _Scalar Eigen::LeastSquareDiagonalPreconditioner< _Scalar >::Scalar

private

StorageIndex

template<typename _Scalar >

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

inherited

Vector

template<typename _Scalar >

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

privateinherited

Member Enumeration Documentation

anonymous enum

template<typename _Scalar >

anonymous enum

inherited

Enumerator
ColsAtCompileTime
MaxColsAtCompileTime

         {
      ColsAtCompileTime = Dynamic,
      MaxColsAtCompileTime = Dynamic
    };

Constructor & Destructor Documentation

LeastSquareDiagonalPreconditioner() [1/2]

template<typename _Scalar >

Eigen::LeastSquareDiagonalPreconditioner< _Scalar >::LeastSquareDiagonalPreconditioner ( )

inline

: Base() {}

LeastSquareDiagonalPreconditioner() [2/2]

template<typename _Scalar >

template<typename MatType >

Eigen::LeastSquareDiagonalPreconditioner< _Scalar >::LeastSquareDiagonalPreconditioner ( const MatType &  mat )

inlineexplicit

                                                                   : Base()
    {
      compute(mat);
    }

References Eigen::LeastSquareDiagonalPreconditioner< _Scalar >::compute().

Here is the call graph for this function:

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

inlineinherited

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

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

analyzePattern()

template<typename _Scalar >

template<typename MatType >

LeastSquareDiagonalPreconditioner & Eigen::LeastSquareDiagonalPreconditioner< _Scalar >::analyzePattern ( const MatType &  )

inline

    {
      return *this;
    }

cols()

template<typename _Scalar >

Index Eigen::DiagonalPreconditioner< _Scalar >::cols ( ) const

inlineinherited

{ return m_invdiag.size(); }

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

compute()

template<typename _Scalar >

template<typename MatType >

LeastSquareDiagonalPreconditioner & Eigen::LeastSquareDiagonalPreconditioner< _Scalar >::compute ( const MatType &  mat )

inline

    {
      return factorize(mat);
    }

References Eigen::LeastSquareDiagonalPreconditioner< _Scalar >::factorize().

Referenced by Eigen::LeastSquareDiagonalPreconditioner< _Scalar >::LeastSquareDiagonalPreconditioner().

Here is the call graph for this function:

Here is the caller graph for this function:

factorize()

template<typename _Scalar >

template<typename MatType >

LeastSquareDiagonalPreconditioner & Eigen::LeastSquareDiagonalPreconditioner< _Scalar >::factorize ( const MatType &  mat )

inline

    {
      // Compute the inverse squared-norm of each column of mat
      m_invdiag.resize(mat.cols());
      if(MatType::IsRowMajor)
      {
        m_invdiag.setZero();
        for(Index j=0; j<mat.outerSize(); ++j)
        {
          for(typename MatType::InnerIterator it(mat,j); it; ++it)
            m_invdiag(it.index()) += numext::abs2(it.value());
        }
        for(Index j=0; j<mat.cols(); ++j)
          if(numext::real(m_invdiag(j))>RealScalar(0))
            m_invdiag(j) = RealScalar(1)/numext::real(m_invdiag(j));
      }
      else
      {
        for(Index j=0; j<mat.outerSize(); ++j)
        {
          RealScalar sum = mat.col(j).squaredNorm();
          if(sum>RealScalar(0))
            m_invdiag(j) = RealScalar(1)/sum;
          else
            m_invdiag(j) = RealScalar(1);
        }
      }
      Base::m_isInitialized = true;
      return *this;
    }

References Eigen::LeastSquareDiagonalPreconditioner< _Scalar >::m_invdiag, Eigen::DiagonalPreconditioner< _Scalar >::m_isInitialized, Eigen::PlainObjectBase< Derived >::resize(), and Eigen::PlainObjectBase< Derived >::setZero().

Referenced by Eigen::LeastSquareDiagonalPreconditioner< _Scalar >::compute().

Here is the call graph for this function:

Here is the caller graph for this function:

info()

template<typename _Scalar >

ComputationInfo Eigen::LeastSquareDiagonalPreconditioner< _Scalar >::info ( )

inline

{ return Success; }

References Eigen::Success.

rows()

template<typename _Scalar >

Index Eigen::DiagonalPreconditioner< _Scalar >::rows ( ) const

inlineinherited

{ return m_invdiag.size(); }

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

solve()

template<typename _Scalar >

template<typename Rhs >

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

inlineinherited

    {
      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 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

private

Referenced by Eigen::LeastSquareDiagonalPreconditioner< _Scalar >::factorize().

m_isInitialized

template<typename _Scalar >

bool Eigen::DiagonalPreconditioner< _Scalar >::m_isInitialized

protectedinherited

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:

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