Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ > Class Template Reference

Inheritance diagram for Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >:

Public Types
enum	{ UpLo }
typedef SimplicialCholeskyBase< SimplicialCholesky >	Base
typedef SparseMatrix< Scalar, ColMajor, StorageIndex >	CholMatrixType
typedef internal::traits< SimplicialLDLT< MatrixType, UpLo > >	LDLTTraits
typedef internal::traits< SimplicialLLT< MatrixType, UpLo > >	LLTTraits
typedef MatrixType_	MatrixType
typedef MatrixType::RealScalar	RealScalar
typedef MatrixType::Scalar	Scalar
typedef MatrixType::StorageIndex	StorageIndex
typedef internal::traits< SimplicialCholesky >	Traits
typedef Matrix< Scalar, Dynamic, 1 >	VectorType
Public Types inherited from Eigen::SimplicialCholeskyBase< SimplicialCholesky< MatrixType_, UpLo_, Ordering_ > >
enum
enum
typedef SparseMatrix< Scalar, ColMajor, StorageIndex >	CholMatrixType
typedef CholMatrixType const *	ConstCholMatrixPtr
typedef internal::traits< SimplicialCholesky< MatrixType_, UpLo_, Ordering_ > >::MatrixType	MatrixType
typedef internal::traits< SimplicialCholesky< MatrixType_, UpLo_, Ordering_ > >::OrderingType	OrderingType
typedef MatrixType::RealScalar	RealScalar
typedef MatrixType::Scalar	Scalar
typedef MatrixType::StorageIndex	StorageIndex
typedef Matrix< StorageIndex, Dynamic, 1 >	VectorI
typedef Matrix< Scalar, Dynamic, 1 >	VectorType

Public Member Functions
template<typename Rhs , typename Dest >
void	_solve_impl (const MatrixBase< Rhs > &b, MatrixBase< Dest > &dest) const
template<typename Rhs , typename Dest >
void	_solve_impl (const SparseMatrixBase< Rhs > &b, SparseMatrixBase< Dest > &dest) const
void	analyzePattern (const MatrixType &a)
SimplicialCholesky &	compute (const MatrixType &matrix)
Scalar	determinant () const
void	factorize (const MatrixType &a)
const CholMatrixType	rawMatrix () const
SimplicialCholesky &	setMode (SimplicialCholeskyMode mode)
	SimplicialCholesky ()
	SimplicialCholesky (const MatrixType &matrix)
const VectorType	vectorD () const
Public Member Functions inherited from Eigen::SimplicialCholeskyBase< SimplicialCholesky< MatrixType_, UpLo_, Ordering_ > >
Index	cols () const
SimplicialCholesky< MatrixType_, UpLo_, Ordering_ > &	derived ()
SimplicialCholesky< MatrixType_, UpLo_, Ordering_ > &	derived ()
const SimplicialCholesky< MatrixType_, UpLo_, Ordering_ > &	derived () const
const SimplicialCholesky< MatrixType_, UpLo_, Ordering_ > &	derived () const
ComputationInfo	info () const
	Reports whether previous computation was successful. More...
const PermutationMatrix< Dynamic, Dynamic, StorageIndex > &	permutationP () const
const PermutationMatrix< Dynamic, Dynamic, StorageIndex > &	permutationPinv () const
Index	rows () const
SimplicialCholesky< MatrixType_, UpLo_, Ordering_ > &	setShift (const RealScalar &offset, const RealScalar &scale=1)
	SimplicialCholeskyBase ()
	SimplicialCholeskyBase (const MatrixType &matrix)
	~SimplicialCholeskyBase ()
Public Member Functions inherited from Eigen::SparseSolverBase< SimplicialCholesky< MatrixType_, UpLo_, Ordering_ > >
SimplicialCholesky< MatrixType_, UpLo_, Ordering_ > &	derived ()
const SimplicialCholesky< MatrixType_, UpLo_, Ordering_ > &	derived () const
const Solve< SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >, Rhs >	solve (const MatrixBase< Rhs > &b) const
const Solve< SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >, Rhs >	solve (const SparseMatrixBase< Rhs > &b) const
	SparseSolverBase ()
	SparseSolverBase (SparseSolverBase &&other)
	~SparseSolverBase ()

Protected Attributes
bool	m_LDLT
Protected Attributes inherited from Eigen::SimplicialCholeskyBase< SimplicialCholesky< MatrixType_, UpLo_, Ordering_ > >
bool	m_analysisIsOk
VectorType	m_diag
bool	m_factorizationIsOk
ComputationInfo	m_info
CholMatrixType	m_matrix
VectorI	m_nonZerosPerCol
PermutationMatrix< Dynamic, Dynamic, StorageIndex >	m_P
VectorI	m_parent
PermutationMatrix< Dynamic, Dynamic, StorageIndex >	m_Pinv
RealScalar	m_shiftOffset
RealScalar	m_shiftScale
Protected Attributes inherited from Eigen::SparseSolverBase< SimplicialCholesky< MatrixType_, UpLo_, Ordering_ > >
bool	m_isInitialized

