Eigen  3.4.90 (git rev 9589cc4e7fd8e4538bedef80dd36c7738977a8be)
 
Loading...
Searching...
No Matches
Public Member Functions | List of all members
Eigen::LDLT< MatrixType, UpLo > Class Template Reference
Dense linear problems and decompositions » Reference » Cholesky module

#include <Eigen/src/Cholesky/LDLT.h>

Detailed Description

template<typename MatrixType, int UpLo = Lower>
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.

See also
MatrixBase::ldlt(), SelfAdjointView::ldlt(), class LLT
+ Inheritance diagram for Eigen::LDLT< MatrixType, UpLo >:

Public Member Functions

const LDLT & adjoint () const
 
template<typename InputType>
LDLT< MatrixType, UpLo_ > & compute (const EigenBase< InputType > &a)
 
ComputationInfo info () const
 Reports whether previous computation was successful.
 
bool isNegative (void) const
 
bool isPositive () const
 
 LDLT ()
 Default Constructor.
 
template<typename InputType>
 LDLT (const EigenBase< InputType > &matrix)
 Constructor with decomposition.
 
template<typename InputType>
 LDLT (EigenBase< InputType > &matrix)
 Constructs a LDLT factorization from a given matrix.
 
 LDLT (Index size)
 Default Constructor with memory preallocation.
 
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 TranspositionType & transpositionsP () const
 
Diagonal< const MatrixType > vectorD () const
 
- Public Member Functions inherited from Eigen::SolverBase< LDLT< MatrixType_, UpLo_ > >
const AdjointReturnType adjoint () const
 
constexpr LDLT< MatrixType_, UpLo_ > & derived ()
 
constexpr const LDLT< MatrixType_, UpLo_ > & derived () const
 
const Solve< LDLT< MatrixType_, UpLo_ >, Rhs > solve (const MatrixBase< Rhs > &b) const
 
 SolverBase ()
 
const ConstTransposeReturnType transpose () const
 
- Public Member Functions inherited from Eigen::EigenBase< LDLT< MatrixType_, UpLo_ > >
EIGEN_CONSTEXPR Index cols () const EIGEN_NOEXCEPT
 
constexpr LDLT< MatrixType_, UpLo_ > & derived ()
 
constexpr const LDLT< MatrixType_, UpLo_ > & derived () const
 
EIGEN_CONSTEXPR Index rows () const EIGEN_NOEXCEPT
 
EIGEN_CONSTEXPR Index size () const EIGEN_NOEXCEPT
 

Additional Inherited Members

- Public Types inherited from Eigen::EigenBase< LDLT< MatrixType_, UpLo_ > >
typedef Eigen::Index Index
 The interface type of indices.
 

Constructor & Destructor Documentation

◆ LDLT() [1/4]

template<typename MatrixType, int UpLo = Lower>
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 = Lower>
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/4]

template<typename MatrixType, int UpLo = Lower>
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)

◆ LDLT() [4/4]

template<typename MatrixType, int UpLo = Lower>
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.

See also
LDLT(const EigenBase&)

Member Function Documentation

◆ adjoint()

template<typename MatrixType, int UpLo = Lower>
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:

x = decomposition.adjoint().solve(b)

◆ compute()

template<typename MatrixType, int UpLo = Lower>
template<typename InputType>
LDLT< MatrixType, UpLo_ > & 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 = Lower>
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 = Lower>
bool Eigen::LDLT< MatrixType, UpLo >::isNegative ( void ) const
inline
Returns
true if the matrix is negative (semidefinite)

◆ isPositive()

template<typename MatrixType, int UpLo = Lower>
bool Eigen::LDLT< MatrixType, UpLo >::isPositive ( ) const
inline
Returns
true if the matrix is positive (semidefinite)

◆ matrixL()

template<typename MatrixType, int UpLo = Lower>
Traits::MatrixL Eigen::LDLT< MatrixType, UpLo >::matrixL ( ) const
inline
Returns
a view of the lower triangular matrix L

◆ matrixLDLT()

template<typename MatrixType, int UpLo = Lower>
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 = Lower>
Traits::MatrixU Eigen::LDLT< MatrixType, UpLo >::matrixU ( ) const
inline
Returns
a view of the upper triangular matrix U

◆ rankUpdate()

template<typename MatrixType, int UpLo = Lower>
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
wa vector to be incorporated into the decomposition.
sigmaa scalar, +1 for updates and -1 for "downdates," which correspond to removing previously-added column vectors. Optional; default value is +1.
See also
setZero()

◆ rcond()

template<typename MatrixType, int UpLo = Lower>
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 ( ) 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 = Lower>
void Eigen::LDLT< MatrixType, UpLo >::setZero ( )
inline

Clear any existing decomposition

See also
rankUpdate(w,sigma)

◆ solve()

template<typename MatrixType, int UpLo = Lower>
template<typename Rhs>
const Solve< LDLT, Rhs > 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.

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

◆ transpositionsP()

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

◆ vectorD()

template<typename MatrixType, int UpLo = Lower>
Diagonal< const MatrixType > 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 files: