Eigen::PardisoImpl< Derived > Class Template Reference

#include <PardisoSupport.h>

Inheritance diagram for Eigen::PardisoImpl< Derived >:

Public Types
enum	{ ScalarIsComplex = NumTraits<Scalar>::IsComplex , ColsAtCompileTime = Dynamic , MaxColsAtCompileTime = Dynamic }
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
	PardisoImpl ()
	~PardisoImpl ()
Index	cols () const
Index	rows () const
ComputationInfo	info () const
	Reports whether previous computation was successful. More...
ParameterType &	pardisoParameterArray ()
Derived &	analyzePattern (const MatrixType &matrix)
Derived &	factorize (const MatrixType &matrix)
Derived &	compute (const MatrixType &matrix)
template<typename Rhs , typename Dest >
void	_solve_impl (const MatrixBase< Rhs > &b, MatrixBase< Dest > &dest) const
template<typename BDerived , typename XDerived >
void	_solve_impl (const MatrixBase< BDerived > &b, MatrixBase< XDerived > &x) const
template<typename Rhs , typename Dest >
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 SparseSolverBase< Derived >	Base
typedef internal::pardiso_traits< Derived >	Traits

Protected Member Functions
void	pardisoRelease ()
void	pardisoInit (int type)
void	manageErrorCode (Index error) const
Derived &	derived ()
const Derived &	derived () const

Protected Attributes
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

Member Typedef Documentation

Base

template<class Derived >

typedef SparseSolverBase<Derived> Eigen::PardisoImpl< Derived >::Base

protected

IntColVectorType

template<class Derived >

typedef Matrix<StorageIndex, MatrixType::RowsAtCompileTime, 1> Eigen::PardisoImpl< Derived >::IntColVectorType

IntRowVectorType

template<class Derived >

typedef Matrix<StorageIndex, 1, MatrixType::ColsAtCompileTime> Eigen::PardisoImpl< Derived >::IntRowVectorType

MatrixType

template<class Derived >

typedef Traits::MatrixType Eigen::PardisoImpl< Derived >::MatrixType

ParameterType

template<class Derived >

typedef Array<StorageIndex, 64, 1, DontAlign> Eigen::PardisoImpl< Derived >::ParameterType

RealScalar

template<class Derived >

typedef Traits::RealScalar Eigen::PardisoImpl< Derived >::RealScalar

Scalar

template<class Derived >

typedef Traits::Scalar Eigen::PardisoImpl< Derived >::Scalar

SparseMatrixType

template<class Derived >

typedef SparseMatrix<Scalar, RowMajor, StorageIndex> Eigen::PardisoImpl< Derived >::SparseMatrixType

StorageIndex

template<class Derived >

typedef Traits::StorageIndex Eigen::PardisoImpl< Derived >::StorageIndex

Traits

template<class Derived >

typedef internal::pardiso_traits<Derived> Eigen::PardisoImpl< Derived >::Traits

protected

VectorType

template<class Derived >

typedef Matrix<Scalar, Dynamic, 1> Eigen::PardisoImpl< Derived >::VectorType

Member Enumeration Documentation

anonymous enum

template<class Derived >

anonymous enum

Enumerator
ScalarIsComplex
ColsAtCompileTime
MaxColsAtCompileTime

{ ScalarIsComplex = NumTraits<Scalar>::IsComplex, ColsAtCompileTime = Dynamic, MaxColsAtCompileTime = Dynamic };

Constructor & Destructor Documentation

PardisoImpl()

template<class Derived >

Eigen::PardisoImpl< Derived >::PardisoImpl ( )

inline

                : m_analysisIsOk(false), m_factorizationIsOk(false) {
    eigen_assert((sizeof(StorageIndex) >= sizeof(_INTEGER_t) && sizeof(StorageIndex) <= 8) &&
                 "Non-supported index type");
    m_iparm.setZero();
    m_msglvl = 0;  // No output
    m_isInitialized = false;
  }

References eigen_assert, Eigen::PardisoImpl< Derived >::m_iparm, Eigen::PardisoImpl< Derived >::m_isInitialized, Eigen::PardisoImpl< Derived >::m_msglvl, and Eigen::PlainObjectBase< Derived >::setZero().

~PardisoImpl()

template<class Derived >

Eigen::PardisoImpl< Derived >::~PardisoImpl ( )

inline

{ pardisoRelease(); }

References Eigen::PardisoImpl< Derived >::pardisoRelease().

Member Function Documentation

_solve_impl() [1/3]

template<class Derived >

template<typename BDerived , typename XDerived >

