Eigen::SuperLU< MatrixType_ > Class Template Reference

A sparse direct LU factorization and solver based on the SuperLU library. More...

#include <SuperLUSupport.h>

Inheritance diagram for Eigen::SuperLU< MatrixType_ >:

Public Types
typedef SuperLUBase< MatrixType_, SuperLU >	Base
typedef MatrixType_	MatrixType
typedef Base::Scalar	Scalar
typedef Base::RealScalar	RealScalar
typedef Base::StorageIndex	StorageIndex
typedef Base::IntRowVectorType	IntRowVectorType
typedef Base::IntColVectorType	IntColVectorType
typedef Base::PermutationMap	PermutationMap
typedef Base::LUMatrixType	LUMatrixType
typedef TriangularView< LUMatrixType, Lower|UnitDiag >	LMatrixType
typedef TriangularView< LUMatrixType, Upper >	UMatrixType
Public Types inherited from Eigen::SuperLUBase< MatrixType_, SuperLU< MatrixType_ > >
enum
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 Map< PermutationMatrix< Dynamic, Dynamic, int > >	PermutationMap
typedef SparseMatrix< Scalar >	LUMatrixType

Public Member Functions
	SuperLU ()
	SuperLU (const MatrixType &matrix)
	~SuperLU ()
void	analyzePattern (const MatrixType &matrix)
void	factorize (const MatrixType &matrix)
template<typename Rhs , typename Dest >
void	_solve_impl (const MatrixBase< Rhs > &b, MatrixBase< Dest > &dest) const
const LMatrixType &	matrixL () const
const UMatrixType &	matrixU () const
const IntColVectorType &	permutationP () const
const IntRowVectorType &	permutationQ () const
Scalar	determinant () const
Public Member Functions inherited from Eigen::SuperLUBase< MatrixType_, SuperLU< MatrixType_ > >
	SuperLUBase ()
	~SuperLUBase ()
Index	rows () const
Index	cols () const
superlu_options_t &	options ()
ComputationInfo	info () const
	Reports whether previous computation was successful. More...
void	compute (const MatrixType &matrix)
void	analyzePattern (const MatrixType &)
void	dumpMemory (Stream &)
Public Member Functions inherited from Eigen::SparseSolverBase< Derived >
	SparseSolverBase ()
	SparseSolverBase (SparseSolverBase &&other)
	~SparseSolverBase ()
Derived &	derived ()
const Derived &	derived () 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
template<typename Rhs , typename Dest >
void	_solve_impl (const SparseMatrixBase< Rhs > &b, SparseMatrixBase< Dest > &dest) const

Protected Member Functions
void	init ()
Protected Member Functions inherited from Eigen::SuperLUBase< MatrixType_, SuperLU< MatrixType_ > >
void	initFactorization (const MatrixType &a)
void	init ()
void	extractData () const
void	clearFactors ()
SuperLU< MatrixType_ > &	derived ()
const SuperLU< MatrixType_ > &	derived () const

