A sparse direct supernodal Cholesky (LLT) factorization and solver based on the PaStiX library. More...

#include <src/eigen/Eigen/src/PaStiXSupport/PaStiXSupport.h>

Inheritance diagram for Eigen::PastixLLT< _MatrixType, _UpLo >:

Collaboration diagram for Eigen::PastixLLT< _MatrixType, _UpLo >:

Public Types
enum	{ UpLo = _UpLo }

typedef _MatrixType	MatrixType

typedef PastixBase< PastixLLT< MatrixType, _UpLo > >	Base

typedef Base::ColSpMatrix	ColSpMatrix

enum

typedef internal::pastix_traits< PastixLLT< _MatrixType, _UpLo > >::MatrixType	_MatrixType

typedef MatrixType::Scalar	Scalar

typedef MatrixType::RealScalar	RealScalar

typedef MatrixType::StorageIndex	StorageIndex

typedef Matrix< Scalar, Dynamic, 1 >	Vector

Public Member Functions
	PastixLLT ()

	PastixLLT (const MatrixType &matrix)

void	compute (const MatrixType &matrix)

void	analyzePattern (const MatrixType &matrix)

void	factorize (const MatrixType &matrix)

bool	_solve_impl (const MatrixBase< Rhs > &b, MatrixBase< Dest > &x) const

void	_solve_impl (const SparseMatrixBase< Rhs > &b, SparseMatrixBase< Dest > &dest) const

Array< StorageIndex, IPARM_SIZE, 1 > &	iparm ()

int &	iparm (int idxparam)

Array< double, DPARM_SIZE, 1 > &	dparm ()

double &	dparm (int idxparam)

Index	cols () const

Index	rows () const

ComputationInfo	info () const
	Reports whether previous computation was successful.

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

Protected Member Functions
void	init ()

void	grabMatrix (const MatrixType &matrix, ColSpMatrix &out)

void	analyzePattern (ColSpMatrix &mat)

void	factorize (ColSpMatrix &mat)

void	clean ()

void	compute (ColSpMatrix &mat)

PastixLLT< _MatrixType, _UpLo > &	derived ()

const PastixLLT< _MatrixType, _UpLo > &	derived () const

Protected Attributes
Array< int, IPARM_SIZE, 1 >	m_iparm

int	m_initisOk

int	m_analysisIsOk

int	m_factorizationIsOk

ComputationInfo	m_info

pastix_data_t *	m_pastixdata

int	m_comm

Array< double, DPARM_SIZE, 1 >	m_dparm

Matrix< StorageIndex, Dynamic, 1 >	m_perm

Matrix< StorageIndex, Dynamic, 1 >	m_invp

int	m_size

bool	m_isInitialized

Detailed Description

template<typename _MatrixType, int _UpLo>
class Eigen::PastixLLT< _MatrixType, _UpLo >

A sparse direct supernodal Cholesky (LLT) factorization and solver based on the PaStiX library.

This class is used to solve the linear systems A.X = B via a LL^T supernodal Cholesky factorization available in the PaStiX library. The matrix A should be symmetric and positive definite WARNING Selfadjoint complex matrices are not supported in the current version of PaStiX The vectors or matrices X and B can be either dense or sparse

Template Parameters

MatrixType	the type of the sparse matrix A, it must be a SparseMatrix<>
UpLo	The part of the matrix to use : Lower or Upper. The default is Lower as required by PaStiX

\implsparsesolverconcept

See also: TutorialSparseSolverConcept, class SimplicialLLT

Member Typedef Documentation

◆ _MatrixType

typedef internal::pastix_traits<PastixLLT< _MatrixType, _UpLo > >::MatrixType Eigen::PastixBase< PastixLLT< _MatrixType, _UpLo > >::_MatrixType

inherited

◆ Base

template<typename _MatrixType , int _UpLo>

typedef PastixBase<PastixLLT<MatrixType, _UpLo> > Eigen::PastixLLT< _MatrixType, _UpLo >::Base

◆ ColSpMatrix

template<typename _MatrixType , int _UpLo>

typedef Base::ColSpMatrix Eigen::PastixLLT< _MatrixType, _UpLo >::ColSpMatrix

◆ MatrixType

template<typename _MatrixType , int _UpLo>

typedef _MatrixType Eigen::PastixLLT< _MatrixType, _UpLo >::MatrixType

◆ RealScalar

typedef MatrixType::RealScalar Eigen::PastixBase< PastixLLT< _MatrixType, _UpLo > >::RealScalar

