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

Inheritance diagram for Eigen::PastixBase< Derived >:

Collaboration diagram for Eigen::PastixBase< Derived >:

Public Types
enum	{ ColsAtCompileTime = MatrixType::ColsAtCompileTime , MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime }

typedef internal::pastix_traits< Derived >::MatrixType	_MatrixType

typedef _MatrixType	MatrixType

typedef MatrixType::Scalar	Scalar

typedef MatrixType::RealScalar	RealScalar

typedef MatrixType::StorageIndex	StorageIndex

typedef Matrix< Scalar, Dynamic, 1 >	Vector

typedef SparseMatrix< Scalar, ColMajor >	ColSpMatrix

Public Member Functions
	PastixBase ()

	~PastixBase ()

template<typename Rhs , typename Dest >
bool	_solve_impl (const MatrixBase< Rhs > &b, MatrixBase< Dest > &x) 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 , typename Dest >
void	_solve_impl (const SparseMatrixBase< Rhs > &b, SparseMatrixBase< Dest > &dest) 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

Protected Types
typedef SparseSolverBase< Derived >	Base

Protected Member Functions
void	init ()

void	analyzePattern (ColSpMatrix &mat)

void	factorize (ColSpMatrix &mat)

void	clean ()

void	compute (ColSpMatrix &mat)

Derived &	derived ()

const Derived &	derived () const

Protected Attributes
int	m_initisOk

int	m_analysisIsOk

int	m_factorizationIsOk

ComputationInfo	m_info

pastix_data_t *	m_pastixdata

int	m_comm

Array< int, IPARM_SIZE, 1 >	m_iparm

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<class Derived>
class Eigen::PastixBase< Derived >

Member Typedef Documentation

◆ _MatrixType

template<class Derived >

typedef internal::pastix_traits<Derived>::MatrixType Eigen::PastixBase< Derived >::_MatrixType

◆ Base

template<class Derived >

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

protected

◆ ColSpMatrix

template<class Derived >

typedef SparseMatrix<Scalar, ColMajor> Eigen::PastixBase< Derived >::ColSpMatrix

◆ MatrixType

template<class Derived >

typedef _MatrixType Eigen::PastixBase< Derived >::MatrixType

◆ RealScalar

template<class Derived >

typedef MatrixType::RealScalar Eigen::PastixBase< Derived >::RealScalar

◆ Scalar

template<class Derived >

typedef MatrixType::Scalar Eigen::PastixBase< Derived >::Scalar

◆ StorageIndex

template<class Derived >

typedef MatrixType::StorageIndex Eigen::PastixBase< Derived >::StorageIndex

◆ Vector

template<class Derived >

typedef Matrix<Scalar,Dynamic,1> Eigen::PastixBase< Derived >::Vector

Member Enumeration Documentation

◆ anonymous enum

template<class Derived >

anonymous enum

Enumerator
ColsAtCompileTime
MaxColsAtCompileTime

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

Constructor & Destructor Documentation

◆ PastixBase()

template<class Derived >

Eigen::PastixBase< Derived >::PastixBase ( )

inline

                 : m_initisOk(false), m_analysisIsOk(false), m_factorizationIsOk(false), m_pastixdata(0), m_size(0)
    {
      init();
    }

References Eigen::PastixBase< Derived >::init().

Here is the call graph for this function:

◆ ~PastixBase()

template<class Derived >

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

inline

    {
      clean();
    }

References Eigen::PastixBase< Derived >::clean().

Here is the call graph for this function:

Member Function Documentation

◆ _solve_impl() [1/2]

template<typename Base >

template<typename Rhs , typename Dest >

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

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

References eigen_assert, Eigen::internal::eigen_pastix(), EIGEN_STATIC_ASSERT, Eigen::NumericalIssue, Eigen::RowMajorBit, and Eigen::Success.

Here is the call graph for this function:

◆ _solve_impl() [2/2]

template<class Derived >

template<typename Rhs , typename Dest >

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

inline

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

◆ analyzePattern()

template<class Derived >

void Eigen::PastixBase< Derived >::analyzePattern ( ColSpMatrix & mat )