Protected Attributes
LUMatrixType	m_l
LUMatrixType	m_matrix
IntColVectorType	m_p
IntRowVectorType	m_q
SluMatrix	m_sluA
SluMatrix	m_sluB
Matrix< RealScalar, Dynamic, 1 >	m_sluBerr
Matrix< RealScalar, Dynamic, 1 >	m_sluCscale
char	m_sluEqued
std::vector< int >	m_sluEtree
Matrix< RealScalar, Dynamic, 1 >	m_sluFerr
SuperMatrix	m_sluL
superlu_options_t	m_sluOptions
Matrix< RealScalar, Dynamic, 1 >	m_sluRscale
SuperLUStat_t	m_sluStat
SuperMatrix	m_sluU
SluMatrix	m_sluX
LUMatrixType	m_u
int	m_analysisIsOk
bool	m_extractedDataAreDirty
int	m_factorizationIsOk
ComputationInfo	m_info
bool	m_isInitialized
Protected Attributes inherited from Eigen::SuperLUBase< MatrixType_, SuperLU< MatrixType_ > >
LUMatrixType	m_l
LUMatrixType	m_u
IntColVectorType	m_p
IntRowVectorType	m_q
LUMatrixType	m_matrix
SluMatrix	m_sluA
SuperMatrix	m_sluL
SuperMatrix	m_sluU
SluMatrix	m_sluB
SluMatrix	m_sluX
SuperLUStat_t	m_sluStat
superlu_options_t	m_sluOptions
std::vector< int >	m_sluEtree
Matrix< RealScalar, Dynamic, 1 >	m_sluRscale
Matrix< RealScalar, Dynamic, 1 >	m_sluCscale
Matrix< RealScalar, Dynamic, 1 >	m_sluFerr
Matrix< RealScalar, Dynamic, 1 >	m_sluBerr
char	m_sluEqued
ComputationInfo	m_info
int	m_factorizationIsOk
int	m_analysisIsOk
bool	m_extractedDataAreDirty
bool	m_isInitialized
Protected Attributes inherited from Eigen::SparseSolverBase< Derived >
bool	m_isInitialized

Private Member Functions
	SuperLU (SuperLU &)

Additional Inherited Members
Protected Types inherited from Eigen::SuperLUBase< MatrixType_, SuperLU< MatrixType_ > >
typedef SparseSolverBase< SuperLU< MatrixType_ > >	Base

Detailed Description

template<typename MatrixType_>
class Eigen::SuperLU< MatrixType_ >

A sparse direct LU factorization and solver based on the SuperLU library.

This class allows to solve for A.X = B sparse linear problems via a direct LU factorization using the SuperLU library. The sparse matrix A must be squared and invertible. 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<>

Warning

This class is only for the 4.x versions of SuperLU. The 3.x and 5.x versions are not supported.

\implsparsesolverconcept

See also

Sparse solver concept, class SparseLU

Member Typedef Documentation

Base

template<typename MatrixType_ >

typedef SuperLUBase<MatrixType_, SuperLU> Eigen::SuperLU< MatrixType_ >::Base

IntColVectorType

template<typename MatrixType_ >

typedef Base::IntColVectorType Eigen::SuperLU< MatrixType_ >::IntColVectorType

IntRowVectorType

template<typename MatrixType_ >

typedef Base::IntRowVectorType Eigen::SuperLU< MatrixType_ >::IntRowVectorType

LMatrixType

template<typename MatrixType_ >

typedef TriangularView<LUMatrixType, Lower | UnitDiag> Eigen::SuperLU< MatrixType_ >::LMatrixType

LUMatrixType

template<typename MatrixType_ >

typedef Base::LUMatrixType Eigen::SuperLU< MatrixType_ >::LUMatrixType

MatrixType

template<typename MatrixType_ >

typedef MatrixType_ Eigen::SuperLU< MatrixType_ >::MatrixType

PermutationMap

template<typename MatrixType_ >

typedef Base::PermutationMap Eigen::SuperLU< MatrixType_ >::PermutationMap

RealScalar

template<typename MatrixType_ >

typedef Base::RealScalar Eigen::SuperLU< MatrixType_ >::RealScalar

Scalar

template<typename MatrixType_ >

typedef Base::Scalar Eigen::SuperLU< MatrixType_ >::Scalar

StorageIndex

template<typename MatrixType_ >

typedef Base::StorageIndex Eigen::SuperLU< MatrixType_ >::StorageIndex

UMatrixType

template<typename MatrixType_ >

typedef TriangularView<LUMatrixType, Upper> Eigen::SuperLU< MatrixType_ >::UMatrixType

Constructor & Destructor Documentation

SuperLU() [1/3]

template<typename MatrixType_ >

Eigen::SuperLU< MatrixType_ >::SuperLU ( )

inline

: Base() { init(); }

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

SuperLU() [2/3]

template<typename MatrixType_ >

