Eigen::PardisoLU< MatrixType > Class Template Reference

A sparse direct LU factorization and solver based on the PARDISO library. More...

#include <PardisoSupport.h>

Inheritance diagram for Eigen::PardisoLU< MatrixType >:

Public Types
typedef Base::Scalar	Scalar
typedef Base::RealScalar	RealScalar
Public Types inherited from Eigen::PardisoImpl< PardisoLU< MatrixType > >
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
	PardisoLU ()
	PardisoLU (const MatrixType &matrix)
Derived &	compute (const MatrixType &matrix)
Public Member Functions inherited from Eigen::PardisoImpl< PardisoLU< MatrixType > >
	PardisoImpl ()
	~PardisoImpl ()
Index	cols () const
Index	rows () const
ComputationInfo	info () const
	Reports whether previous computation was successful. More...
ParameterType &	pardisoParameterArray ()
PardisoLU< MatrixType > &	analyzePattern (const MatrixType &matrix)
PardisoLU< MatrixType > &	factorize (const MatrixType &matrix)
PardisoLU< MatrixType > &	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< PardisoLU >	Base
Protected Types inherited from Eigen::PardisoImpl< PardisoLU< MatrixType > >
typedef SparseSolverBase< PardisoLU< MatrixType > >	Base
typedef internal::pardiso_traits< PardisoLU< MatrixType > >	Traits

Protected Member Functions
void	getMatrix (const MatrixType &matrix)
void	pardisoInit (int type)
Protected Member Functions inherited from Eigen::PardisoImpl< PardisoLU< MatrixType > >
void	pardisoRelease ()
void	pardisoInit (int type)
void	manageErrorCode (Index error) const
PardisoLU< MatrixType > &	derived ()
const PardisoLU< MatrixType > &	derived () const

Protected Attributes
SparseMatrixType	m_matrix
Protected Attributes inherited from Eigen::PardisoImpl< PardisoLU< MatrixType > >
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

Friends
class	PardisoImpl< PardisoLU< MatrixType > >

Detailed Description

template<typename MatrixType>
class Eigen::PardisoLU< MatrixType >

A sparse direct LU factorization and solver based on the PARDISO library.

This class allows to solve for A.X = B sparse linear problems via a direct LU factorization using the Intel MKL PARDISO library. The sparse matrix A must be squared and invertible. 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<>

\implsparsesolverconcept

See also

Sparse solver concept, class SparseLU

Member Typedef Documentation

Base

template<typename MatrixType >

typedef PardisoImpl<PardisoLU> Eigen::PardisoLU< MatrixType >::Base

protected

RealScalar

template<typename MatrixType >

typedef Base::RealScalar Eigen::PardisoLU< MatrixType >::RealScalar

Scalar

template<typename MatrixType >

typedef Base::Scalar Eigen::PardisoLU< MatrixType >::Scalar

Constructor & Destructor Documentation

PardisoLU() [1/2]

template<typename MatrixType >

Eigen::PardisoLU< MatrixType >::PardisoLU ( )

inline

: Base() { pardisoInit(Base::ScalarIsComplex ? 13 : 11); }

References Eigen::PardisoLU< MatrixType >::pardisoInit(), and Eigen::PardisoImpl< Derived >::ScalarIsComplex.

PardisoLU() [2/2]

template<typename MatrixType >

Eigen::PardisoLU< MatrixType >::PardisoLU ( const MatrixType &  matrix )

inlineexplicit

                                               : Base() {
    pardisoInit(Base::ScalarIsComplex ? 13 : 11);
    compute(matrix);
  }

References Eigen::PardisoLU< MatrixType >::compute(), matrix(), Eigen::PardisoLU< MatrixType >::pardisoInit(), and Eigen::PardisoImpl< Derived >::ScalarIsComplex.

Member Function Documentation

compute()

template<typename MatrixType >

