Robust Cholesky decomposition of a matrix with pivoting. More...

#include <LDLT.h>

Public Types
enum	{ RowsAtCompileTime = MatrixType::RowsAtCompileTime , ColsAtCompileTime = MatrixType::ColsAtCompileTime , Options = MatrixType::Options & ~RowMajorBit , MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime , MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime , UpLo = _UpLo }

typedef _MatrixType	MatrixType

typedef MatrixType::Scalar	Scalar

typedef NumTraits< typenameMatrixType::Scalar >::Real	RealScalar

typedef Eigen::Index	Index

typedef MatrixType::StorageIndex	StorageIndex

typedef Matrix< Scalar, RowsAtCompileTime, 1, Options, MaxRowsAtCompileTime, 1 >	TmpMatrixType

typedef Transpositions< RowsAtCompileTime, MaxRowsAtCompileTime >	TranspositionType

typedef PermutationMatrix< RowsAtCompileTime, MaxRowsAtCompileTime >	PermutationType

typedef internal::LDLT_Traits< MatrixType, UpLo >	Traits

Public Member Functions
	LDLT ()
	Default Constructor.

	LDLT (Index size)
	Default Constructor with memory preallocation.

template<typename InputType >
	LDLT (const EigenBase< InputType > &matrix)
	Constructor with decomposition.

void	setZero ()
	Clear any existing decomposition.

Traits::MatrixU	matrixU () const

Traits::MatrixL	matrixL () const

const TranspositionType &	transpositionsP () const

Diagonal< const MatrixType >	vectorD () const

bool	isPositive () const

bool	isNegative (void) const

template<typename Rhs >
const Solve< LDLT, Rhs >	solve (const MatrixBase< Rhs > &b) const

template<typename Derived >
bool	solveInPlace (MatrixBase< Derived > &bAndX) const

template<typename InputType >
LDLT &	compute (const EigenBase< InputType > &matrix)

template<typename Derived >
LDLT &	rankUpdate (const MatrixBase< Derived > &w, const RealScalar &alpha=1)

const MatrixType &	matrixLDLT () const

MatrixType	reconstructedMatrix () const

Index	rows () const

Index	cols () const

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

template<typename RhsType , typename DstType >
EIGEN_DEVICE_FUNC void	_solve_impl (const RhsType &rhs, DstType &dst) const

template<typename InputType >
LDLT< MatrixType, _UpLo > &	compute (const EigenBase< InputType > &a)
	Compute / recompute the LDLT decomposition A = L D L^* = U^* D U of matrix.

template<typename Derived >
LDLT< MatrixType, _UpLo > &	rankUpdate (const MatrixBase< Derived > &w, const typename LDLT< MatrixType, _UpLo >::RealScalar &sigma)
	Update the LDLT decomposition: given A = L D L^T, efficiently compute the decomposition of A + sigma w w^T.

template<typename RhsType , typename DstType >
void	_solve_impl (const RhsType &rhs, DstType &dst) const

Static Protected Member Functions
static void	check_template_parameters ()

Protected Attributes
MatrixType	m_matrix

TranspositionType	m_transpositions

TmpMatrixType	m_temporary

internal::SignMatrix	m_sign

bool	m_isInitialized

Detailed Description

template<typename _MatrixType, int _UpLo>
class Eigen::LDLT< _MatrixType, _UpLo >

Robust Cholesky decomposition of a matrix with pivoting.

Parameters

MatrixType	the type of the matrix of which to compute the LDL^T Cholesky decomposition
UpLo	the triangular part that will be used for the decompositon: Lower (default) or Upper. The other triangular part won't be read.

Perform a robust Cholesky decomposition of a positive semidefinite or negative semidefinite matrix $ A $ such that $ A = P^TLDL^*P $ , where P is a permutation matrix, L is lower triangular with a unit diagonal and D is a diagonal matrix.

The decomposition uses pivoting to ensure stability, so that L will have zeros in the bottom right rank(A) - n submatrix. Avoiding the square root on D also stabilizes the computation.

Remember that Cholesky decompositions are not rank-revealing. Also, do not use a Cholesky decomposition to determine whether a system of equations has a solution.

See also: MatrixBase::ldlt(), SelfAdjointView::ldlt(), class LLT

Member Typedef Documentation

◆ Index

template<typename _MatrixType , int _UpLo>

typedef Eigen::Index Eigen::LDLT< _MatrixType, _UpLo >::Index

Deprecated:: since Eigen 3.3

Constructor & Destructor Documentation