Eigen::SuperLU< MatrixType_ >::SuperLU ( const MatrixType &  matrix )

inlineexplicit

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

References Eigen::SuperLUBase< MatrixType_, Derived >::compute(), Eigen::SuperLU< MatrixType_ >::init(), and matrix().

~SuperLU()

template<typename MatrixType_ >

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

inline

{}

SuperLU() [3/3]

template<typename MatrixType_ >

Eigen::SuperLU< MatrixType_ >::SuperLU ( SuperLU< MatrixType_ > &  )

inlineprivate

{}

Member Function Documentation

_solve_impl()

template<typename MatrixType >

template<typename Rhs , typename Dest >

void Eigen::SuperLU< MatrixType >::_solve_impl	(	const MatrixBase< Rhs > &	b,
		MatrixBase< Dest > &	dest
	)		const

                                                                                         {
  eigen_assert(m_factorizationIsOk &&
               "The decomposition is not in a valid state for solving, you must first call either compute() or "
               "analyzePattern()/factorize()");
 
  const Index rhsCols = b.cols();
  eigen_assert(m_matrix.rows() == b.rows());
 
  m_sluOptions.Trans = NOTRANS;
  m_sluOptions.Fact = FACTORED;
  m_sluOptions.IterRefine = NOREFINE;
 
  m_sluFerr.resize(rhsCols);
  m_sluBerr.resize(rhsCols);
 
  Ref<const Matrix<typename Rhs::Scalar, Dynamic, Dynamic, ColMajor> > b_ref(b);
  Ref<const Matrix<typename Dest::Scalar, Dynamic, Dynamic, ColMajor> > x_ref(x);
 
  m_sluB = SluMatrix::Map(b_ref.const_cast_derived());
  m_sluX = SluMatrix::Map(x_ref.const_cast_derived());
 
  typename Rhs::PlainObject b_cpy;
  if (m_sluEqued != 'N') {
    b_cpy = b;
    m_sluB = SluMatrix::Map(b_cpy.const_cast_derived());
  }
 
  StatInit(&m_sluStat);
  int info = 0;
  RealScalar recip_pivot_growth, rcond;
  SuperLU_gssvx(&m_sluOptions, &m_sluA, m_q.data(), m_p.data(), &m_sluEtree[0], &m_sluEqued, &m_sluRscale[0],
                &m_sluCscale[0], &m_sluL, &m_sluU, NULL, 0, &m_sluB, &m_sluX, &recip_pivot_growth, &rcond,
                &m_sluFerr[0], &m_sluBerr[0], &m_sluStat, &info, Scalar());
  StatFree(&m_sluStat);
 
  if (x.derived().data() != x_ref.data()) x = x_ref;
 
  m_info = info == 0 ? Success : NumericalIssue;
}

References b, eigen_assert, FACTORED, info, Eigen::SluMatrix::Map(), NOREFINE, NOTRANS, Eigen::NumericalIssue, StatFree(), StatInit(), Eigen::Success, and plotDoE::x.

analyzePattern()

template<typename MatrixType_ >

void Eigen::SuperLU< 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()

                                                {
    m_info = InvalidInput;
    m_isInitialized = false;
    Base::analyzePattern(matrix);
  }

References Eigen::SuperLUBase< MatrixType_, Derived >::analyzePattern(), Eigen::InvalidInput, Eigen::SuperLU< MatrixType_ >::m_info, Eigen::SuperLU< MatrixType_ >::m_isInitialized, and matrix().

determinant()

template<typename MatrixType >