Additional Inherited Members
Protected Member Functions inherited from Eigen::SimplicialCholeskyBase< SimplicialCholesky< MatrixType_, UpLo_, Ordering_ > >
void	analyzePattern (const MatrixType &a, bool doLDLT)
void	analyzePattern_preordered (const CholMatrixType &a, bool doLDLT)
void	compute (const MatrixType &matrix)
void	factorize (const MatrixType &a)
void	factorize_preordered (const CholMatrixType &a)
void	ordering (const MatrixType &a, ConstCholMatrixPtr &pmat, CholMatrixType &ap)

Detailed Description

template<typename MatrixType_, int UpLo_, typename Ordering_>
class Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >

Deprecated:

use SimplicialLDLT or class SimplicialLLT

See also

class SimplicialLDLT, class SimplicialLLT

Definition at line 513 of file SimplicialCholesky.h.

Member Typedef Documentation

Base

template<typename MatrixType_ , int UpLo_, typename Ordering_ >

typedef SimplicialCholeskyBase<SimplicialCholesky> Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >::Base

Definition at line 518 of file SimplicialCholesky.h.

CholMatrixType

template<typename MatrixType_ , int UpLo_, typename Ordering_ >

typedef SparseMatrix<Scalar,ColMajor,StorageIndex> Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >::CholMatrixType

Definition at line 522 of file SimplicialCholesky.h.

LDLTTraits

template<typename MatrixType_ , int UpLo_, typename Ordering_ >

typedef internal::traits<SimplicialLDLT<MatrixType,UpLo> > Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >::LDLTTraits

Definition at line 525 of file SimplicialCholesky.h.

LLTTraits

template<typename MatrixType_ , int UpLo_, typename Ordering_ >

typedef internal::traits<SimplicialLLT<MatrixType,UpLo> > Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >::LLTTraits

Definition at line 526 of file SimplicialCholesky.h.

MatrixType

template<typename MatrixType_ , int UpLo_, typename Ordering_ >

typedef MatrixType_ Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >::MatrixType

Definition at line 516 of file SimplicialCholesky.h.

RealScalar

template<typename MatrixType_ , int UpLo_, typename Ordering_ >

typedef MatrixType::RealScalar Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >::RealScalar

Definition at line 520 of file SimplicialCholesky.h.

Scalar

template<typename MatrixType_ , int UpLo_, typename Ordering_ >

typedef MatrixType::Scalar Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >::Scalar

Definition at line 519 of file SimplicialCholesky.h.

StorageIndex

template<typename MatrixType_ , int UpLo_, typename Ordering_ >

typedef MatrixType::StorageIndex Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >::StorageIndex

Definition at line 521 of file SimplicialCholesky.h.

Traits

template<typename MatrixType_ , int UpLo_, typename Ordering_ >

typedef internal::traits<SimplicialCholesky> Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >::Traits

Definition at line 524 of file SimplicialCholesky.h.

VectorType

template<typename MatrixType_ , int UpLo_, typename Ordering_ >

typedef Matrix<Scalar,Dynamic,1> Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >::VectorType

Definition at line 523 of file SimplicialCholesky.h.

Member Enumeration Documentation

anonymous enum

template<typename MatrixType_ , int UpLo_, typename Ordering_ >

anonymous enum

Enumerator
UpLo

Definition at line 517 of file SimplicialCholesky.h.

{ UpLo = UpLo_ };

Constructor & Destructor Documentation

SimplicialCholesky() [1/2]

template<typename MatrixType_ , int UpLo_, typename Ordering_ >

Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >::SimplicialCholesky ( )

inline

Definition at line 528 of file SimplicialCholesky.h.

: Base(), m_LDLT(true) {}

SimplicialCholesky() [2/2]

template<typename MatrixType_ , int UpLo_, typename Ordering_ >

Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >::SimplicialCholesky ( const MatrixType &  matrix )

inlineexplicit

Definition at line 530 of file SimplicialCholesky.h.

      : Base(), m_LDLT(true)
    {
      compute(matrix);
    }

Member Function Documentation

_solve_impl() [1/2]

template<typename MatrixType_ , int UpLo_, typename Ordering_ >

template<typename Rhs , typename Dest >

void Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >::_solve_impl ( const MatrixBase< Rhs > &  b, MatrixBase< Dest > &  dest  ) const

inline