Derived & Eigen::PardisoImpl< Derived >::compute

                                                          {
  m_size = a.rows();
  eigen_assert(a.rows() == a.cols());
 
  pardisoRelease();
  m_perm.setZero(m_size);
  derived().getMatrix(a);
 
  Index error;
  error = internal::pardiso_run_selector<StorageIndex>::run(
      m_pt, 1, 1, m_type, 12, internal::convert_index<StorageIndex>(m_size), m_matrix.valuePtr(),
      m_matrix.outerIndexPtr(), m_matrix.innerIndexPtr(), m_perm.data(), 0, m_iparm.data(), m_msglvl, NULL, NULL);
  manageErrorCode(error);
  m_analysisIsOk = m_info == Eigen::Success;
  m_factorizationIsOk = m_info == Eigen::Success;
  m_isInitialized = true;
  return derived();
}

Referenced by Eigen::PardisoLU< MatrixType >::PardisoLU().

getMatrix()

template<typename MatrixType >

void Eigen::PardisoLU< MatrixType >::getMatrix ( const MatrixType &  matrix )

inlineprotected

                                           {
    m_matrix = matrix;
    m_matrix.makeCompressed();
  }

References Eigen::PardisoLU< MatrixType >::m_matrix, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::makeCompressed(), and matrix().

pardisoInit()

template<typename MatrixType >

void Eigen::PardisoImpl< Derived >::pardisoInit

inlineprotected

                             {
    m_type = type;
    bool symmetric = std::abs(m_type) < 10;
    m_iparm[0] = 1;                   // No solver default
    m_iparm[1] = 2;                   // use Metis for the ordering
    m_iparm[2] = 0;                   // Reserved. Set to zero. (??Numbers of processors, value of OMP_NUM_THREADS??)
    m_iparm[3] = 0;                   // No iterative-direct algorithm
    m_iparm[4] = 0;                   // No user fill-in reducing permutation
    m_iparm[5] = 0;                   // Write solution into x, b is left unchanged
    m_iparm[6] = 0;                   // Not in use
    m_iparm[7] = 2;                   // Max numbers of iterative refinement steps
    m_iparm[8] = 0;                   // Not in use
    m_iparm[9] = 13;                  // Perturb the pivot elements with 1E-13
    m_iparm[10] = symmetric ? 0 : 1;  // Use nonsymmetric permutation and scaling MPS
    m_iparm[11] = 0;                  // Not in use
    m_iparm[12] = symmetric ? 0 : 1;  // Maximum weighted matching algorithm is switched-off (default for symmetric).
                                      // Try m_iparm[12] = 1 in case of inappropriate accuracy
    m_iparm[13] = 0;                  // Output: Number of perturbed pivots
    m_iparm[14] = 0;                  // Not in use
    m_iparm[15] = 0;                  // Not in use
    m_iparm[16] = 0;                  // Not in use
    m_iparm[17] = -1;                 // Output: Number of nonzeros in the factor LU
    m_iparm[18] = -1;                 // Output: Mflops for LU factorization
    m_iparm[19] = 0;                  // Output: Numbers of CG Iterations
 
    m_iparm[20] = 0;  // 1x1 pivoting
    m_iparm[26] = 0;  // No matrix checker
    m_iparm[27] = (sizeof(RealScalar) == 4) ? 1 : 0;
    m_iparm[34] = 1;  // C indexing
    m_iparm[36] = 0;  // CSR
    m_iparm[59] = 0;  // 0 - In-Core ; 1 - Automatic switch between In-Core and Out-of-Core modes ; 2 - Out-of-Core
 
    memset(m_pt, 0, sizeof(m_pt));
  }

Referenced by Eigen::PardisoLU< MatrixType >::PardisoLU().

Friends And Related Function Documentation

PardisoImpl< PardisoLU< MatrixType > >

template<typename MatrixType >

friend class PardisoImpl< PardisoLU< MatrixType > >

friend

Member Data Documentation

m_matrix

template<typename MatrixType >

SparseMatrixType Eigen::PardisoImpl< Derived >::m_matrix

mutableprotected

Referenced by Eigen::PardisoLU< MatrixType >::getMatrix().

---

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

• PardisoSupport.h