SuperLU< MatrixType >::Scalar Eigen::SuperLU< MatrixType >::determinant

                                                                          {
  eigen_assert(m_factorizationIsOk &&
               "The decomposition is not in a valid state for computing the determinant, you must first call either "
               "compute() or analyzePattern()/factorize()");
 
  if (m_extractedDataAreDirty) this->extractData();
 
  Scalar det = Scalar(1);
  for (int j = 0; j < m_u.cols(); ++j) {
    if (m_u.outerIndexPtr()[j + 1] - m_u.outerIndexPtr()[j] > 0) {
      int lastId = m_u.outerIndexPtr()[j + 1] - 1;
      eigen_assert(m_u.innerIndexPtr()[lastId] <= j);
      if (m_u.innerIndexPtr()[lastId] == j) det *= m_u.valuePtr()[lastId];
    }
  }
  if (PermutationMap(m_p.data(), m_p.size()).determinant() * PermutationMap(m_q.data(), m_q.size()).determinant() < 0)
    det = -det;
  if (m_sluEqued != 'N')
    return det / m_sluRscale.prod() / m_sluCscale.prod();
  else
    return det;
}

References eigen_assert, and j.

factorize()

template<typename MatrixType >

void Eigen::SuperLU< MatrixType >::factorize

(

const MatrixType &

matrix

)

Performs a numeric decomposition of matrix

The given matrix must has the same sparcity than the matrix on which the symbolic decomposition has been performed.

See also

analyzePattern()

                                                       {
  eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
  if (!m_analysisIsOk) {
    m_info = InvalidInput;
    return;
  }
 
  this->initFactorization(a);
 
  m_sluOptions.ColPerm = COLAMD;
  int info = 0;
  RealScalar recip_pivot_growth, rcond;
  RealScalar ferr, berr;
 
  StatInit(&m_sluStat);
  SuperLU_gssvx(&m_sluOptions, &m_sluA, m_q.data(), m_p.data(), &m_sluEtree[0], &m_sluEqued, &m_sluRscale[0],
                &m_sluCscale[0], &m_sluL, &m_sluU, NULL, 0, &m_sluB, &m_sluX, &recip_pivot_growth, &rcond, &ferr, &berr,
                &m_sluStat, &info, Scalar());
  StatFree(&m_sluStat);
 
  m_extractedDataAreDirty = true;
 
  // FIXME how to better check for errors ???
  m_info = info == 0 ? Success : NumericalIssue;
  m_factorizationIsOk = true;
}

References a, COLAMD, eigen_assert, info, Eigen::InvalidInput, Eigen::NumericalIssue, StatFree(), StatInit(), and Eigen::Success.

init()

template<typename MatrixType_ >

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

inlineprotected

              {
    Base::init();
 
    set_default_options(&this->m_sluOptions);
    m_sluOptions.PrintStat = NO;
    m_sluOptions.ConditionNumber = NO;
    m_sluOptions.Trans = NOTRANS;
    m_sluOptions.ColPerm = COLAMD;
  }

References COLAMD, superlu_options_t::ColPerm, superlu_options_t::ConditionNumber, Eigen::SuperLUBase< MatrixType_, Derived >::init(), Eigen::SuperLU< MatrixType_ >::m_sluOptions, NO, NOTRANS, superlu_options_t::PrintStat, set_default_options(), and superlu_options_t::Trans.

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

matrixL()

template<typename MatrixType_ >

const LMatrixType& Eigen::SuperLU< MatrixType_ >::matrixL ( ) const

inline

                                            {
    if (m_extractedDataAreDirty) this->extractData();
    return m_l;
  }

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

matrixU()

template<typename MatrixType_ >

const UMatrixType& Eigen::SuperLU< MatrixType_ >::matrixU ( ) const

inline

                                            {
    if (m_extractedDataAreDirty) this->extractData();
    return m_u;
  }

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

permutationP()

template<typename MatrixType_ >

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

inline

                                                      {
    if (m_extractedDataAreDirty) this->extractData();
    return m_p;
  }

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

permutationQ()

template<typename MatrixType_ >

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

inline

                                                      {
    if (m_extractedDataAreDirty) this->extractData();
    return m_q;
  }

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

Member Data Documentation

m_analysisIsOk

template<typename MatrixType_ >

int Eigen::SuperLUBase< MatrixType_, Derived >::m_analysisIsOk

protected