void Eigen::PardisoImpl< Derived >::_solve_impl	(	const MatrixBase< BDerived > &	b,
		MatrixBase< XDerived > &	x
	)		const

                                                                                                   {
  if (m_iparm[0] == 0)  // Factorization was not computed
  {
    m_info = InvalidInput;
    return;
  }
 
  // Index n = m_matrix.rows();
  Index nrhs = Index(b.cols());
  eigen_assert(m_size == b.rows());
  eigen_assert(((MatrixBase<BDerived>::Flags & RowMajorBit) == 0 || nrhs == 1) &&
               "Row-major right hand sides are not supported");
  eigen_assert(((MatrixBase<XDerived>::Flags & RowMajorBit) == 0 || nrhs == 1) &&
               "Row-major matrices of unknowns are not supported");
  eigen_assert(((nrhs == 1) || b.outerStride() == b.rows()));
 
  //  switch (transposed) {
  //    case SvNoTrans    : m_iparm[11] = 0 ; break;
  //    case SvTranspose  : m_iparm[11] = 2 ; break;
  //    case SvAdjoint    : m_iparm[11] = 1 ; break;
  //    default:
  //      //std::cerr << "Eigen: transposition  option \"" << transposed << "\" not supported by the PARDISO backend\n";
  //      m_iparm[11] = 0;
  //  }
 
  Scalar* rhs_ptr = const_cast<Scalar*>(b.derived().data());
  Matrix<Scalar, Dynamic, Dynamic, ColMajor> tmp;
 
  // Pardiso cannot solve in-place
  if (rhs_ptr == x.derived().data()) {
    tmp = b;
    rhs_ptr = tmp.data();
  }
 
  Index error;
  error = internal::pardiso_run_selector<StorageIndex>::run(
      m_pt, 1, 1, m_type, 33, internal::convert_index<StorageIndex>(m_size), m_matrix.valuePtr(),
      m_matrix.outerIndexPtr(), m_matrix.innerIndexPtr(), m_perm.data(), internal::convert_index<StorageIndex>(nrhs),
      m_iparm.data(), m_msglvl, rhs_ptr, x.derived().data());
 
  manageErrorCode(error);
}

References b, Eigen::PlainObjectBase< Derived >::data(), eigen_assert, calibrate::error, Eigen::InvalidInput, Eigen::RowMajorBit, Eigen::internal::pardiso_run_selector< IndexType >::run(), tmp, and plotDoE::x.

_solve_impl() [2/3]

template<class Derived >

template<typename Rhs , typename Dest >

void Eigen::PardisoImpl< Derived >::_solve_impl	(	const MatrixBase< Rhs > &	b,
		MatrixBase< Dest > &	dest
	)		const

_solve_impl() [3/3]

template<class Derived >

template<typename Rhs , typename Dest >

void Eigen::SparseSolverBase< Derived >::_solve_impl ( typename Rhs  , typename Dest    )

inline

default implementation of solving with a sparse rhs

                                                                                       {
    internal::solve_sparse_through_dense_panels(derived(), b.derived(), dest.derived());
  }

analyzePattern()

template<class Derived >

Derived & Eigen::PardisoImpl< Derived >::analyzePattern

(

const MatrixType &

matrix

)

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()

                                                                 {
  m_size = a.rows();
  eigen_assert(m_size == 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, 11, 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 = false;
  m_isInitialized = true;
  return derived();
}

References a, eigen_assert, calibrate::error, Eigen::internal::pardiso_run_selector< IndexType >::run(), and Eigen::Success.

cols()

template<class Derived >

Index Eigen::PardisoImpl< Derived >::cols ( ) const

inline

{ return m_size; }

References Eigen::PardisoImpl< Derived >::m_size.

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<class Derived >

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

(

const MatrixType &

matrix

)

                                                          {
  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();
}

References a, eigen_assert, calibrate::error, Eigen::internal::pardiso_run_selector< IndexType >::run(), and Eigen::Success.

derived() [1/2]

template<class Derived >

Derived& Eigen::SparseSolverBase< Derived >::derived

inlineprotected

{ return *static_cast<Derived*>(this); }

derived() [2/2]

template<class Derived >

const Derived& Eigen::SparseSolverBase< Derived >::derived

inlineprotected

{ return *static_cast<const Derived*>(this); }

factorize()

template<class Derived >

Derived & Eigen::PardisoImpl< Derived >::factorize

(

const MatrixType &

matrix

)

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()

                                                            {
  eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
  eigen_assert(m_size == a.rows() && m_size == a.cols());
 
  derived().getMatrix(a);
 
  Index error;
  error = internal::pardiso_run_selector<StorageIndex>::run(
      m_pt, 1, 1, m_type, 22, 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_factorizationIsOk = m_info == Eigen::Success;
  return derived();
}

References a, eigen_assert, calibrate::error, Eigen::internal::pardiso_run_selector< IndexType >::run(), and Eigen::Success.

info()

template<class Derived >

ComputationInfo Eigen::PardisoImpl< Derived >::info ( ) const

inline

Reports whether previous computation was successful.

Returns

Success if computation was successful, NumericalIssue if the matrix appears to be negative.

                               {
    eigen_assert(m_isInitialized && "Decomposition is not initialized.");
    return m_info;
  }

References eigen_assert, Eigen::PardisoImpl< Derived >::m_info, and Eigen::PardisoImpl< Derived >::m_isInitialized.

manageErrorCode()

template<class Derived >

void Eigen::PardisoImpl< Derived >::manageErrorCode ( Index  error ) const

inlineprotected

                                          {
    switch (error) {
      case 0:
        m_info = Success;
        break;
      case -4:
      case -7:
        m_info = NumericalIssue;
        break;
      default:
        m_info = InvalidInput;
    }
  }

References calibrate::error, Eigen::InvalidInput, Eigen::PardisoImpl< Derived >::m_info, Eigen::NumericalIssue, and Eigen::Success.

pardisoInit()

template<class Derived >

void Eigen::PardisoImpl< Derived >::pardisoInit ( int  type )

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));
  }

