Incomplete LU factorization with dual-threshold strategy. More...

#include <IncompleteLUT.h>

Inheritance diagram for Eigen::IncompleteLUT< _Scalar, _StorageIndex >:

Data Structures
struct	keep_diag
	keeps off-diagonal entries; drops diagonal entries More...

Public Types
enum	{ ColsAtCompileTime = Dynamic , MaxColsAtCompileTime = Dynamic }

typedef _Scalar	Scalar

typedef _StorageIndex	StorageIndex

typedef NumTraits< Scalar >::Real	RealScalar

typedef Matrix< Scalar, Dynamic, 1 >	Vector

typedef Matrix< StorageIndex, Dynamic, 1 >	VectorI

typedef SparseMatrix< Scalar, RowMajor, StorageIndex >	FactorType

Public Member Functions
template<typename MatrixType >
	IncompleteLUT (const MatrixType &mat, const RealScalar &droptol=NumTraits< Scalar >::dummy_precision(), int fillfactor=10)

Index	rows () const

Index	cols () const

ComputationInfo	info () const
	Reports whether previous computation was successful.

template<typename MatrixType >
void	analyzePattern (const MatrixType &amat)

template<typename MatrixType >
void	factorize (const MatrixType &amat)

template<typename MatrixType >
IncompleteLUT &	compute (const MatrixType &amat)
	Compute an incomplete LU factorization with dual threshold on the matrix mat No pivoting is done in this version.

void	setDroptol (const RealScalar &droptol)
	Set control parameter droptol.

void	setFillfactor (int fillfactor)
	Set control parameter fillfactor.

template<typename Rhs , typename Dest >
void	_solve_impl (const Rhs &b, Dest &x) const

template<typename _MatrixType >
void	analyzePattern (const _MatrixType &amat)

template<typename _MatrixType >
void	factorize (const _MatrixType &amat)

Public Member Functions inherited from Eigen::SparseSolverBase< Derived >
	SparseSolverBase ()
	Default constructor.

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 Types
typedef SparseSolverBase< IncompleteLUT >	Base

Protected Attributes
FactorType	m_lu

RealScalar	m_droptol

int	m_fillfactor

bool	m_analysisIsOk

bool	m_factorizationIsOk

ComputationInfo	m_info

PermutationMatrix< Dynamic, Dynamic, StorageIndex >	m_P

PermutationMatrix< Dynamic, Dynamic, StorageIndex >	m_Pinv

bool	m_isInitialized

Protected Attributes inherited from Eigen::SparseSolverBase< Derived >
bool	m_isInitialized

Detailed Description

template<typename _Scalar, typename _StorageIndex = int>
class Eigen::IncompleteLUT< _Scalar, _StorageIndex >

Incomplete LU factorization with dual-threshold strategy.

\implsparsesolverconcept

During the numerical factorization, two dropping rules are used : 1) any element whose magnitude is less than some tolerance is dropped. This tolerance is obtained by multiplying the input tolerance droptol by the average magnitude of all the original elements in the current row. 2) After the elimination of the row, only the fill largest elements in the L part and the fill largest elements in the U part are kept (in addition to the diagonal element ). Note that fill is computed from the input parameter fillfactor which is used the ratio to control the fill_in relatively to the initial number of nonzero elements.

The two extreme cases are when droptol=0 (to keep all the fill*2 largest elements) and when fill=n/2 with droptol being different to zero.

References : Yousef Saad, ILUT: A dual threshold incomplete LU factorization, Numerical Linear Algebra with Applications, 1(4), pp 387-402, 1994.

NOTE : The following implementation is derived from the ILUT implementation in the SPARSKIT package, Copyright (C) 2005, the Regents of the University of Minnesota released under the terms of the GNU LGPL: http://www-users.cs.umn.edu/~saad/software/SPARSKIT/README However, Yousef Saad gave us permission to relicense his ILUT code to MPL2. See the Eigen mailing list archive, thread: ILUT, date: July 8, 2012: http://listengine.tuxfamily.org/lists.tuxfamily.org/eigen/2012/07/msg00064.html alternatively, on GMANE: http://comments.gmane.org/gmane.comp.lib.eigen/3302

Member Function Documentation

◆ info()

template<typename _Scalar , typename _StorageIndex = int>

ComputationInfo Eigen::IncompleteLUT< _Scalar, _StorageIndex >::info ( ) const

inline

Reports whether previous computation was successful.

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

◆ setDroptol()

template<typename Scalar , typename StorageIndex >

void Eigen::IncompleteLUT< Scalar, StorageIndex >::setDroptol ( const RealScalar & droptol )

Set control parameter droptol.

Parameters

droptol Drop any element whose magnitude is less than this tolerance

◆ setFillfactor()

template<typename Scalar , typename StorageIndex >

void Eigen::IncompleteLUT< Scalar, StorageIndex >::setFillfactor ( int fillfactor )

Set control parameter fillfactor.

Parameters

fillfactor This is used to compute the number fill_in of largest elements to keep on each row.

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

External/Eigen/src/IterativeLinearSolvers/IncompleteLUT.h

Data Structures

Public Types

Public Member Functions

Protected Types

Protected Attributes

Detailed Description

Member Function Documentation

◆ info()

◆ setDroptol()

◆ setFillfactor()