inherited

◆ Scalar

typedef MatrixType::Scalar Eigen::PastixBase< PastixLLT< _MatrixType, _UpLo > >::Scalar

inherited

◆ StorageIndex

typedef MatrixType::StorageIndex Eigen::PastixBase< PastixLLT< _MatrixType, _UpLo > >::StorageIndex

inherited

◆ Vector

typedef Matrix<Scalar,Dynamic,1> Eigen::PastixBase< PastixLLT< _MatrixType, _UpLo > >::Vector

inherited

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

inherited

         {
      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
    };

◆ anonymous enum

template<typename _MatrixType , int _UpLo>

anonymous enum

Enumerator
UpLo

532{ UpLo = _UpLo };

Eigen::PastixLLT::UpLo

@ UpLo

Definition PaStiXSupport.h:532

Constructor & Destructor Documentation

◆ PastixLLT() [1/2]

template<typename _MatrixType , int _UpLo>

Eigen::PastixLLT< _MatrixType, _UpLo >::PastixLLT ( )

inline

                : Base()
    {
      init();
    }

References Eigen::PastixLLT< _MatrixType, _UpLo >::init().

Here is the call graph for this function:

◆ PastixLLT() [2/2]

template<typename _MatrixType , int _UpLo>

Eigen::PastixLLT< _MatrixType, _UpLo >::PastixLLT ( const MatrixType & matrix )

inlineexplicit

                                                :Base()
    {
      init();
      compute(matrix);
    }

References Eigen::PastixLLT< _MatrixType, _UpLo >::compute(), and Eigen::PastixLLT< _MatrixType, _UpLo >::init().

Here is the call graph for this function:

Member Function Documentation

◆ _solve_impl() [1/2]

bool Eigen::PastixBase< Base >::_solve_impl	(	const MatrixBase< Rhs > &	b,
		MatrixBase< Dest > &	x
	)		const

inherited