protected

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

References eigen_assert, Eigen::internal::eigen_pastix(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::innerIndexPtr(), Eigen::NumericalIssue, Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::outerIndexPtr(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::rows(), Eigen::Success, and Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::valuePtr().

Referenced by Eigen::PastixLU< _MatrixType, IsStrSym >::analyzePattern(), Eigen::PastixLLT< _MatrixType, _UpLo >::analyzePattern(), and Eigen::PastixLDLT< _MatrixType, _UpLo >::analyzePattern().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clean()

template<class Derived >

void Eigen::PastixBase< Derived >::clean ( )

inlineprotected

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

References Eigen::PlainObjectBase< Derived >::data(), eigen_assert, Eigen::internal::eigen_pastix(), Eigen::PastixBase< Derived >::m_dparm, Eigen::PastixBase< Derived >::m_initisOk, Eigen::PastixBase< Derived >::m_invp, Eigen::PastixBase< Derived >::m_iparm, Eigen::PastixBase< Derived >::m_pastixdata, and Eigen::PastixBase< Derived >::m_perm.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cols()

template<class Derived >

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

inline

201{ return m_size; }

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

◆ compute()

template<class Derived >

void Eigen::PastixBase< Derived >::compute ( ColSpMatrix & mat )

protected

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

References Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::cols(), eigen_assert, and Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::rows().

Referenced by Eigen::PastixLU< _MatrixType, IsStrSym >::compute(), Eigen::PastixLLT< _MatrixType, _UpLo >::compute(), and Eigen::PastixLDLT< _MatrixType, _UpLo >::compute().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ derived() [1/2]

template<class Derived >

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

inlineprotected

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

◆ derived() [2/2]

template<class Derived >

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

inlineprotected

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

◆ dparm() [1/2]

template<class Derived >

Array< double, DPARM_SIZE, 1 > & Eigen::PastixBase< Derived >::dparm ( )

inline

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

References Eigen::PastixBase< Derived >::m_dparm.

◆ dparm() [2/2]

template<class Derived >

double & Eigen::PastixBase< Derived >::dparm ( int idxparam )

inline

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

See also: dparm()

    {
      return m_dparm(idxparam);
    }

References Eigen::PastixBase< Derived >::m_dparm.

◆ factorize()

template<class Derived >

void Eigen::PastixBase< Derived >::factorize ( ColSpMatrix & mat )

protected

{
//   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;
  }
}

References eigen_assert, Eigen::internal::eigen_pastix(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::innerIndexPtr(), Eigen::NumericalIssue, Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::outerIndexPtr(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::rows(), Eigen::Success, and Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::valuePtr().

Referenced by Eigen::PastixLU< _MatrixType, IsStrSym >::factorize(), Eigen::PastixLLT< _MatrixType, _UpLo >::factorize(), and Eigen::PastixLDLT< _MatrixType, _UpLo >::factorize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ info()

template<class Derived >

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

inline

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

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

◆ init()

template<class Derived >

void Eigen::PastixBase< Derived >::init

protected

Initialize the PaStiX data structure. A first call to this function fills iparm and dparm with the default PaStiX parameters

See also: iparm() dparm()

{
  m_size = 0; 
  m_iparm.setZero(IPARM_SIZE);
  m_dparm.setZero(DPARM_SIZE);
  
  m_iparm(IPARM_MODIFY_PARAMETER) = API_NO;
  pastix(&m_pastixdata, MPI_COMM_WORLD,
         0, 0, 0, 0,
         0, 0, 0, 1, m_iparm.data(), m_dparm.data());
  
  m_iparm[IPARM_MATRIX_VERIFICATION] = API_NO;
  m_iparm[IPARM_VERBOSE]             = API_VERBOSE_NOT;
  m_iparm[IPARM_ORDERING]            = API_ORDER_SCOTCH;
  m_iparm[IPARM_INCOMPLETE]          = API_NO;
  m_iparm[IPARM_OOC_LIMIT]           = 2000;
  m_iparm[IPARM_RHS_MAKING]          = API_RHS_B;
  m_iparm(IPARM_MATRIX_VERIFICATION) = API_NO;
  
  m_iparm(IPARM_START_TASK) = API_TASK_INIT;
  m_iparm(IPARM_END_TASK) = API_TASK_INIT;
  internal::eigen_pastix(&m_pastixdata, MPI_COMM_WORLD, 0, 0, 0, (Scalar*)0,
                         0, 0, 0, 0, m_iparm.data(), m_dparm.data());
  
  // Check the returned error
  if(m_iparm(IPARM_ERROR_NUMBER)) {
    m_info = InvalidInput;
    m_initisOk = false;
  }
  else { 
    m_info = Success;
    m_initisOk = true;
  }
}

References Eigen::internal::eigen_pastix(), Eigen::InvalidInput, and Eigen::Success.

Referenced by Eigen::PastixBase< Derived >::PastixBase().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ iparm() [1/2]

template<class Derived >

Array< StorageIndex, IPARM_SIZE, 1 > & Eigen::PastixBase< Derived >::iparm ( )

inline

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

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

◆ iparm() [2/2]

template<class Derived >

int & Eigen::PastixBase< Derived >::iparm ( int idxparam )

inline

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

See also: iparm()

    {
      return m_iparm(idxparam);
    }

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

◆ rows()

template<class Derived >

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

inline

202{ return m_size; }

References Eigen::PastixBase< Derived >::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

template<class Derived >

int Eigen::PastixBase< Derived >::m_analysisIsOk

protected

◆ m_comm

template<class Derived >

int Eigen::PastixBase< Derived >::m_comm

mutableprotected

◆ m_dparm

template<class Derived >

Array<double,DPARM_SIZE,1> Eigen::PastixBase< Derived >::m_dparm

mutableprotected

Referenced by Eigen::PastixBase< Derived >::clean(), Eigen::PastixBase< Derived >::dparm(), and Eigen::PastixBase< Derived >::dparm().

◆ m_factorizationIsOk

template<class Derived >

int Eigen::PastixBase< Derived >::m_factorizationIsOk

protected

◆ m_info

template<class Derived >

ComputationInfo Eigen::PastixBase< Derived >::m_info

mutableprotected

Referenced by Eigen::PastixBase< Derived >::info().

◆ m_initisOk

template<class Derived >

int Eigen::PastixBase< Derived >::m_initisOk

protected

Referenced by Eigen::PastixBase< Derived >::clean().

◆ m_invp

template<class Derived >

Matrix<StorageIndex,Dynamic,1> Eigen::PastixBase< Derived >::m_invp

mutableprotected

Referenced by Eigen::PastixBase< Derived >::clean().

◆ m_iparm

template<class Derived >

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

mutableprotected

Referenced by Eigen::PastixBase< Derived >::clean(), Eigen::PastixBase< Derived >::iparm(), and Eigen::PastixBase< Derived >::iparm().

◆ m_isInitialized

template<class Derived >

bool Eigen::SparseSolverBase< Derived >::m_isInitialized

mutableprotected

Referenced by Eigen::PastixBase< Derived >::info().

◆ m_pastixdata

template<class Derived >

pastix_data_t* Eigen::PastixBase< Derived >::m_pastixdata

mutableprotected

Referenced by Eigen::PastixBase< Derived >::clean().

◆ m_perm

template<class Derived >

Matrix<StorageIndex,Dynamic,1> Eigen::PastixBase< Derived >::m_perm

mutableprotected

Referenced by Eigen::PastixBase< Derived >::clean().

◆ m_size

template<class Derived >

int Eigen::PastixBase< Derived >::m_size

mutableprotected

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

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

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

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ _MatrixType

◆ Base

◆ ColSpMatrix

◆ MatrixType

◆ RealScalar

◆ Scalar

◆ StorageIndex

◆ Vector

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ PastixBase()

◆ ~PastixBase()

Member Function Documentation

◆ _solve_impl() [1/2]

◆ _solve_impl() [2/2]

◆ analyzePattern()

◆ clean()

◆ cols()

◆ compute()

◆ derived() [1/2]

◆ derived() [2/2]

◆ dparm() [1/2]

◆ dparm() [2/2]

◆ factorize()

◆ 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