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_ >:

Public Types
enum	{ ColsAtCompileTime = MatrixType::ColsAtCompileTime , MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime }
typedef MatrixType_	MatrixType
typedef MatrixType::Scalar	Scalar
typedef MatrixType::RealScalar	RealScalar
typedef MatrixType::StorageIndex	StorageIndex
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, StorageIndex >	UmfpackMatrixType
typedef Ref< const UmfpackMatrixType, StandardCompressedFormat >	UmfpackMatrixRef
typedef Array< double, UMFPACK_CONTROL, 1 >	UmfpackControl
typedef Array< double, UMFPACK_INFO, 1 >	UmfpackInfo

Public Member Functions
	UmfPackLU ()
template<typename InputMatrixType >
	UmfPackLU (const InputMatrixType &matrix)
	~UmfPackLU ()
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
template<typename InputMatrixType >
void	compute (const InputMatrixType &matrix)
template<typename InputMatrixType >
void	analyzePattern (const InputMatrixType &matrix)
int	umfpackFactorizeReturncode () const
const UmfpackControl &	umfpackControl () const
UmfpackControl &	umfpackControl ()
template<typename InputMatrixType >
void	factorize (const InputMatrixType &matrix)
void	printUmfpackControl ()
void	printUmfpackInfo ()
void	printUmfpackStatus ()
template<typename BDerived , typename XDerived >
bool	_solve_impl (const MatrixBase< BDerived > &b, MatrixBase< XDerived > &x) const
Scalar	determinant () const
void	extractData () const
Public Member Functions inherited from Eigen::SparseSolverBase< UmfPackLU< MatrixType_ > >
	SparseSolverBase ()
	SparseSolverBase (SparseSolverBase &&other)
	~SparseSolverBase ()
UmfPackLU< MatrixType_ > &	derived ()
const UmfPackLU< MatrixType_ > &	derived () const
const Solve< UmfPackLU< MatrixType_ >, Rhs >	solve (const MatrixBase< Rhs > &b) const
const Solve< UmfPackLU< MatrixType_ >, Rhs >	solve (const SparseMatrixBase< Rhs > &b) const
void	_solve_impl (const SparseMatrixBase< Rhs > &b, SparseMatrixBase< Dest > &dest) const

Protected Types
typedef SparseSolverBase< UmfPackLU< MatrixType_ > >	Base

Protected Member Functions
void	init ()
void	analyzePattern_impl ()
void	factorize_impl ()
template<typename MatrixDerived >
void	grab (const EigenBase< MatrixDerived > &A)
void	grab (const UmfpackMatrixRef &A)

Protected Attributes
LUMatrixType	m_l
StorageIndex	m_fact_errorCode
UmfpackControl	m_control
UmfpackInfo	m_umfpackInfo
LUMatrixType	m_u
IntColVectorType	m_p
IntRowVectorType	m_q
UmfpackMatrixType	m_dummy
UmfpackMatrixRef	mp_matrix
void *	m_numeric
void *	m_symbolic
ComputationInfo	m_info
int	m_factorizationIsOk
int	m_analysisIsOk
bool	m_extractedDataAreDirty
Protected Attributes inherited from Eigen::SparseSolverBase< UmfPackLU< MatrixType_ > >
bool	m_isInitialized

Private Member Functions
	UmfPackLU (const UmfPackLU &)

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

\implsparsesolverconcept

See also

Sparse solver concept, class SparseLU

Member Typedef Documentation

Base

template<typename MatrixType_ >

typedef SparseSolverBase<UmfPackLU<MatrixType_> > Eigen::UmfPackLU< MatrixType_ >::Base

protected

IntColVectorType

template<typename MatrixType_ >

typedef Matrix<int, MatrixType::RowsAtCompileTime, 1> Eigen::UmfPackLU< MatrixType_ >::IntColVectorType

IntRowVectorType

template<typename MatrixType_ >

typedef Matrix<int, 1, MatrixType::ColsAtCompileTime> Eigen::UmfPackLU< MatrixType_ >::IntRowVectorType

LUMatrixType