◆ LDLT() [1/3]

template<typename _MatrixType , int _UpLo>

Eigen::LDLT< _MatrixType, _UpLo >::LDLT ( )

inline

Default Constructor.

The default constructor is useful in cases in which the user intends to perform decompositions via LDLT::compute(const MatrixType&).

◆ LDLT() [2/3]

template<typename _MatrixType , int _UpLo>

Eigen::LDLT< _MatrixType, _UpLo >::LDLT ( Index size )

inlineexplicit

Default Constructor with memory preallocation.

Like the default constructor but with preallocation of the internal data according to the specified problem size.

See also: LDLT()

◆ LDLT() [3/3]

template<typename _MatrixType , int _UpLo>

template<typename InputType >

Eigen::LDLT< _MatrixType, _UpLo >::LDLT ( const EigenBase< InputType > & matrix )

inlineexplicit

Constructor with decomposition.

This calculates the decomposition for the input matrix.

See also: LDLT(Index size)

Member Function Documentation

◆ info()

template<typename _MatrixType , int _UpLo>

ComputationInfo Eigen::LDLT< _MatrixType, _UpLo >::info ( ) const

inline

Reports whether previous computation was successful.

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

◆ isNegative()

template<typename _MatrixType , int _UpLo>

bool Eigen::LDLT< _MatrixType, _UpLo >::isNegative ( void ) const

inline

Returns: true if the matrix is negative (semidefinite)

◆ isPositive()

template<typename _MatrixType , int _UpLo>

bool Eigen::LDLT< _MatrixType, _UpLo >::isPositive ( ) const

inline

Returns: true if the matrix is positive (semidefinite)

◆ matrixL()

template<typename _MatrixType , int _UpLo>

Traits::MatrixL Eigen::LDLT< _MatrixType, _UpLo >::matrixL ( ) const

inline

Returns: a view of the lower triangular matrix L

◆ matrixLDLT()

template<typename _MatrixType , int _UpLo>

const MatrixType & Eigen::LDLT< _MatrixType, _UpLo >::matrixLDLT ( ) const

inline

Returns: the internal LDLT decomposition matrix

TODO: document the storage layout

◆ matrixU()

template<typename _MatrixType , int _UpLo>

Traits::MatrixU Eigen::LDLT< _MatrixType, _UpLo >::matrixU ( ) const

inline

Returns: a view of the upper triangular matrix U

◆ rankUpdate()

template<typename _MatrixType , int _UpLo>

template<typename Derived >

LDLT< MatrixType, _UpLo > & Eigen::LDLT< _MatrixType, _UpLo >::rankUpdate	(	const MatrixBase< Derived > &	w,
		const typename LDLT< MatrixType, _UpLo >::RealScalar &	sigma
	)

Update the LDLT decomposition: given A = L D L^T, efficiently compute the decomposition of A + sigma w w^T.

Parameters

w	a vector to be incorporated into the decomposition.
sigma	a scalar, +1 for updates and -1 for "downdates," which correspond to removing previously-added column vectors. Optional; default value is +1.

See also: setZero()

◆ reconstructedMatrix()

template<typename MatrixType , int _UpLo>

MatrixType Eigen::LDLT< MatrixType, _UpLo >::reconstructedMatrix ( ) const

Returns: the matrix represented by the decomposition, i.e., it returns the product: P^T L D L^* P. This function is provided for debug purpose.

◆ setZero()

template<typename _MatrixType , int _UpLo>

void Eigen::LDLT< _MatrixType, _UpLo >::setZero ( )

inline

Clear any existing decomposition.

See also: rankUpdate(w,sigma)

◆ solve()

template<typename _MatrixType , int _UpLo>

template<typename Rhs >

const Solve< LDLT, Rhs > Eigen::LDLT< _MatrixType, _UpLo >::solve ( const MatrixBase< Rhs > & b ) const

inline

Returns: a solution x of using the current decomposition of A.

This function also supports in-place solves using the syntax x = decompositionObject.solve(x) .

\note_about_checking_solutions

More precisely, this method solves $ A x = b $ using the decomposition $ A = P^T L D L^* P $ by solving the systems $ P^T y_1 = b $ , $ L y_2 = y_1 $ , $ D y_3 = y_2 $ , $ L^* y_4 = y_3 $ and $ P x = y_4 $ in succession. If the matrix $ A $ is singular, then $ D $ will also be singular (all the other matrices are invertible). In that case, the least-square solution of is computed. This does not mean that this function computes the least-square solution of $ A x = b $ is $ A $ is singular.