Definition at line 599 of file SimplicialCholesky.h.

    {
      eigen_assert(Base::m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()");
      eigen_assert(Base::m_matrix.rows()==b.rows());
 
      if(Base::m_info!=Success)
        return;
 
      if(Base::m_P.size()>0)
        dest = Base::m_P * b;
      else
        dest = b;
 
      if(Base::m_matrix.nonZeros()>0) // otherwise L==I
      {
        if(m_LDLT)
          LDLTTraits::getL(Base::m_matrix).solveInPlace(dest);
        else
          LLTTraits::getL(Base::m_matrix).solveInPlace(dest);
      }
 
      if(Base::m_diag.size()>0)
        dest = Base::m_diag.real().asDiagonal().inverse() * dest;
 
      if (Base::m_matrix.nonZeros()>0) // otherwise I==I
      {
        if(m_LDLT)
          LDLTTraits::getU(Base::m_matrix).solveInPlace(dest);
        else
          LLTTraits::getU(Base::m_matrix).solveInPlace(dest);
      }
 
      if(Base::m_P.size()>0)
        dest = Base::m_Pinv * dest;
    }

_solve_impl() [2/2]

template<typename MatrixType_ , int UpLo_, typename Ordering_ >

template<typename Rhs , typename Dest >

void Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >::_solve_impl ( const SparseMatrixBase< Rhs > &  b, SparseMatrixBase< Dest > &  dest  ) const

inline

Definition at line 637 of file SimplicialCholesky.h.

    {
      internal::solve_sparse_through_dense_panels(*this, b, dest);
    }

analyzePattern()

template<typename MatrixType_ , int UpLo_, typename Ordering_ >

void Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >::analyzePattern ( const MatrixType &  a )

inline

Performs a symbolic decomposition on the sparcity of matrix.

This function is particularly useful when solving for several problems having the same structure.

See also

factorize()

Definition at line 578 of file SimplicialCholesky.h.

    {
      Base::analyzePattern(a, m_LDLT);
    }

compute()

template<typename MatrixType_ , int UpLo_, typename Ordering_ >

SimplicialCholesky& Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >::compute ( const MatrixType &  matrix )

inline

Computes the sparse Cholesky decomposition of matrix

Definition at line 563 of file SimplicialCholesky.h.

    {
      if(m_LDLT)
        Base::template compute<true>(matrix);
      else
        Base::template compute<false>(matrix);
      return *this;
    }

determinant()

template<typename MatrixType_ , int UpLo_, typename Ordering_ >

Scalar Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >::determinant ( ) const

inline

Definition at line 642 of file SimplicialCholesky.h.

    {
      if(m_LDLT)
      {
        return Base::m_diag.prod();
      }
      else
      {
        Scalar detL = Diagonal<const CholMatrixType>(Base::m_matrix).prod();
        return numext::abs2(detL);
      }
    }

factorize()

template<typename MatrixType_ , int UpLo_, typename Ordering_ >

void Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >::factorize ( const MatrixType &  a )

inline

Performs a numeric decomposition of matrix

The given matrix must has the same sparcity than the matrix on which the symbolic decomposition has been performed.

See also

analyzePattern()

Definition at line 589 of file SimplicialCholesky.h.

    {
      if(m_LDLT)
        Base::template factorize<true>(a);
      else
        Base::template factorize<false>(a);
    }

rawMatrix()

template<typename MatrixType_ , int UpLo_, typename Ordering_ >

const CholMatrixType Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >::rawMatrix ( ) const

inline

Definition at line 557 of file SimplicialCholesky.h.

                                                  {
        eigen_assert(Base::m_factorizationIsOk && "Simplicial Cholesky not factorized");
        return Base::m_matrix;
    }

setMode()

template<typename MatrixType_ , int UpLo_, typename Ordering_ >

SimplicialCholesky& Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >::setMode ( SimplicialCholeskyMode  mode )

inline

Definition at line 536 of file SimplicialCholesky.h.

    {
      switch(mode)
      {
      case SimplicialCholeskyLLT:
        m_LDLT = false;
        break;
      case SimplicialCholeskyLDLT:
        m_LDLT = true;
        break;
      default:
        break;
      }
 
      return *this;
    }

vectorD()

template<typename MatrixType_ , int UpLo_, typename Ordering_ >

const VectorType Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >::vectorD ( ) const

inline

Definition at line 553 of file SimplicialCholesky.h.

                                            {
        eigen_assert(Base::m_factorizationIsOk && "Simplicial Cholesky not factorized");
        return Base::m_diag;
    }

Member Data Documentation

m_LDLT

template<typename MatrixType_ , int UpLo_, typename Ordering_ >

bool Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >::m_LDLT

protected

Definition at line 656 of file SimplicialCholesky.h.

---

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

• SimplicialCholesky.h