Please, help us to better know about our user community by answering the following short survey: https://forms.gle/wpyrxWi18ox9Z5ae9
 Eigen  3.4.90 (git rev e3e74001f7c4bf95f0dde572e8a08c5b2918a3ab)
Eigen::LDLT< MatrixType_, UpLo_ > Class Template Reference

## Detailed Description

### template<typename MatrixType_, int UpLo_> class Eigen::LDLT< MatrixType_, UpLo_ >

Robust Cholesky decomposition of a matrix with pivoting.

Template 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 decomposition: 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 D 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.

This class supports the inplace decomposition mechanism.

Inheritance diagram for Eigen::LDLT< MatrixType_, UpLo_ >:

## Public Member Functions

template<typename InputType >
LDLT< MatrixType, UpLo_ > & compute (const EigenBase< InputType > &a)

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

bool isNegative (void) const

bool isPositive () const

LDLT ()
Default Constructor. More...

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

template<typename InputType >
LDLT (EigenBase< InputType > &matrix)
Constructs a LDLT factorization from a given matrix. More...

LDLT (Index size)
Default Constructor with memory preallocation. More...

Traits::MatrixL matrixL () const

const MatrixType & matrixLDLT () const

Traits::MatrixU matrixU () const

template<typename Derived >
LDLT< MatrixType, UpLo_ > & rankUpdate (const MatrixBase< Derived > &w, const typename LDLT< MatrixType, UpLo_ >::RealScalar &sigma)

RealScalar rcond () const

MatrixType reconstructedMatrix () const

void setZero ()

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

const TranspositionTypetranspositionsP () const

Diagonal< const MatrixType > vectorD () const

Public Member Functions inherited from Eigen::SolverBase< LDLT< MatrixType_, UpLo_ > >

LDLT< MatrixType_, UpLo_ > & derived ()

const LDLT< MatrixType_, UpLo_ > & derived () const

const Solve< LDLT< MatrixType_, UpLo_ >, Rhs > solve (const MatrixBase< Rhs > &b) const

SolverBase ()

ConstTransposeReturnType transpose () const

Public Member Functions inherited from Eigen::EigenBase< Derived >
EIGEN_CONSTEXPR Index cols () const EIGEN_NOEXCEPT

Derived & derived ()

const Derived & derived () const

EIGEN_CONSTEXPR Index rows () const EIGEN_NOEXCEPT

EIGEN_CONSTEXPR Index size () const EIGEN_NOEXCEPT

Public Types inherited from Eigen::EigenBase< Derived >
typedef Eigen::Index Index
The interface type of indices. More...

## ◆ LDLT() [1/4]

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/4]

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.

LDLT()

## ◆ LDLT() [3/4]

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.

LDLT(Index size)

## ◆ LDLT() [4/4]

template<typename MatrixType_ , int UpLo_>
template<typename InputType >
 Eigen::LDLT< MatrixType_, UpLo_ >::LDLT ( EigenBase< InputType > & matrix )
inlineexplicit

Constructs a LDLT factorization from a given matrix.

This overloaded constructor is provided for inplace decomposition when MatrixType is a Eigen::Ref.

LDLT(const EigenBase&)

## Member Function Documentation

template<typename MatrixType_ , int UpLo_>
 const LDLT& Eigen::LDLT< MatrixType_, UpLo_ >::adjoint ( ) const
inline
Returns
the adjoint of *this, that is, a const reference to the decomposition itself as the underlying matrix is self-adjoint.

This method is provided for compatibility with other matrix decompositions, thus enabling generic code such as:

## ◆ compute()

template<typename MatrixType_ , int UpLo_>
template<typename InputType >
 LDLT& Eigen::LDLT< MatrixType_, UpLo_ >::compute ( const EigenBase< InputType > & a )

Compute / recompute the LDLT decomposition A = L D L^* = U^* D U of matrix

## ◆ 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 successful, NumericalIssue if the factorization failed because of a zero pivot.

## ◆ 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& 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.
setZero()

## ◆ rcond()

template<typename MatrixType_ , int UpLo_>
 RealScalar Eigen::LDLT< MatrixType_, UpLo_ >::rcond ( ) const
inline
Returns
an estimate of the reciprocal condition number of the matrix of which *this is the LDLT decomposition.

## ◆ reconstructedMatrix()

template<typename MatrixType , int UpLo_>
 MatrixType Eigen::LDLT< MatrixType, UpLo_ >::reconstructedMatrix
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

rankUpdate(w,sigma)

## ◆ solve()

template<typename MatrixType_ , int UpLo_>
template<typename Rhs >
 const Solve Eigen::LDLT< MatrixType_, UpLo_ >::solve ( const MatrixBase< Rhs > & b ) const
inline
Returns
a solution x of $$A x = b$$ using the current decomposition of A.

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

This method just tries to find as good a solution as possible. If you want to check whether a solution exists or if it is accurate, just call this function to get a result and then compute the error of this result, or use MatrixBase::isApprox() directly, for instance like this:

bool a_solution_exists = (A*result).isApprox(b, precision);

This method avoids dividing by zero, so that the non-existence of a solution doesn't by itself mean that you'll get inf or nan values.

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 $$D y_3 = y_2$$ is computed. This does not mean that this function computes the least-square solution of $$A x = b$$ if $$A$$ is singular.

## ◆ transpositionsP()

template<typename MatrixType_ , int UpLo_>
 const TranspositionType& Eigen::LDLT< MatrixType_, UpLo_ >::transpositionsP ( ) const
inline
Returns
the permutation matrix P as a transposition sequence.

## ◆ vectorD()

template<typename MatrixType_ , int UpLo_>
 Diagonal Eigen::LDLT< MatrixType_, UpLo_ >::vectorD ( ) const
inline
Returns
the coefficients of the diagonal matrix D

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