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.
Each step pivots on the diagonal entry of largest magnitude of the remaining Schur complement (complete diagonal pivoting, as in LAPACK's xPSTRF), so that for a semidefinite matrix of rank r the n - r entries of D that vanish in exact arithmetic come last, at the level of rounding errors and of either sign. Avoiding the square root on D also stabilizes the computation.
LDLT does not determine a numerical rank, though. Also, do not use a Cholesky decomposition to determine whether a system of equations has a solution.
This class supports the inplace decomposition mechanism.
D is purely diagonal, so this class is not backward stable on indefinite matrices: it can report Success for a factorization with a large backward error. If isPositive() and isNegative() both return false, D has pivots of both signs: unless that comes from the rounding-level pivots of a singular semidefinite matrix, the matrix is indefinite, and BunchKaufman, which produces a block-diagonal D, should be used instead.
- See also
- MatrixBase::ldlt(), SelfAdjointView::ldlt(), class LLT, class BunchKaufman
|
| RealScalar | absDeterminant () const |
| |
| const LDLT & | adjoint () const |
| |
| template<typename InputType> |
| LDLT< MatrixType, UpLo_ > & | compute (const EigenBase< InputType > &a) |
| |
| Scalar | determinant () const |
| |
| 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.
|
| |
| RealScalar | logAbsDeterminant () const |
| |
| 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 () |
| |
| Scalar | signDeterminant () const |
| |
| template<typename Rhs> |
| Solve< LDLT, Rhs > | solve (const MatrixBase< Rhs > &b) const |
| |
| const TranspositionType & | transpositionsP () const |
| |
| Diagonal< const MatrixType > | vectorD () const |
| |
| const AdjointReturnType | adjoint () const |
| |
| constexpr LDLT< MatrixType_, UpLo_ > & | derived () |
| |
| constexpr const LDLT< MatrixType_, UpLo_ > & | derived () const |
| |
| Solve< LDLT< MatrixType_, UpLo_ >, Rhs > | solve (const MatrixBase< Rhs > &b) const |
| |
| | SolverBase ()=default |
| |
| const ConstTransposeReturnType | transpose () const |
| |
| constexpr Index | cols () const noexcept |
| |
| constexpr LDLT< MatrixType_, UpLo_ > & | derived () |
| |
| constexpr const LDLT< MatrixType_, UpLo_ > & | derived () const |
| |
| constexpr Index | rows () const noexcept |
| |
| constexpr Index | size () const noexcept |
| |
template<typename MatrixType_, int UpLo_>
template<typename Rhs>
- 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()