Eigen::UmfPackLU< _MatrixType > Class Template Reference

A sparse LU factorization and solver based on UmfPack. More...

#include <UmfPackSupport.h>

Inheritance diagram for Eigen::UmfPackLU< _MatrixType >:

Collaboration diagram for Eigen::UmfPackLU< _MatrixType >:

Public Types
typedef _MatrixType	MatrixType
typedef MatrixType::Scalar	Scalar
typedef MatrixType::RealScalar	RealScalar
typedef MatrixType::Index	Index
typedef Matrix< Scalar, Dynamic, 1 >	Vector
typedef Matrix< int, 1, MatrixType::ColsAtCompileTime >	IntRowVectorType
typedef Matrix< int, MatrixType::RowsAtCompileTime, 1 >	IntColVectorType
typedef SparseMatrix< Scalar >	LUMatrixType
typedef SparseMatrix< Scalar, ColMajor, int >	UmfpackMatrixType

Public Member Functions
	UmfPackLU (const MatrixType &matrix)
Index	rows () const
Index	cols () const
ComputationInfo	info () const
	Reports whether previous computation was successful. More...
const LUMatrixType &	matrixL () const
const LUMatrixType &	matrixU () const
const IntColVectorType &	permutationP () const
const IntRowVectorType &	permutationQ () const
void	compute (const MatrixType &matrix)
template<typename Rhs >
const internal::solve_retval< UmfPackLU, Rhs >	solve (const MatrixBase< Rhs > &b) const
template<typename Rhs >
const internal::sparse_solve_retval< UmfPackLU, Rhs >	solve (const SparseMatrixBase< Rhs > &b) const
void	analyzePattern (const MatrixType &matrix)
void	factorize (const MatrixType &matrix)
template<typename BDerived , typename XDerived >
bool	_solve (const MatrixBase< BDerived > &b, MatrixBase< XDerived > &x) const
Scalar	determinant () const
void	extractData () const

Protected Member Functions
void	init ()
void	grapInput (const MatrixType &mat)

Protected Attributes
LUMatrixType	m_l
LUMatrixType	m_u
IntColVectorType	m_p
IntRowVectorType	m_q
UmfpackMatrixType	m_copyMatrix
const Scalar *	m_valuePtr
const int *	m_outerIndexPtr
const int *	m_innerIndexPtr
void *	m_numeric
void *	m_symbolic
ComputationInfo	m_info
bool	m_isInitialized
int	m_factorizationIsOk
int	m_analysisIsOk
bool	m_extractedDataAreDirty

Detailed Description

template<typename _MatrixType>
class Eigen::UmfPackLU< _MatrixType >

A sparse LU factorization and solver based on UmfPack.

This class allows to solve for A.X = B sparse linear problems via a LU factorization using the UmfPack library. The sparse matrix A must be squared and full rank. The vectors or matrices X and B can be either dense or sparse.

Warning

The input matrix A should be in a compressed and column-major form. Otherwise an expensive copy will be made. You can call the inexpensive makeCompressed() to get a compressed matrix.

Template Parameters

_MatrixType

the type of the sparse matrix A, it must be a SparseMatrix<>

See also

TutorialSparseDirectSolvers

Definition at line 124 of file UmfPackSupport.h.

Member Function Documentation

template<typename _MatrixType>

void Eigen::UmfPackLU< _MatrixType >::analyzePattern ( const MatrixType &  matrix )

inline

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

Definition at line 233 of file UmfPackSupport.h.

    {
      if(m_symbolic)
        umfpack_free_symbolic(&m_symbolic,Scalar());
      if(m_numeric)
        umfpack_free_numeric(&m_numeric,Scalar());
      
      grapInput(matrix);

      int errorCode = 0;
      errorCode = umfpack_symbolic(matrix.rows(), matrix.cols(), m_outerIndexPtr, m_innerIndexPtr, m_valuePtr,
                                   &m_symbolic, 0, 0);

      m_isInitialized = true;
      m_info = errorCode ? InvalidInput : Success;
      m_analysisIsOk = true;
      m_factorizationIsOk = false;
    }

template<typename _MatrixType>

void Eigen::UmfPackLU< _MatrixType >::compute ( const MatrixType &  matrix )

inline

Computes the sparse Cholesky decomposition of matrix Note that the matrix should be column-major, and in compressed format for best performance.

See also

SparseMatrix::makeCompressed().

Definition at line 195 of file UmfPackSupport.h.

    {
      analyzePattern(matrix);
      factorize(matrix);
    }

template<typename _MatrixType>

void Eigen::UmfPackLU< _MatrixType >::factorize ( const MatrixType &  matrix )

inline

Performs a numeric decomposition of matrix

The given matrix must has the same sparcity than the matrix on which the pattern anylysis has been performed.

See also

analyzePattern(), compute()

Definition at line 258 of file UmfPackSupport.h.

    {
      eigen_assert(m_analysisIsOk && "UmfPackLU: you must first call analyzePattern()");
      if(m_numeric)
        umfpack_free_numeric(&m_numeric,Scalar());

      grapInput(matrix);

      int errorCode;
      errorCode = umfpack_numeric(m_outerIndexPtr, m_innerIndexPtr, m_valuePtr,
                                  m_symbolic, &m_numeric, 0, 0);

      m_info = errorCode ? NumericalIssue : Success;
      m_factorizationIsOk = true;
    }

template<typename _MatrixType>

ComputationInfo Eigen::UmfPackLU< _MatrixType >::info ( ) const

inline

Reports whether previous computation was successful.

Returns

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

Definition at line 161 of file UmfPackSupport.h.

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

template<typename _MatrixType>

template<typename Rhs >

const internal::solve_retval<UmfPackLU, Rhs> Eigen::UmfPackLU< _MatrixType >::solve ( const MatrixBase< Rhs > &  b ) const

inline

Returns

the solution x of using the current decomposition of A.

See also

compute()

Definition at line 206 of file UmfPackSupport.h.

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

template<typename _MatrixType>

template<typename Rhs >

const internal::sparse_solve_retval<UmfPackLU, Rhs> Eigen::UmfPackLU< _MatrixType >::solve ( const SparseMatrixBase< Rhs > &  b ) const

inline

Returns

the solution x of using the current decomposition of A.

See also

compute()

Definition at line 219 of file UmfPackSupport.h.

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

---

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

• C:/Users/Brig/Documents/ShapeWorksStudio/src/Surfworks/Eigen/src/UmfPackSupport/UmfPackSupport.h