m_extractedDataAreDirty

template<typename MatrixType_ >

bool Eigen::SuperLUBase< MatrixType_, Derived >::m_extractedDataAreDirty

mutableprotected

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

m_factorizationIsOk

template<typename MatrixType_ >

int Eigen::SuperLUBase< MatrixType_, Derived >::m_factorizationIsOk

protected

m_info

template<typename MatrixType_ >

ComputationInfo Eigen::SuperLUBase< MatrixType_, Derived >::m_info

mutableprotected

Referenced by Eigen::SuperLU< MatrixType_ >::analyzePattern().

m_isInitialized

template<typename MatrixType_ >

bool Eigen::SparseSolverBase< Derived >::m_isInitialized

mutableprotected

Referenced by Eigen::SuperLU< MatrixType_ >::analyzePattern().

m_l

template<typename MatrixType_ >

LUMatrixType Eigen::SuperLUBase< MatrixType_, Derived >::m_l

mutableprotected

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

m_matrix

template<typename MatrixType_ >

LUMatrixType Eigen::SuperLUBase< MatrixType_, Derived >::m_matrix

mutableprotected

m_p

template<typename MatrixType_ >

IntColVectorType Eigen::SuperLUBase< MatrixType_, Derived >::m_p

mutableprotected

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

m_q

template<typename MatrixType_ >

IntRowVectorType Eigen::SuperLUBase< MatrixType_, Derived >::m_q

mutableprotected

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

m_sluA

template<typename MatrixType_ >

SluMatrix Eigen::SuperLUBase< MatrixType_, Derived >::m_sluA

mutableprotected

m_sluB

template<typename MatrixType_ >

SluMatrix Eigen::SuperLUBase< MatrixType_, Derived >::m_sluB

mutableprotected

m_sluBerr

template<typename MatrixType_ >

Matrix<RealScalar, Dynamic, 1> Eigen::SuperLUBase< MatrixType_, Derived >::m_sluBerr

protected

m_sluCscale

template<typename MatrixType_ >

Matrix<RealScalar, Dynamic, 1> Eigen::SuperLUBase< MatrixType_, Derived >::m_sluCscale

protected

m_sluEqued

template<typename MatrixType_ >

char Eigen::SuperLUBase< MatrixType_, Derived >::m_sluEqued

mutableprotected

m_sluEtree

template<typename MatrixType_ >

std::vector<int> Eigen::SuperLUBase< MatrixType_, Derived >::m_sluEtree

mutableprotected

m_sluFerr

template<typename MatrixType_ >

Matrix<RealScalar, Dynamic, 1> Eigen::SuperLUBase< MatrixType_, Derived >::m_sluFerr

mutableprotected

m_sluL

template<typename MatrixType_ >

SuperMatrix Eigen::SuperLUBase< MatrixType_, Derived >::m_sluL

mutableprotected

m_sluOptions

template<typename MatrixType_ >

superlu_options_t Eigen::SuperLUBase< MatrixType_, Derived >::m_sluOptions

mutableprotected

Referenced by Eigen::SuperLU< MatrixType_ >::init().

m_sluRscale

template<typename MatrixType_ >

Matrix<RealScalar, Dynamic, 1> Eigen::SuperLUBase< MatrixType_, Derived >::m_sluRscale

mutableprotected

m_sluStat

template<typename MatrixType_ >

SuperLUStat_t Eigen::SuperLUBase< MatrixType_, Derived >::m_sluStat

mutableprotected

m_sluU

template<typename MatrixType_ >

SuperMatrix Eigen::SuperLUBase< MatrixType_, Derived >::m_sluU

protected

m_sluX

template<typename MatrixType_ >

SluMatrix Eigen::SuperLUBase< MatrixType_, Derived >::m_sluX

protected

m_u

template<typename MatrixType_ >

LUMatrixType Eigen::SuperLUBase< MatrixType_, Derived >::m_u

mutableprotected

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

---

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

• SuperLUSupport.h