{
  eigen_assert(m_isInitialized && "The matrix should be factorized first");
  EIGEN_STATIC_ASSERT((Dest::Flags&RowMajorBit)==0,
                     THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
  int rhs = 1;
  
  x = b; /* on return, x is overwritten by the computed solution */
  
  for (int i = 0; i < b.cols(); i++){
    m_iparm[IPARM_START_TASK]          = API_TASK_SOLVE;
    m_iparm[IPARM_END_TASK]            = API_TASK_REFINE;
  
    internal::eigen_pastix(&m_pastixdata, MPI_COMM_WORLD, internal::convert_index<int>(x.rows()), 0, 0, 0,
                           m_perm.data(), m_invp.data(), &x(0, i), rhs, m_iparm.data(), m_dparm.data());
  }
  
  // Check the returned error
  m_info = m_iparm(IPARM_ERROR_NUMBER)==0 ? Success : NumericalIssue;
  
  return m_iparm(IPARM_ERROR_NUMBER)==0;
}

◆ _solve_impl() [2/2]

void Eigen::SparseSolverBase< PastixLLT< _MatrixType, _UpLo > >::_solve_impl	(	const SparseMatrixBase< Rhs > &	b,
		SparseMatrixBase< Dest > &	dest
	)		const

inlineinherited

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

◆ analyzePattern() [1/2]

void Eigen::PastixBase< PastixLLT< _MatrixType, _UpLo > >::analyzePattern ( ColSpMatrix & mat )

protectedinherited

{                         
  eigen_assert(m_initisOk && "The initialization of PaSTiX failed");
  
  // clean previous calls
  if(m_size>0)
    clean();
  
  m_size = internal::convert_index<int>(mat.rows());
  m_perm.resize(m_size);
  m_invp.resize(m_size);
  
  m_iparm(IPARM_START_TASK) = API_TASK_ORDERING;
  m_iparm(IPARM_END_TASK) = API_TASK_ANALYSE;
  internal::eigen_pastix(&m_pastixdata, MPI_COMM_WORLD, m_size, mat.outerIndexPtr(), mat.innerIndexPtr(),
               mat.valuePtr(), m_perm.data(), m_invp.data(), 0, 0, m_iparm.data(), m_dparm.data());
  
  // Check the returned error
  if(m_iparm(IPARM_ERROR_NUMBER))
  {
    m_info = NumericalIssue;
    m_analysisIsOk = false;
  }
  else
  { 
    m_info = Success;
    m_analysisIsOk = true;
  }
}

◆ analyzePattern() [2/2]

template<typename _MatrixType , int _UpLo>

void Eigen::PastixLLT< _MatrixType, _UpLo >::analyzePattern ( const MatrixType & matrix )

inline

Compute the LL^T symbolic factorization of matrix using its sparsity pattern The result of this operation can be used with successive matrices having the same pattern as matrix

See also: factorize()

    {
      ColSpMatrix temp;
      grabMatrix(matrix, temp);
      Base::analyzePattern(temp);
    }

References Eigen::PastixBase< Derived >::analyzePattern(), and Eigen::PastixLLT< _MatrixType, _UpLo >::grabMatrix().

Here is the call graph for this function:

◆ clean()

void Eigen::PastixBase< PastixLLT< _MatrixType, _UpLo > >::clean ( )

inlineprotectedinherited

    {
      eigen_assert(m_initisOk && "The Pastix structure should be allocated first"); 
      m_iparm(IPARM_START_TASK) = API_TASK_CLEAN;
      m_iparm(IPARM_END_TASK) = API_TASK_CLEAN;
      internal::eigen_pastix(&m_pastixdata, MPI_COMM_WORLD, 0, 0, 0, (Scalar*)0,
                             m_perm.data(), m_invp.data(), 0, 0, m_iparm.data(), m_dparm.data());
    }

◆ cols()

Index Eigen::PastixBase< PastixLLT< _MatrixType, _UpLo > >::cols ( ) const

inlineinherited

201{ return m_size; }

◆ compute() [1/2]

void Eigen::PastixBase< PastixLLT< _MatrixType, _UpLo > >::compute ( ColSpMatrix & mat )

protectedinherited

{
  eigen_assert(mat.rows() == mat.cols() && "The input matrix should be squared");
  
  analyzePattern(mat);  
  factorize(mat);
  
  m_iparm(IPARM_MATRIX_VERIFICATION) = API_NO;
}

◆ compute() [2/2]

template<typename _MatrixType , int _UpLo>

void Eigen::PastixLLT< _MatrixType, _UpLo >::compute ( const MatrixType & matrix )

inline

Compute the L factor of the LL^T supernodal factorization of matrix

See also: analyzePattern() factorize()

    {
      ColSpMatrix temp;
      grabMatrix(matrix, temp);
      Base::compute(temp);
    }

References Eigen::PastixBase< Derived >::compute(), and Eigen::PastixLLT< _MatrixType, _UpLo >::grabMatrix().

Referenced by Eigen::PastixLLT< _MatrixType, _UpLo >::PastixLLT().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ derived() [1/2]

PastixLLT< _MatrixType, _UpLo > & Eigen::SparseSolverBase< PastixLLT< _MatrixType, _UpLo > >::derived ( )

inlineprotectedinherited

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

◆ derived() [2/2]

const PastixLLT< _MatrixType, _UpLo > & Eigen::SparseSolverBase< PastixLLT< _MatrixType, _UpLo > >::derived ( ) const

inlineprotectedinherited

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

◆ dparm() [1/2]

Array< double, DPARM_SIZE, 1 > & Eigen::PastixBase< PastixLLT< _MatrixType, _UpLo > >::dparm ( )

inlineinherited

Returns a reference to the double vector DPARM of PaStiX parameters The statistics related to the different phases of factorization and solve are saved here as well

See also: analyzePattern() factorize()

    {
      return m_dparm; 
    }

◆ dparm() [2/2]

double & Eigen::PastixBase< PastixLLT< _MatrixType, _UpLo > >::dparm ( int idxparam )

inlineinherited

Return a reference to a particular index parameter of the DPARM vector

See also: dparm()

    {
      return m_dparm(idxparam);
    }

◆ factorize() [1/2]

void Eigen::PastixBase< PastixLLT< _MatrixType, _UpLo > >::factorize ( ColSpMatrix & mat )

protectedinherited

{
//   if(&m_cpyMat != &mat) m_cpyMat = mat;
  eigen_assert(m_analysisIsOk && "The analysis phase should be called before the factorization phase");
  m_iparm(IPARM_START_TASK) = API_TASK_NUMFACT;
  m_iparm(IPARM_END_TASK) = API_TASK_NUMFACT;
  m_size = internal::convert_index<int>(mat.rows());
  
  internal::eigen_pastix(&m_pastixdata, MPI_COMM_WORLD, m_size, mat.outerIndexPtr(), mat.innerIndexPtr(),
               mat.valuePtr(), m_perm.data(), m_invp.data(), 0, 0, m_iparm.data(), m_dparm.data());
  
  // Check the returned error
  if(m_iparm(IPARM_ERROR_NUMBER))
  {
    m_info = NumericalIssue;
    m_factorizationIsOk = false;
    m_isInitialized = false;
  }
  else
  {
    m_info = Success;
    m_factorizationIsOk = true;
    m_isInitialized = true;
  }
}

◆ factorize() [2/2]

template<typename _MatrixType , int _UpLo>

void Eigen::PastixLLT< _MatrixType, _UpLo >::factorize ( const MatrixType & matrix )

inline

Compute the LL^T supernodal numerical factorization of matrix

See also: analyzePattern()

    {
      ColSpMatrix temp;
      grabMatrix(matrix, temp);
      Base::factorize(temp);
    }

References Eigen::PastixBase< Derived >::factorize(), and Eigen::PastixLLT< _MatrixType, _UpLo >::grabMatrix().

Here is the call graph for this function:

◆ grabMatrix()

template<typename _MatrixType , int _UpLo>

void Eigen::PastixLLT< _MatrixType, _UpLo >::grabMatrix	(	const MatrixType &	matrix,
		ColSpMatrix &	out
	)

inlineprotected

    {
      out.resize(matrix.rows(), matrix.cols());
      // Pastix supports only lower, column-major matrices 
      out.template selfadjointView<Lower>() = matrix.template selfadjointView<UpLo>();
      internal::c_to_fortran_numbering(out);
    }

References Eigen::internal::c_to_fortran_numbering(), and Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::resize().

Referenced by Eigen::PastixLLT< _MatrixType, _UpLo >::analyzePattern(), Eigen::PastixLLT< _MatrixType, _UpLo >::compute(), and Eigen::PastixLLT< _MatrixType, _UpLo >::factorize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ info()

ComputationInfo Eigen::PastixBase< PastixLLT< _MatrixType, _UpLo > >::info ( ) const

inlineinherited

Reports whether previous computation was successful.

Returns: Success if computation was succesful, NumericalIssue if the PaStiX reports a problem InvalidInput if the input matrix is invalid

See also: iparm()

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

◆ init()

template<typename _MatrixType , int _UpLo>

void Eigen::PastixLLT< _MatrixType, _UpLo >::init ( )

inlineprotected

    {
      m_iparm(IPARM_SYM) = API_SYM_YES;
      m_iparm(IPARM_FACTORIZATION) = API_FACT_LLT;
    }

References Eigen::PastixLLT< _MatrixType, _UpLo >::m_iparm.

Referenced by Eigen::PastixLLT< _MatrixType, _UpLo >::PastixLLT(), and Eigen::PastixLLT< _MatrixType, _UpLo >::PastixLLT().

Here is the caller graph for this function:

◆ iparm() [1/2]

Array< StorageIndex, IPARM_SIZE, 1 > & Eigen::PastixBase< PastixLLT< _MatrixType, _UpLo > >::iparm ( )

inlineinherited

Returns a reference to the integer vector IPARM of PaStiX parameters to modify the default parameters. The statistics related to the different phases of factorization and solve are saved here as well

See also: analyzePattern() factorize()

    {
      return m_iparm; 
    }

◆ iparm() [2/2]

int & Eigen::PastixBase< PastixLLT< _MatrixType, _UpLo > >::iparm ( int idxparam )

inlineinherited

Return a reference to a particular index parameter of the IPARM vector

See also: iparm()

    {
      return m_iparm(idxparam);
    }

◆ rows()

Index Eigen::PastixBase< PastixLLT< _MatrixType, _UpLo > >::rows ( ) const

inlineinherited

202{ return m_size; }

◆ solve() [1/2]

template<typename Derived >

template<typename Rhs >

const Solve< Derived, Rhs > Eigen::SparseSolverBase< Derived >::solve ( const MatrixBase< Rhs > & b ) const

inlineinherited

Returns: an expression of the solution x of using the current decomposition of A.

See also: compute()

    {
      eigen_assert(m_isInitialized && "Solver is not initialized.");
      eigen_assert(derived().rows()==b.rows() && "solve(): invalid number of rows of the right hand side matrix b");
      return Solve<Derived, Rhs>(derived(), b.derived());
    }

References Eigen::SparseSolverBase< Derived >::derived(), eigen_assert, and Eigen::SparseSolverBase< Derived >::m_isInitialized.

Referenced by igl::embree::bone_heat(), igl::Frame_field_deformer::compute_optimal_positions(), igl::eigs(), igl::copyleft::comiso::FrameInterpolator::interpolateSymmetric(), igl::slim::solve_weighted_arap(), and igl::copyleft::comiso::NRosyField::solveNoRoundings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ solve() [2/2]

template<typename Derived >

template<typename Rhs >

const Solve< Derived, Rhs > Eigen::SparseSolverBase< Derived >::solve ( const SparseMatrixBase< Rhs > & b ) const

inlineinherited

Returns: an expression of the solution x of using the current decomposition of A.

See also: compute()

    {
      eigen_assert(m_isInitialized && "Solver is not initialized.");
      eigen_assert(derived().rows()==b.rows() && "solve(): invalid number of rows of the right hand side matrix b");
      return Solve<Derived, Rhs>(derived(), b.derived());
    }

Member Data Documentation

◆ m_analysisIsOk

int Eigen::PastixBase< PastixLLT< _MatrixType, _UpLo > >::m_analysisIsOk

protectedinherited

◆ m_comm

int Eigen::PastixBase< PastixLLT< _MatrixType, _UpLo > >::m_comm

mutableprotectedinherited

◆ m_dparm

Array<double,DPARM_SIZE,1> Eigen::PastixBase< PastixLLT< _MatrixType, _UpLo > >::m_dparm

mutableprotectedinherited

◆ m_factorizationIsOk

int Eigen::PastixBase< PastixLLT< _MatrixType, _UpLo > >::m_factorizationIsOk

protectedinherited

◆ m_info

ComputationInfo Eigen::PastixBase< PastixLLT< _MatrixType, _UpLo > >::m_info

mutableprotectedinherited

◆ m_initisOk

int Eigen::PastixBase< PastixLLT< _MatrixType, _UpLo > >::m_initisOk

protectedinherited

◆ m_invp

Matrix<StorageIndex,Dynamic,1> Eigen::PastixBase< PastixLLT< _MatrixType, _UpLo > >::m_invp

mutableprotectedinherited

◆ m_iparm

template<typename _MatrixType , int _UpLo>

Array<int,IPARM_SIZE,1> Eigen::PastixBase< Derived >::m_iparm

mutableprotected

Referenced by Eigen::PastixLLT< _MatrixType, _UpLo >::init().

◆ m_isInitialized

bool Eigen::SparseSolverBase< PastixLLT< _MatrixType, _UpLo > >::m_isInitialized

mutableprotectedinherited

◆ m_pastixdata

pastix_data_t* Eigen::PastixBase< PastixLLT< _MatrixType, _UpLo > >::m_pastixdata

mutableprotectedinherited

◆ m_perm

Matrix<StorageIndex,Dynamic,1> Eigen::PastixBase< PastixLLT< _MatrixType, _UpLo > >::m_perm

mutableprotectedinherited

◆ m_size

int Eigen::PastixBase< PastixLLT< _MatrixType, _UpLo > >::m_size

mutableprotectedinherited

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

src/eigen/Eigen/src/PaStiXSupport/PaStiXSupport.h

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ _MatrixType

◆ Base

◆ ColSpMatrix

◆ MatrixType

◆ RealScalar

◆ Scalar

◆ StorageIndex

◆ Vector

Member Enumeration Documentation

◆ anonymous enum

◆ anonymous enum

Constructor & Destructor Documentation

◆ PastixLLT() [1/2]

◆ PastixLLT() [2/2]

Member Function Documentation

◆ _solve_impl() [1/2]

◆ _solve_impl() [2/2]

◆ analyzePattern() [1/2]

◆ analyzePattern() [2/2]

◆ clean()

◆ cols()

◆ compute() [1/2]

◆ compute() [2/2]

◆ derived() [1/2]

◆ derived() [2/2]

◆ dparm() [1/2]

◆ dparm() [2/2]

◆ factorize() [1/2]

◆ factorize() [2/2]

◆ grabMatrix()

◆ info()

◆ init()

◆ iparm() [1/2]

◆ iparm() [2/2]

◆ rows()

◆ solve() [1/2]

◆ solve() [2/2]

Member Data Documentation

◆ m_analysisIsOk

◆ m_comm

◆ m_dparm

◆ m_factorizationIsOk

◆ m_info

◆ m_initisOk

◆ m_invp

◆ m_iparm

◆ m_isInitialized

◆ m_pastixdata

◆ m_perm

◆ m_size