template<typename MatrixType_ >

typedef SparseMatrix<Scalar> Eigen::UmfPackLU< MatrixType_ >::LUMatrixType

MatrixType

template<typename MatrixType_ >

typedef MatrixType_ Eigen::UmfPackLU< MatrixType_ >::MatrixType

RealScalar

template<typename MatrixType_ >

typedef MatrixType::RealScalar Eigen::UmfPackLU< MatrixType_ >::RealScalar

Scalar

template<typename MatrixType_ >

typedef MatrixType::Scalar Eigen::UmfPackLU< MatrixType_ >::Scalar

StorageIndex

template<typename MatrixType_ >

typedef MatrixType::StorageIndex Eigen::UmfPackLU< MatrixType_ >::StorageIndex

UmfpackControl

template<typename MatrixType_ >

typedef Array<double, UMFPACK_CONTROL, 1> Eigen::UmfPackLU< MatrixType_ >::UmfpackControl

UmfpackInfo

template<typename MatrixType_ >

typedef Array<double, UMFPACK_INFO, 1> Eigen::UmfPackLU< MatrixType_ >::UmfpackInfo

UmfpackMatrixRef

template<typename MatrixType_ >

typedef Ref<const UmfpackMatrixType, StandardCompressedFormat> Eigen::UmfPackLU< MatrixType_ >::UmfpackMatrixRef

UmfpackMatrixType

template<typename MatrixType_ >

typedef SparseMatrix<Scalar, ColMajor, StorageIndex> Eigen::UmfPackLU< MatrixType_ >::UmfpackMatrixType

Vector

template<typename MatrixType_ >

typedef Matrix<Scalar, Dynamic, 1> Eigen::UmfPackLU< MatrixType_ >::Vector

Member Enumeration Documentation

anonymous enum

template<typename MatrixType_ >

anonymous enum

Enumerator
ColsAtCompileTime
MaxColsAtCompileTime

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

Constructor & Destructor Documentation

UmfPackLU() [1/3]

template<typename MatrixType_ >

Eigen::UmfPackLU< MatrixType_ >::UmfPackLU ( )

inline

: m_dummy(0, 0), mp_matrix(m_dummy) { init(); }

References Eigen::UmfPackLU< MatrixType_ >::init().

UmfPackLU() [2/3]

template<typename MatrixType_ >

template<typename InputMatrixType >

Eigen::UmfPackLU< MatrixType_ >::UmfPackLU ( const InputMatrixType &  matrix )

inlineexplicit

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

References Eigen::UmfPackLU< MatrixType_ >::compute(), Eigen::UmfPackLU< MatrixType_ >::init(), and matrix().

~UmfPackLU()

template<typename MatrixType_ >

Eigen::UmfPackLU< MatrixType_ >::~UmfPackLU ( )

inline

               {
    if (m_symbolic) umfpack_free_symbolic(&m_symbolic, Scalar(), StorageIndex());
    if (m_numeric) umfpack_free_numeric(&m_numeric, Scalar(), StorageIndex());
  }

References Eigen::UmfPackLU< MatrixType_ >::m_numeric, Eigen::UmfPackLU< MatrixType_ >::m_symbolic, Eigen::umfpack_free_numeric(), and Eigen::umfpack_free_symbolic().

UmfPackLU() [3/3]

template<typename MatrixType_ >

Eigen::UmfPackLU< MatrixType_ >::UmfPackLU ( const UmfPackLU< MatrixType_ > &  )

inlineprivate

{}

Member Function Documentation

_solve_impl()

template<typename MatrixType >

template<typename BDerived , typename XDerived >

