Eigen::PardisoLDLT< MatrixType, Options > Class Template Reference

A sparse direct Cholesky (LDLT) factorization and solver based on the PARDISO library. More...

#include <PardisoSupport.h>

Inheritance diagram for Eigen::PardisoLDLT< MatrixType, Options >:

Public Types
enum	{ UpLo = Options & (Upper | Lower) }
typedef Base::Scalar	Scalar
typedef Base::RealScalar	RealScalar
typedef Base::StorageIndex	StorageIndex
Public Types inherited from Eigen::PardisoImpl< PardisoLDLT< MatrixType, Options > >
enum
typedef Traits::MatrixType	MatrixType
typedef Traits::Scalar	Scalar
typedef Traits::RealScalar	RealScalar
typedef Traits::StorageIndex	StorageIndex
typedef SparseMatrix< Scalar, RowMajor, StorageIndex >	SparseMatrixType
typedef Matrix< Scalar, Dynamic, 1 >	VectorType
typedef Matrix< StorageIndex, 1, MatrixType::ColsAtCompileTime >	IntRowVectorType
typedef Matrix< StorageIndex, MatrixType::RowsAtCompileTime, 1 >	IntColVectorType
typedef Array< StorageIndex, 64, 1, DontAlign >	ParameterType

Public Member Functions
	PardisoLDLT ()
	PardisoLDLT (const MatrixType &matrix)
void	getMatrix (const MatrixType &matrix)
Public Member Functions inherited from Eigen::PardisoImpl< PardisoLDLT< MatrixType, Options > >
	PardisoImpl ()
	~PardisoImpl ()
Index	cols () const
Index	rows () const
ComputationInfo	info () const
	Reports whether previous computation was successful. More...
ParameterType &	pardisoParameterArray ()
PardisoLDLT< MatrixType, Options > &	analyzePattern (const MatrixType &matrix)
PardisoLDLT< MatrixType, Options > &	factorize (const MatrixType &matrix)
PardisoLDLT< MatrixType, Options > &	compute (const MatrixType &matrix)
void	_solve_impl (const MatrixBase< Rhs > &b, MatrixBase< Dest > &dest) const
void	_solve_impl (const MatrixBase< BDerived > &b, MatrixBase< XDerived > &x) const
void	_solve_impl (const SparseMatrixBase< Rhs > &b, SparseMatrixBase< Dest > &dest) const
Public Member Functions inherited from Eigen::SparseSolverBase< Derived >
	SparseSolverBase ()
	SparseSolverBase (SparseSolverBase &&other)
	~SparseSolverBase ()
Derived &	derived ()
const Derived &	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
template<typename Rhs , typename Dest >
void	_solve_impl (const SparseMatrixBase< Rhs > &b, SparseMatrixBase< Dest > &dest) const

Protected Types
typedef PardisoImpl< PardisoLDLT< MatrixType, Options > >	Base
Protected Types inherited from Eigen::PardisoImpl< PardisoLDLT< MatrixType, Options > >
typedef SparseSolverBase< PardisoLDLT< MatrixType, Options > >	Base
typedef internal::pardiso_traits< PardisoLDLT< MatrixType, Options > >	Traits

Friends
class	PardisoImpl< PardisoLDLT< MatrixType, Options > >

Additional Inherited Members
Protected Member Functions inherited from Eigen::PardisoImpl< PardisoLDLT< MatrixType, Options > >
void	pardisoRelease ()
void	pardisoInit (int type)
void	manageErrorCode (Index error) const
PardisoLDLT< MatrixType, Options > &	derived ()
const PardisoLDLT< MatrixType, Options > &	derived () const
Protected Attributes inherited from Eigen::PardisoImpl< PardisoLDLT< MatrixType, Options > >
SparseMatrixType	m_matrix
ComputationInfo	m_info
bool	m_analysisIsOk
bool	m_factorizationIsOk
StorageIndex	m_type
StorageIndex	m_msglvl
void *	m_pt [64]
ParameterType	m_iparm
IntColVectorType	m_perm
Index	m_size
bool	m_isInitialized
Protected Attributes inherited from Eigen::SparseSolverBase< Derived >
bool	m_isInitialized

Detailed Description

template<typename MatrixType, int Options>
class Eigen::PardisoLDLT< MatrixType, Options >

