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

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

Inheritance diagram for Eigen::UmfPackLU< _MatrixType >:

Collaboration 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, int >	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.

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

void	umfpackReportInfo ()

void	umfpackReportStatus ()

template<typename BDerived , typename XDerived >
bool	_solve_impl (const MatrixBase< BDerived > &b, MatrixBase< XDerived > &x) const

Scalar	determinant () const

void	extractData () const

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

int	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

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: TutorialSparseSolverConcept, 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,int> 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().

Here is the call graph for this function:

◆ 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(), and Eigen::UmfPackLU< _MatrixType >::init().

Here is the call graph for this function:

◆ ~UmfPackLU()

template<typename _MatrixType >

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

inline

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

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

Here is the call graph for this function:

◆ UmfPackLU() [3/3]

template<typename _MatrixType >

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

inlineprivate

431{ }

Member Function Documentation

◆ _solve_impl() [1/2]

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");
 
  int errorCode;
  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);
    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 Eigen::PlainObjectBase< Derived >::data(), eigen_assert, Eigen::PlainObjectBase< Derived >::resize(), Eigen::RowMajorBit, and Eigen::umfpack_solve().

Here is the call graph for this function:

◆ _solve_impl() [2/2]

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

inlineinherited

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

◆ 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());
      if(m_numeric)  umfpack_free_numeric(&m_numeric,Scalar());
 
      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, Eigen::umfpack_free_numeric(), and Eigen::umfpack_free_symbolic().

Here is the call graph for this function:

◆ analyzePattern_impl()

template<typename _MatrixType >

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

inlineprotected

    {
      m_fact_errorCode = umfpack_symbolic(internal::convert_index<int>(mp_matrix.rows()),
                                          internal::convert_index<int>(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;
    }

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cols()

template<typename _MatrixType >

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

inline

200{ return mp_matrix.cols(); }

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

◆ 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());
      if(m_numeric)  umfpack_free_numeric(&m_numeric,Scalar());
      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, Eigen::umfpack_free_numeric(), and Eigen::umfpack_free_symbolic().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ derived() [1/2]

UmfPackLU< _MatrixType > & Eigen::SparseSolverBase< UmfPackLU< _MatrixType > >::derived ( )

inlineinherited

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

◆ derived() [2/2]

const UmfPackLU< _MatrixType > & Eigen::SparseSolverBase< UmfPackLU< _MatrixType > >::derived ( ) const

inlineinherited

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

◆ determinant()

template<typename MatrixType >

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

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

References Eigen::umfpack_get_determinant().

Here is the call graph for this function:

◆ extractData()

template<typename MatrixType >

void Eigen::UmfPackLU< MatrixType >::extractData

{
  if (m_extractedDataAreDirty)
  {
    // get size of the data
    int 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 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().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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());
 
      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, and Eigen::umfpack_free_numeric().

Here is the call graph for this function:

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ grab() [1/2]

template<typename _MatrixType >

template<typename MatrixDerived >

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

inlineprotected

    {
      mp_matrix.~UmfpackMatrixRef();
      ::new (&mp_matrix) UmfpackMatrixRef(A.derived());
    }

References Eigen::EigenBase< Derived >::derived(), and Eigen::UmfPackLU< _MatrixType >::mp_matrix.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ grab() [2/2]

template<typename _MatrixType >

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

inlineprotected

    {
      if(&(A.derived()) != &mp_matrix)
      {
        mp_matrix.~UmfpackMatrixRef();
        ::new (&mp_matrix) UmfpackMatrixRef(A);
      }
    }

References 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 succesful, 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());
    }

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(), and Eigen::UmfPackLU< _MatrixType >::UmfPackLU().

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

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

Here is the call graph for this function:

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

Here is the call graph for this function:

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

Here is the call graph for this function:

◆ rows()

template<typename _MatrixType >

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

inline

199{ return mp_matrix.rows(); }

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

◆ solve() [1/2]

const Solve< UmfPackLU< _MatrixType > , Rhs > Eigen::SparseSolverBase< UmfPackLU< _MatrixType > >::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());
    }

◆ solve() [2/2]

const Solve< UmfPackLU< _MatrixType > , Rhs > Eigen::SparseSolverBase< UmfPackLU< _MatrixType > >::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());
    }

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

◆ umfpackReportControl()

template<typename _MatrixType >

void Eigen::UmfPackLU< _MatrixType >::umfpackReportControl ( )

inline

Prints the current UmfPack control settings.