bool Eigen::UmfPackLU< MatrixType >::_solve_impl	(	const MatrixBase< BDerived > &	b,
		MatrixBase< XDerived > &	x
	)		const

                                                                                                    {
  Index rhsCols = b.cols();
  eigen_assert((BDerived::Flags & RowMajorBit) == 0 && "UmfPackLU backend does not support non col-major rhs yet");
  eigen_assert((XDerived::Flags & RowMajorBit) == 0 && "UmfPackLU backend does not support non col-major result yet");
  eigen_assert(b.derived().data() != x.derived().data() && " Umfpack does not support inplace solve");
 
  Scalar *x_ptr = 0;
  Matrix<Scalar, Dynamic, 1> x_tmp;
  if (x.innerStride() != 1) {
    x_tmp.resize(x.rows());
    x_ptr = x_tmp.data();
  }
  for (int j = 0; j < rhsCols; ++j) {
    if (x.innerStride() == 1) x_ptr = &x.col(j).coeffRef(0);
    StorageIndex errorCode =
        umfpack_solve(UMFPACK_A, mp_matrix.outerIndexPtr(), mp_matrix.innerIndexPtr(), mp_matrix.valuePtr(), x_ptr,
                      &b.const_cast_derived().col(j).coeffRef(0), m_numeric, m_control.data(), m_umfpackInfo.data());
    if (x.innerStride() != 1) x.col(j) = x_tmp;
    if (errorCode != 0) return false;
  }
 
  return true;
}

References b, Eigen::PlainObjectBase< Derived >::data(), eigen_assert, j, Eigen::PlainObjectBase< Derived >::resize(), Eigen::RowMajorBit, Eigen::umfpack_solve(), and plotDoE::x.

analyzePattern()

template<typename MatrixType_ >

template<typename InputMatrixType >