References abs(), Eigen::PardisoImpl< Derived >::m_iparm, Eigen::PardisoImpl< Derived >::m_pt, Eigen::PardisoImpl< Derived >::m_type, and compute_granudrum_aor::type.

pardisoParameterArray()

template<class Derived >

ParameterType& Eigen::PardisoImpl< Derived >::pardisoParameterArray ( )

inline

Warning

for advanced usage only.

Returns

a reference to the parameter array controlling PARDISO. See the PARDISO manual to know how to use it.

{ return m_iparm; }

References Eigen::PardisoImpl< Derived >::m_iparm.

pardisoRelease()

template<class Derived >

void Eigen::PardisoImpl< Derived >::pardisoRelease ( )

inlineprotected

                        {
    if (m_isInitialized)  // Factorization ran at least once
    {
      internal::pardiso_run_selector<StorageIndex>::run(m_pt, 1, 1, m_type, -1,
                                                        internal::convert_index<StorageIndex>(m_size), 0, 0, 0,
                                                        m_perm.data(), 0, m_iparm.data(), m_msglvl, NULL, NULL);
      m_isInitialized = false;
    }
  }

References Eigen::PlainObjectBase< Derived >::data(), Eigen::PardisoImpl< Derived >::m_iparm, Eigen::PardisoImpl< Derived >::m_isInitialized, Eigen::PardisoImpl< Derived >::m_msglvl, Eigen::PardisoImpl< Derived >::m_perm, Eigen::PardisoImpl< Derived >::m_pt, Eigen::PardisoImpl< Derived >::m_size, Eigen::PardisoImpl< Derived >::m_type, and Eigen::internal::pardiso_run_selector< IndexType >::run().

Referenced by Eigen::PardisoImpl< Derived >::~PardisoImpl().

rows()

template<class Derived >

Index Eigen::PardisoImpl< Derived >::rows ( ) const

inline

{ return m_size; }

References Eigen::PardisoImpl< Derived >::m_size.

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().

Member Data Documentation

m_analysisIsOk

template<class Derived >

bool Eigen::PardisoImpl< Derived >::m_analysisIsOk

protected

m_factorizationIsOk

template<class Derived >

bool Eigen::PardisoImpl< Derived >::m_factorizationIsOk

protected

m_info

template<class Derived >

ComputationInfo Eigen::PardisoImpl< Derived >::m_info

mutableprotected

Referenced by Eigen::PardisoImpl< Derived >::info(), and Eigen::PardisoImpl< Derived >::manageErrorCode().

m_iparm

template<class Derived >

ParameterType Eigen::PardisoImpl< Derived >::m_iparm

mutableprotected

Referenced by Eigen::PardisoImpl< Derived >::PardisoImpl(), Eigen::PardisoImpl< Derived >::pardisoInit(), Eigen::PardisoImpl< Derived >::pardisoParameterArray(), and Eigen::PardisoImpl< Derived >::pardisoRelease().

m_isInitialized

template<class Derived >

bool Eigen::SparseSolverBase< Derived >::m_isInitialized

mutableprotected

Referenced by Eigen::PardisoImpl< Derived >::info(), Eigen::PardisoImpl< Derived >::PardisoImpl(), and Eigen::PardisoImpl< Derived >::pardisoRelease().

m_matrix

template<class Derived >

SparseMatrixType Eigen::PardisoImpl< Derived >::m_matrix

mutableprotected

m_msglvl

template<class Derived >

StorageIndex Eigen::PardisoImpl< Derived >::m_msglvl

protected

Referenced by Eigen::PardisoImpl< Derived >::PardisoImpl(), and Eigen::PardisoImpl< Derived >::pardisoRelease().

m_perm

template<class Derived >

IntColVectorType Eigen::PardisoImpl< Derived >::m_perm

mutableprotected

Referenced by Eigen::PardisoImpl< Derived >::pardisoRelease().

m_pt

template<class Derived >

void* Eigen::PardisoImpl< Derived >::m_pt[64]

mutableprotected

Referenced by Eigen::PardisoImpl< Derived >::pardisoInit(), and Eigen::PardisoImpl< Derived >::pardisoRelease().

m_size

template<class Derived >

Index Eigen::PardisoImpl< Derived >::m_size

protected

Referenced by Eigen::PardisoImpl< Derived >::cols(), Eigen::PardisoImpl< Derived >::pardisoRelease(), and Eigen::PardisoImpl< Derived >::rows().

m_type

template<class Derived >

StorageIndex Eigen::PardisoImpl< Derived >::m_type

protected

Referenced by Eigen::PardisoImpl< Derived >::pardisoInit(), and Eigen::PardisoImpl< Derived >::pardisoRelease().

---

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

• PardisoSupport.h