See also: umfpackControl()

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

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

Here is the call graph for this function:

◆ umfpackReportInfo()

template<typename _MatrixType >

void Eigen::UmfPackLU< _MatrixType >::umfpackReportInfo ( )

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

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

Here is the call graph for this function:

◆ umfpackReportStatus()

template<typename _MatrixType >

void Eigen::UmfPackLU< _MatrixType >::umfpackReportStatus ( )

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

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

Here is the call graph for this function:

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 >::umfpackReportInfo(), and Eigen::UmfPackLU< _MatrixType >::umfpackReportStatus().

◆ 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 >::umfpackControl(), Eigen::UmfPackLU< _MatrixType >::umfpackControl(), Eigen::UmfPackLU< _MatrixType >::umfpackReportControl(), Eigen::UmfPackLU< _MatrixType >::umfpackReportInfo(), and Eigen::UmfPackLU< _MatrixType >::umfpackReportStatus().

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

int Eigen::UmfPackLU< _MatrixType >::m_fact_errorCode

protected

Referenced by Eigen::UmfPackLU< _MatrixType >::analyzePattern_impl(), Eigen::UmfPackLU< _MatrixType >::factorize_impl(), Eigen::UmfPackLU< _MatrixType >::umfpackFactorizeReturncode(), and Eigen::UmfPackLU< _MatrixType >::umfpackReportStatus().

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

bool Eigen::SparseSolverBase< UmfPackLU< _MatrixType > >::m_isInitialized

mutableprotectedinherited

◆ 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 >::~UmfPackLU(), Eigen::UmfPackLU< _MatrixType >::analyzePattern(), Eigen::UmfPackLU< _MatrixType >::compute(), Eigen::UmfPackLU< _MatrixType >::factorize(), Eigen::UmfPackLU< _MatrixType >::factorize_impl(), Eigen::UmfPackLU< _MatrixType >::init(), and Eigen::UmfPackLU< _MatrixType >::umfpackFactorizeReturncode().

◆ 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 >::~UmfPackLU(), Eigen::UmfPackLU< _MatrixType >::analyzePattern(), Eigen::UmfPackLU< _MatrixType >::analyzePattern_impl(), Eigen::UmfPackLU< _MatrixType >::compute(), Eigen::UmfPackLU< _MatrixType >::factorize_impl(), and Eigen::UmfPackLU< _MatrixType >::init().

◆ 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 >::umfpackReportInfo().

◆ 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(), Eigen::UmfPackLU< _MatrixType >::grab(), and Eigen::UmfPackLU< _MatrixType >::rows().

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

src/eigen/Eigen/src/UmfPackSupport/UmfPackSupport.h

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Member Typedef Documentation

◆ Base

◆ IntColVectorType

◆ IntRowVectorType

◆ LUMatrixType

◆ MatrixType

◆ RealScalar

◆ Scalar

◆ StorageIndex

◆ UmfpackControl

◆ UmfpackInfo

◆ UmfpackMatrixRef

◆ UmfpackMatrixType

◆ Vector

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ UmfPackLU() [1/3]

◆ UmfPackLU() [2/3]

◆ ~UmfPackLU()

◆ UmfPackLU() [3/3]

Member Function Documentation

◆ _solve_impl() [1/2]

◆ _solve_impl() [2/2]

◆ analyzePattern()

◆ analyzePattern_impl()

◆ cols()

◆ compute()

◆ derived() [1/2]

◆ derived() [2/2]

◆ determinant()

◆ extractData()

◆ factorize()

◆ factorize_impl()

◆ grab() [1/2]

◆ grab() [2/2]

◆ info()

◆ init()

◆ matrixL()

◆ matrixU()

◆ permutationP()

◆ permutationQ()

◆ rows()

◆ solve() [1/2]

◆ solve() [2/2]

◆ umfpackControl() [1/2]

◆ umfpackControl() [2/2]

◆ umfpackFactorizeReturncode()

◆ umfpackReportControl()

◆ umfpackReportInfo()

◆ umfpackReportStatus()

Member Data Documentation

◆ m_analysisIsOk

◆ m_control

◆ m_dummy

◆ m_extractedDataAreDirty

◆ m_fact_errorCode

◆ m_factorizationIsOk

◆ m_info

◆ m_isInitialized

◆ m_l

◆ m_numeric

◆ m_p

◆ m_q

◆ m_symbolic

◆ m_u

◆ m_umfpackInfo

◆ mp_matrix