void Eigen::UmfPackLU< MatrixType_ >::analyzePattern ( const InputMatrixType &  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()

                                                     {
    if (m_symbolic) umfpack_free_symbolic(&m_symbolic, Scalar(), StorageIndex());
    if (m_numeric) umfpack_free_numeric(&m_numeric, Scalar(), StorageIndex());
 
    grab(matrix.derived());
 
    analyzePattern_impl();
  }

References Eigen::UmfPackLU< MatrixType_ >::analyzePattern_impl(), Eigen::UmfPackLU< MatrixType_ >::grab(), Eigen::UmfPackLU< MatrixType_ >::m_numeric, Eigen::UmfPackLU< MatrixType_ >::m_symbolic, matrix(), Eigen::umfpack_free_numeric(), and Eigen::umfpack_free_symbolic().

analyzePattern_impl()

template<typename MatrixType_ >

void Eigen::UmfPackLU< MatrixType_ >::analyzePattern_impl ( )

inlineprotected

                             {
    m_fact_errorCode = umfpack_symbolic(internal::convert_index<StorageIndex>(mp_matrix.rows()),
                                        internal::convert_index<StorageIndex>(mp_matrix.cols()),
                                        mp_matrix.outerIndexPtr(), mp_matrix.innerIndexPtr(), mp_matrix.valuePtr(),
                                        &m_symbolic, m_control.data(), m_umfpackInfo.data());
 
    m_isInitialized = true;
    m_info = m_fact_errorCode ? InvalidInput : Success;
    m_analysisIsOk = true;
    m_factorizationIsOk = false;
    m_extractedDataAreDirty = true;
  }

References Eigen::PlainObjectBase< Derived >::data(), Eigen::InvalidInput, Eigen::UmfPackLU< MatrixType_ >::m_analysisIsOk, Eigen::UmfPackLU< MatrixType_ >::m_control, Eigen::UmfPackLU< MatrixType_ >::m_extractedDataAreDirty, Eigen::UmfPackLU< MatrixType_ >::m_fact_errorCode, Eigen::UmfPackLU< MatrixType_ >::m_factorizationIsOk, Eigen::UmfPackLU< MatrixType_ >::m_info, Eigen::SparseSolverBase< UmfPackLU< MatrixType_ > >::m_isInitialized, Eigen::UmfPackLU< MatrixType_ >::m_symbolic, Eigen::UmfPackLU< MatrixType_ >::m_umfpackInfo, Eigen::UmfPackLU< MatrixType_ >::mp_matrix, Eigen::Success, and Eigen::umfpack_symbolic().

Referenced by Eigen::UmfPackLU< MatrixType_ >::analyzePattern(), and Eigen::UmfPackLU< MatrixType_ >::compute().

cols()

template<typename MatrixType_ >

Index Eigen::UmfPackLU< MatrixType_ >::cols ( ) const

inline

{ return mp_matrix.cols(); }

References Eigen::UmfPackLU< MatrixType_ >::mp_matrix.

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<typename MatrixType_ >

template<typename InputMatrixType >

void Eigen::UmfPackLU< MatrixType_ >::compute ( const InputMatrixType &  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().

                                              {
    if (m_symbolic) umfpack_free_symbolic(&m_symbolic, Scalar(), StorageIndex());
    if (m_numeric) umfpack_free_numeric(&m_numeric, Scalar(), StorageIndex());
    grab(matrix.derived());
    analyzePattern_impl();
    factorize_impl();
  }

References Eigen::UmfPackLU< MatrixType_ >::analyzePattern_impl(), Eigen::UmfPackLU< MatrixType_ >::factorize_impl(), Eigen::UmfPackLU< MatrixType_ >::grab(), Eigen::UmfPackLU< MatrixType_ >::m_numeric, Eigen::UmfPackLU< MatrixType_ >::m_symbolic, matrix(), Eigen::umfpack_free_numeric(), and Eigen::umfpack_free_symbolic().

Referenced by Eigen::UmfPackLU< MatrixType_ >::UmfPackLU().

determinant()

template<typename MatrixType >

UmfPackLU< MatrixType >::Scalar Eigen::UmfPackLU< MatrixType >::determinant

                                                                              {
  Scalar det;
  umfpack_get_determinant(&det, 0, m_numeric, 0, StorageIndex());
  return det;
}

References Eigen::umfpack_get_determinant().

extractData()

template<typename MatrixType >

void Eigen::UmfPackLU< MatrixType >::extractData

                                              {
  if (m_extractedDataAreDirty) {
    // get size of the data
    StorageIndex lnz, unz, rows, cols, nz_udiag;
    umfpack_get_lunz(&lnz, &unz, &rows, &cols, &nz_udiag, m_numeric, Scalar());
 
    // allocate data
    m_l.resize(rows, (std::min)(rows, cols));
    m_l.resizeNonZeros(lnz);
 
    m_u.resize((std::min)(rows, cols), cols);
    m_u.resizeNonZeros(unz);
 
    m_p.resize(rows);
    m_q.resize(cols);
 
    // extract
    umfpack_get_numeric(m_l.outerIndexPtr(), m_l.innerIndexPtr(), m_l.valuePtr(), m_u.outerIndexPtr(),
                        m_u.innerIndexPtr(), m_u.valuePtr(), m_p.data(), m_q.data(), 0, 0, 0, m_numeric);
 
    m_extractedDataAreDirty = false;
  }
}

References cols, min, rows, Eigen::umfpack_get_lunz(), and Eigen::umfpack_get_numeric().

Referenced by Eigen::UmfPackLU< MatrixType_ >::matrixL(), Eigen::UmfPackLU< MatrixType_ >::matrixU(), Eigen::UmfPackLU< MatrixType_ >::permutationP(), and Eigen::UmfPackLU< MatrixType_ >::permutationQ().

factorize()

template<typename MatrixType_ >

template<typename InputMatrixType >

void Eigen::UmfPackLU< MatrixType_ >::factorize ( const InputMatrixType &  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()

                                                {
    eigen_assert(m_analysisIsOk && "UmfPackLU: you must first call analyzePattern()");
    if (m_numeric) umfpack_free_numeric(&m_numeric, Scalar(), StorageIndex());
 
    grab(matrix.derived());
 
    factorize_impl();
  }

References eigen_assert, Eigen::UmfPackLU< MatrixType_ >::factorize_impl(), Eigen::UmfPackLU< MatrixType_ >::grab(), Eigen::UmfPackLU< MatrixType_ >::m_analysisIsOk, Eigen::UmfPackLU< MatrixType_ >::m_numeric, matrix(), and Eigen::umfpack_free_numeric().

factorize_impl()

template<typename MatrixType_ >

void Eigen::UmfPackLU< MatrixType_ >::factorize_impl ( )

inlineprotected

                        {
    m_fact_errorCode = umfpack_numeric(mp_matrix.outerIndexPtr(), mp_matrix.innerIndexPtr(), mp_matrix.valuePtr(),
                                       m_symbolic, &m_numeric, m_control.data(), m_umfpackInfo.data());
 
    m_info = m_fact_errorCode == UMFPACK_OK ? Success : NumericalIssue;
    m_factorizationIsOk = true;
    m_extractedDataAreDirty = true;
  }

References Eigen::PlainObjectBase< Derived >::data(), Eigen::UmfPackLU< MatrixType_ >::m_control, Eigen::UmfPackLU< MatrixType_ >::m_extractedDataAreDirty, Eigen::UmfPackLU< MatrixType_ >::m_fact_errorCode, Eigen::UmfPackLU< MatrixType_ >::m_factorizationIsOk, Eigen::UmfPackLU< MatrixType_ >::m_info, Eigen::UmfPackLU< MatrixType_ >::m_numeric, Eigen::UmfPackLU< MatrixType_ >::m_symbolic, Eigen::UmfPackLU< MatrixType_ >::m_umfpackInfo, Eigen::UmfPackLU< MatrixType_ >::mp_matrix, Eigen::NumericalIssue, Eigen::Success, and Eigen::umfpack_numeric().

Referenced by Eigen::UmfPackLU< MatrixType_ >::compute(), and Eigen::UmfPackLU< MatrixType_ >::factorize().

grab() [1/2]

template<typename MatrixType_ >

template<typename MatrixDerived >

void Eigen::UmfPackLU< MatrixType_ >::grab ( const EigenBase< MatrixDerived > &  A )

inlineprotected

                                               {
    internal::destroy_at(&mp_matrix);
    internal::construct_at(&mp_matrix, A.derived());
  }

References Eigen::internal::construct_at(), Eigen::internal::destroy_at(), and Eigen::UmfPackLU< MatrixType_ >::mp_matrix.

Referenced by Eigen::UmfPackLU< MatrixType_ >::analyzePattern(), Eigen::UmfPackLU< MatrixType_ >::compute(), and Eigen::UmfPackLU< MatrixType_ >::factorize().

grab() [2/2]

template<typename MatrixType_ >

void Eigen::UmfPackLU< MatrixType_ >::grab ( const UmfpackMatrixRef &  A )

inlineprotected

                                       {
    if (&(A.derived()) != &mp_matrix) {
      internal::destroy_at(&mp_matrix);
      internal::construct_at(&mp_matrix, A);
    }
  }

References Eigen::internal::construct_at(), Eigen::internal::destroy_at(), and Eigen::UmfPackLU< MatrixType_ >::mp_matrix.

info()

template<typename MatrixType_ >

ComputationInfo Eigen::UmfPackLU< MatrixType_ >::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::UmfPackLU< MatrixType_ >::m_info, and Eigen::SparseSolverBase< UmfPackLU< MatrixType_ > >::m_isInitialized.

init()

template<typename MatrixType_ >

void Eigen::UmfPackLU< MatrixType_ >::init ( )

inlineprotected

              {
    m_info = InvalidInput;
    m_isInitialized = false;
    m_numeric = 0;
    m_symbolic = 0;
    m_extractedDataAreDirty = true;
 
    umfpack_defaults(m_control.data(), Scalar(), StorageIndex());
  }

References Eigen::PlainObjectBase< Derived >::data(), Eigen::InvalidInput, Eigen::UmfPackLU< MatrixType_ >::m_control, Eigen::UmfPackLU< MatrixType_ >::m_extractedDataAreDirty, Eigen::UmfPackLU< MatrixType_ >::m_info, Eigen::SparseSolverBase< UmfPackLU< MatrixType_ > >::m_isInitialized, Eigen::UmfPackLU< MatrixType_ >::m_numeric, Eigen::UmfPackLU< MatrixType_ >::m_symbolic, and Eigen::umfpack_defaults().

Referenced by Eigen::UmfPackLU< MatrixType_ >::UmfPackLU().

matrixL()

template<typename MatrixType_ >

const LUMatrixType& Eigen::UmfPackLU< MatrixType_ >::matrixL ( ) const

inline

                                             {
    if (m_extractedDataAreDirty) extractData();
    return m_l;
  }

References Eigen::UmfPackLU< MatrixType_ >::extractData(), Eigen::UmfPackLU< MatrixType_ >::m_extractedDataAreDirty, and Eigen::UmfPackLU< MatrixType_ >::m_l.

matrixU()

template<typename MatrixType_ >

const LUMatrixType& Eigen::UmfPackLU< MatrixType_ >::matrixU ( ) const

inline

                                             {
    if (m_extractedDataAreDirty) extractData();
    return m_u;
  }

References Eigen::UmfPackLU< MatrixType_ >::extractData(), Eigen::UmfPackLU< MatrixType_ >::m_extractedDataAreDirty, and Eigen::UmfPackLU< MatrixType_ >::m_u.

permutationP()

template<typename MatrixType_ >

const IntColVectorType& Eigen::UmfPackLU< MatrixType_ >::permutationP ( ) const

inline

                                                      {
    if (m_extractedDataAreDirty) extractData();
    return m_p;
  }

References Eigen::UmfPackLU< MatrixType_ >::extractData(), Eigen::UmfPackLU< MatrixType_ >::m_extractedDataAreDirty, and Eigen::UmfPackLU< MatrixType_ >::m_p.

permutationQ()

template<typename MatrixType_ >

const IntRowVectorType& Eigen::UmfPackLU< MatrixType_ >::permutationQ ( ) const

inline

                                                      {
    if (m_extractedDataAreDirty) extractData();
    return m_q;
  }

References Eigen::UmfPackLU< MatrixType_ >::extractData(), Eigen::UmfPackLU< MatrixType_ >::m_extractedDataAreDirty, and Eigen::UmfPackLU< MatrixType_ >::m_q.

printUmfpackControl()

template<typename MatrixType_ >

void Eigen::UmfPackLU< MatrixType_ >::printUmfpackControl ( )

inline

Prints the current UmfPack control settings.

See also

umfpackControl()

{ umfpack_report_control(m_control.data(), Scalar(), StorageIndex()); }

References Eigen::PlainObjectBase< Derived >::data(), Eigen::UmfPackLU< MatrixType_ >::m_control, and Eigen::umfpack_report_control().

printUmfpackInfo()

template<typename MatrixType_ >

void Eigen::UmfPackLU< MatrixType_ >::printUmfpackInfo ( )

inline

Prints statistics collected by UmfPack.

See also

analyzePattern(), compute()

                          {
    eigen_assert(m_analysisIsOk && "UmfPackLU: you must first call analyzePattern()");
    umfpack_report_info(m_control.data(), m_umfpackInfo.data(), Scalar(), StorageIndex());
  }

References Eigen::PlainObjectBase< Derived >::data(), eigen_assert, Eigen::UmfPackLU< MatrixType_ >::m_analysisIsOk, Eigen::UmfPackLU< MatrixType_ >::m_control, Eigen::UmfPackLU< MatrixType_ >::m_umfpackInfo, and Eigen::umfpack_report_info().

printUmfpackStatus()

template<typename MatrixType_ >

void Eigen::UmfPackLU< MatrixType_ >::printUmfpackStatus ( )

inline

Prints the status of the previous factorization operation performed by UmfPack (symbolic or numerical factorization).

See also

analyzePattern(), compute()

                            {
    eigen_assert(m_analysisIsOk && "UmfPackLU: you must first call analyzePattern()");
    umfpack_report_status(m_control.data(), m_fact_errorCode, Scalar(), StorageIndex());
  }

References Eigen::PlainObjectBase< Derived >::data(), eigen_assert, Eigen::UmfPackLU< MatrixType_ >::m_analysisIsOk, Eigen::UmfPackLU< MatrixType_ >::m_control, Eigen::UmfPackLU< MatrixType_ >::m_fact_errorCode, and Eigen::umfpack_report_status().

rows()

template<typename MatrixType_ >

Index Eigen::UmfPackLU< MatrixType_ >::rows ( ) const

inline

{ return mp_matrix.rows(); }

References Eigen::UmfPackLU< MatrixType_ >::mp_matrix.

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

umfpackControl() [1/2]

template<typename MatrixType_ >

UmfpackControl& Eigen::UmfPackLU< MatrixType_ >::umfpackControl ( )

inline

Provides access to the control settings array used by UmfPack.

If this array contains NaN's, the default values are used.

See UMFPACK documentation for details.

{ return m_control; }

References Eigen::UmfPackLU< MatrixType_ >::m_control.

umfpackControl() [2/2]

template<typename MatrixType_ >

const UmfpackControl& Eigen::UmfPackLU< MatrixType_ >::umfpackControl ( ) const

inline

Provides access to the control settings array used by UmfPack.

If this array contains NaN's, the default values are used.

See UMFPACK documentation for details.

{ return m_control; }

References Eigen::UmfPackLU< MatrixType_ >::m_control.

umfpackFactorizeReturncode()

template<typename MatrixType_ >

int Eigen::UmfPackLU< MatrixType_ >::umfpackFactorizeReturncode ( ) const

inline

Provides the return status code returned by UmfPack during the numeric factorization.

See also

factorize(), compute()

                                                {
    eigen_assert(m_numeric && "UmfPackLU: you must first call factorize()");
    return m_fact_errorCode;
  }

References eigen_assert, Eigen::UmfPackLU< MatrixType_ >::m_fact_errorCode, and Eigen::UmfPackLU< MatrixType_ >::m_numeric.

Member Data Documentation

m_analysisIsOk

template<typename MatrixType_ >

int Eigen::UmfPackLU< MatrixType_ >::m_analysisIsOk

protected

Referenced by Eigen::UmfPackLU< MatrixType_ >::analyzePattern_impl(), Eigen::UmfPackLU< MatrixType_ >::factorize(), Eigen::UmfPackLU< MatrixType_ >::printUmfpackInfo(), and Eigen::UmfPackLU< MatrixType_ >::printUmfpackStatus().

m_control

template<typename MatrixType_ >

UmfpackControl Eigen::UmfPackLU< MatrixType_ >::m_control

protected

Referenced by Eigen::UmfPackLU< MatrixType_ >::analyzePattern_impl(), Eigen::UmfPackLU< MatrixType_ >::factorize_impl(), Eigen::UmfPackLU< MatrixType_ >::init(), Eigen::UmfPackLU< MatrixType_ >::printUmfpackControl(), Eigen::UmfPackLU< MatrixType_ >::printUmfpackInfo(), Eigen::UmfPackLU< MatrixType_ >::printUmfpackStatus(), and Eigen::UmfPackLU< MatrixType_ >::umfpackControl().

m_dummy

template<typename MatrixType_ >

UmfpackMatrixType Eigen::UmfPackLU< MatrixType_ >::m_dummy

protected

m_extractedDataAreDirty

template<typename MatrixType_ >

bool Eigen::UmfPackLU< MatrixType_ >::m_extractedDataAreDirty

mutableprotected

Referenced by Eigen::UmfPackLU< MatrixType_ >::analyzePattern_impl(), Eigen::UmfPackLU< MatrixType_ >::factorize_impl(), Eigen::UmfPackLU< MatrixType_ >::init(), Eigen::UmfPackLU< MatrixType_ >::matrixL(), Eigen::UmfPackLU< MatrixType_ >::matrixU(), Eigen::UmfPackLU< MatrixType_ >::permutationP(), and Eigen::UmfPackLU< MatrixType_ >::permutationQ().

m_fact_errorCode

template<typename MatrixType_ >

StorageIndex Eigen::UmfPackLU< MatrixType_ >::m_fact_errorCode

protected

Referenced by Eigen::UmfPackLU< MatrixType_ >::analyzePattern_impl(), Eigen::UmfPackLU< MatrixType_ >::factorize_impl(), Eigen::UmfPackLU< MatrixType_ >::printUmfpackStatus(), and Eigen::UmfPackLU< MatrixType_ >::umfpackFactorizeReturncode().

m_factorizationIsOk

template<typename MatrixType_ >

int Eigen::UmfPackLU< MatrixType_ >::m_factorizationIsOk

protected

Referenced by Eigen::UmfPackLU< MatrixType_ >::analyzePattern_impl(), and Eigen::UmfPackLU< MatrixType_ >::factorize_impl().

m_info

template<typename MatrixType_ >

ComputationInfo Eigen::UmfPackLU< MatrixType_ >::m_info

mutableprotected

Referenced by Eigen::UmfPackLU< MatrixType_ >::analyzePattern_impl(), Eigen::UmfPackLU< MatrixType_ >::factorize_impl(), Eigen::UmfPackLU< MatrixType_ >::info(), and Eigen::UmfPackLU< MatrixType_ >::init().

m_l

template<typename MatrixType_ >

LUMatrixType Eigen::UmfPackLU< MatrixType_ >::m_l

mutableprotected

Referenced by Eigen::UmfPackLU< MatrixType_ >::matrixL().

m_numeric

template<typename MatrixType_ >

void* Eigen::UmfPackLU< MatrixType_ >::m_numeric

protected

Referenced by Eigen::UmfPackLU< MatrixType_ >::analyzePattern(), Eigen::UmfPackLU< MatrixType_ >::compute(), Eigen::UmfPackLU< MatrixType_ >::factorize(), Eigen::UmfPackLU< MatrixType_ >::factorize_impl(), Eigen::UmfPackLU< MatrixType_ >::init(), Eigen::UmfPackLU< MatrixType_ >::umfpackFactorizeReturncode(), and Eigen::UmfPackLU< MatrixType_ >::~UmfPackLU().

m_p

template<typename MatrixType_ >

IntColVectorType Eigen::UmfPackLU< MatrixType_ >::m_p

mutableprotected

Referenced by Eigen::UmfPackLU< MatrixType_ >::permutationP().

m_q

template<typename MatrixType_ >

IntRowVectorType Eigen::UmfPackLU< MatrixType_ >::m_q

mutableprotected

Referenced by Eigen::UmfPackLU< MatrixType_ >::permutationQ().

m_symbolic

template<typename MatrixType_ >

void* Eigen::UmfPackLU< MatrixType_ >::m_symbolic

protected

Referenced by Eigen::UmfPackLU< MatrixType_ >::analyzePattern(), Eigen::UmfPackLU< MatrixType_ >::analyzePattern_impl(), Eigen::UmfPackLU< MatrixType_ >::compute(), Eigen::UmfPackLU< MatrixType_ >::factorize_impl(), Eigen::UmfPackLU< MatrixType_ >::init(), and Eigen::UmfPackLU< MatrixType_ >::~UmfPackLU().

m_u

template<typename MatrixType_ >

LUMatrixType Eigen::UmfPackLU< MatrixType_ >::m_u

mutableprotected

Referenced by Eigen::UmfPackLU< MatrixType_ >::matrixU().

m_umfpackInfo

template<typename MatrixType_ >

UmfpackInfo Eigen::UmfPackLU< MatrixType_ >::m_umfpackInfo

mutableprotected

Referenced by Eigen::UmfPackLU< MatrixType_ >::analyzePattern_impl(), Eigen::UmfPackLU< MatrixType_ >::factorize_impl(), and Eigen::UmfPackLU< MatrixType_ >::printUmfpackInfo().

mp_matrix

template<typename MatrixType_ >

UmfpackMatrixRef Eigen::UmfPackLU< MatrixType_ >::mp_matrix

protected

Referenced by Eigen::UmfPackLU< MatrixType_ >::analyzePattern_impl(), Eigen::UmfPackLU< MatrixType_ >::cols(), Eigen::UmfPackLU< MatrixType_ >::factorize_impl(), Eigen::UmfPackLU< MatrixType_ >::grab(), and Eigen::UmfPackLU< MatrixType_ >::rows().

---

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

• UmfPackSupport.h