A sparse direct Cholesky (LDLT) factorization and solver based on the PARDISO library.

This class allows to solve for A.X = B sparse linear problems via a LDL^T Cholesky factorization using the Intel MKL PARDISO library. The sparse matrix A is assumed to be selfajoint and positive definite. For complex matrices, A can also be symmetric only, see the Options template parameter. The vectors or matrices X and B can be either dense or sparse.

By default, it runs in in-core mode. To enable PARDISO's out-of-core feature, set:

solver.pardisoParameterArray()[59] = 1; 

Template Parameters

MatrixType	the type of the sparse matrix A, it must be a SparseMatrix<>
Options	can be any bitwise combination of Upper, Lower, and Symmetric. The default is Upper, meaning only the upper triangular part has to be used. Symmetric can be used for symmetric, non-selfadjoint complex matrices, the default being to assume a selfadjoint matrix. Upper|Lower can be used to tell both triangular parts can be used as input.

\implsparsesolverconcept

See also

Sparse solver concept, class SimplicialLDLT

Member Typedef Documentation

Base

template<typename MatrixType , int Options>

typedef PardisoImpl<PardisoLDLT<MatrixType, Options> > Eigen::PardisoLDLT< MatrixType, Options >::Base

protected

RealScalar

template<typename MatrixType , int Options>

typedef Base::RealScalar Eigen::PardisoLDLT< MatrixType, Options >::RealScalar

Scalar

template<typename MatrixType , int Options>

typedef Base::Scalar Eigen::PardisoLDLT< MatrixType, Options >::Scalar

StorageIndex

template<typename MatrixType , int Options>

typedef Base::StorageIndex Eigen::PardisoLDLT< MatrixType, Options >::StorageIndex

Member Enumeration Documentation

anonymous enum

template<typename MatrixType , int Options>

anonymous enum

Enumerator
UpLo

{ UpLo = Options & (Upper | Lower) };

Constructor & Destructor Documentation

PardisoLDLT() [1/2]

template<typename MatrixType , int Options>

Eigen::PardisoLDLT< MatrixType, Options >::PardisoLDLT ( )

inline

: Base() { pardisoInit(Base::ScalarIsComplex ? (bool(Options & Symmetric) ? 6 : -4) : -2); }

References Eigen::PardisoImpl< PardisoLDLT< MatrixType, Options > >::pardisoInit(), Eigen::PardisoImpl< PardisoLDLT< MatrixType, Options > >::ScalarIsComplex, and Eigen::Symmetric.

PardisoLDLT() [2/2]

template<typename MatrixType , int Options>

Eigen::PardisoLDLT< MatrixType, Options >::PardisoLDLT ( const MatrixType &  matrix )

inlineexplicit

                                                 : Base() {
    pardisoInit(Base::ScalarIsComplex ? (bool(Options & Symmetric) ? 6 : -4) : -2);
    compute(matrix);
  }

References Eigen::PardisoImpl< PardisoLDLT< MatrixType, Options > >::compute(), matrix(), Eigen::PardisoImpl< PardisoLDLT< MatrixType, Options > >::pardisoInit(), Eigen::PardisoImpl< PardisoLDLT< MatrixType, Options > >::ScalarIsComplex, and Eigen::Symmetric.

Member Function Documentation

getMatrix()

template<typename MatrixType , int Options>

void Eigen::PardisoLDLT< MatrixType, Options >::getMatrix ( const MatrixType &  matrix )

inline

                                           {
    // PARDISO supports only upper, row-major matrices
    PermutationMatrix<Dynamic, Dynamic, StorageIndex> p_null;
    m_matrix.resize(matrix.rows(), matrix.cols());
    m_matrix.template selfadjointView<Upper>() = matrix.template selfadjointView<UpLo>().twistedBy(p_null);
    m_matrix.makeCompressed();
  }

References Eigen::PardisoImpl< PardisoLDLT< MatrixType, Options > >::m_matrix, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::makeCompressed(), matrix(), and Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::resize().

Friends And Related Function Documentation

PardisoImpl< PardisoLDLT< MatrixType, Options > >

template<typename MatrixType , int Options>

friend class PardisoImpl< PardisoLDLT< MatrixType, Options > >

friend

---

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

• PardisoSupport.h