Eigen::LDLT< MatrixType_, UpLo_ > Class Template Reference

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

#include <LDLT.h>

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

Public Types
enum	{ MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime , MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime , UpLo = UpLo_ }
typedef MatrixType_	MatrixType
typedef SolverBase< LDLT >	Base
typedef Matrix< Scalar, RowsAtCompileTime, 1, 0, MaxRowsAtCompileTime, 1 >	TmpMatrixType
typedef Transpositions< RowsAtCompileTime, MaxRowsAtCompileTime >	TranspositionType
typedef PermutationMatrix< RowsAtCompileTime, MaxRowsAtCompileTime >	PermutationType
typedef internal::LDLT_Traits< MatrixType, UpLo >	Traits
Public Types inherited from Eigen::SolverBase< LDLT< MatrixType_, UpLo_ > >
enum
typedef EigenBase< LDLT< MatrixType_, UpLo_ > >	Base
typedef internal::traits< LDLT< MatrixType_, UpLo_ > >::Scalar	Scalar
typedef Scalar	CoeffReturnType
typedef Transpose< const LDLT< MatrixType_, UpLo_ > >	ConstTransposeReturnType
typedef std::conditional_t< NumTraits< Scalar >::IsComplex, CwiseUnaryOp< internal::scalar_conjugate_op< Scalar >, const ConstTransposeReturnType >, const ConstTransposeReturnType >	AdjointReturnType
Public Types inherited from Eigen::EigenBase< Derived >
typedef Eigen::Index	Index
	The interface type of indices. More...
typedef internal::traits< Derived >::StorageKind	StorageKind

Public Member Functions
	LDLT ()
	Default Constructor. More...
	LDLT (Index size)
	Default Constructor with memory preallocation. 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...
void	setZero ()
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 Derived >
bool	solveInPlace (MatrixBase< Derived > &bAndX) const
template<typename InputType >
LDLT &	compute (const EigenBase< InputType > &matrix)
RealScalar	rcond () const
template<typename Derived >
LDLT &	rankUpdate (const MatrixBase< Derived > &w, const RealScalar &alpha=1)
const MatrixType &	matrixLDLT () const
MatrixType	reconstructedMatrix () const
const LDLT &	adjoint () const
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index	rows () const EIGEN_NOEXCEPT
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index	cols () const EIGEN_NOEXCEPT
ComputationInfo	info () const
	Reports whether previous computation was successful. More...
template<typename RhsType , typename DstType >
void	_solve_impl (const RhsType &rhs, DstType &dst) const
template<bool Conjugate, typename RhsType , typename DstType >
void	_solve_impl_transposed (const RhsType &rhs, DstType &dst) const
template<typename InputType >
LDLT< MatrixType, UpLo_ > &	compute (const EigenBase< InputType > &a)
template<typename Derived >
LDLT< MatrixType, UpLo_ > &	rankUpdate (const MatrixBase< Derived > &w, const typename LDLT< MatrixType, UpLo_ >::RealScalar &sigma)
Public Member Functions inherited from Eigen::SolverBase< LDLT< MatrixType_, UpLo_ > >
	SolverBase ()
	~SolverBase ()
const Solve< LDLT< MatrixType_, UpLo_ >, Rhs >	solve (const MatrixBase< Rhs > &b) const
const ConstTransposeReturnType	transpose () const
const AdjointReturnType	adjoint () const
constexpr EIGEN_DEVICE_FUNC LDLT< MatrixType_, UpLo_ > &	derived ()
constexpr EIGEN_DEVICE_FUNC const LDLT< MatrixType_, UpLo_ > &	derived () const
Public Member Functions inherited from Eigen::EigenBase< Derived >
constexpr EIGEN_DEVICE_FUNC Derived &	derived ()
constexpr EIGEN_DEVICE_FUNC const Derived &	derived () const
EIGEN_DEVICE_FUNC Derived &	const_cast_derived () const
EIGEN_DEVICE_FUNC const Derived &	const_derived () const
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index	rows () const EIGEN_NOEXCEPT
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index	cols () const EIGEN_NOEXCEPT
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index	size () const EIGEN_NOEXCEPT
template<typename Dest >
EIGEN_DEVICE_FUNC void	evalTo (Dest &dst) const
template<typename Dest >
EIGEN_DEVICE_FUNC void	addTo (Dest &dst) const
template<typename Dest >
EIGEN_DEVICE_FUNC void	subTo (Dest &dst) const
template<typename Dest >
EIGEN_DEVICE_FUNC void	applyThisOnTheRight (Dest &dst) const
template<typename Dest >
EIGEN_DEVICE_FUNC void	applyThisOnTheLeft (Dest &dst) const
template<typename Device >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DeviceWrapper< Derived, Device >	device (Device &device)
template<typename Device >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DeviceWrapper< const Derived, Device >	device (Device &device) const

Protected Attributes
MatrixType	m_matrix
RealScalar	m_l1_norm
TranspositionType	m_transpositions
TmpMatrixType	m_temporary
internal::SignMatrix	m_sign
bool	m_isInitialized
ComputationInfo	m_info

Friends
class	SolverBase< LDLT >

Additional Inherited Members
Protected Member Functions inherited from Eigen::SolverBase< LDLT< MatrixType_, UpLo_ > >
void	_check_solve_assertion (const Rhs &b) const

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.

See also

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

Member Typedef Documentation

Base

template<typename MatrixType_ , int UpLo_>

typedef SolverBase<LDLT> Eigen::LDLT< MatrixType_, UpLo_ >::Base

MatrixType

template<typename MatrixType_ , int UpLo_>

typedef MatrixType_ Eigen::LDLT< MatrixType_, UpLo_ >::MatrixType

PermutationType

template<typename MatrixType_ , int UpLo_>

typedef PermutationMatrix<RowsAtCompileTime, MaxRowsAtCompileTime> Eigen::LDLT< MatrixType_, UpLo_ >::PermutationType

TmpMatrixType

template<typename MatrixType_ , int UpLo_>

typedef Matrix<Scalar, RowsAtCompileTime, 1, 0, MaxRowsAtCompileTime, 1> Eigen::LDLT< MatrixType_, UpLo_ >::TmpMatrixType

Traits

template<typename MatrixType_ , int UpLo_>

typedef internal::LDLT_Traits<MatrixType, UpLo> Eigen::LDLT< MatrixType_, UpLo_ >::Traits

TranspositionType

template<typename MatrixType_ , int UpLo_>

typedef Transpositions<RowsAtCompileTime, MaxRowsAtCompileTime> Eigen::LDLT< MatrixType_, UpLo_ >::TranspositionType

Member Enumeration Documentation

anonymous enum

template<typename MatrixType_ , int UpLo_>

anonymous enum

Enumerator
MaxRowsAtCompileTime
MaxColsAtCompileTime
UpLo

       {
    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
    UpLo = UpLo_
  };

Constructor & Destructor Documentation

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&).

: m_matrix(), m_transpositions(), m_sign(internal::ZeroSign), m_isInitialized(false) {}

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.

See also

LDLT()

      : m_matrix(size, size),
        m_transpositions(size),
        m_temporary(size),
        m_sign(internal::ZeroSign),
        m_isInitialized(false) {}

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.

See also

LDLT(Index size)

      : m_matrix(matrix.rows(), matrix.cols()),
        m_transpositions(matrix.rows()),
        m_temporary(matrix.rows()),
        m_sign(internal::ZeroSign),
        m_isInitialized(false) {
    compute(matrix.derived());
  }

References Eigen::LDLT< MatrixType_, UpLo_ >::compute(), and matrix().

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.

See also

LDLT(const EigenBase&)

      : m_matrix(matrix.derived()),
        m_transpositions(matrix.rows()),
        m_temporary(matrix.rows()),
        m_sign(internal::ZeroSign),
        m_isInitialized(false) {
    compute(matrix.derived());
  }

References Eigen::LDLT< MatrixType_, UpLo_ >::compute(), and matrix().

Member Function Documentation

_solve_impl()

template<typename MatrixType_ , int UpLo_>

template<typename RhsType , typename DstType >

void Eigen::LDLT< MatrixType_, UpLo_ >::_solve_impl	(	const RhsType &	rhs,
		DstType &	dst
	)		const

                                                                                 {
  _solve_impl_transposed<true>(rhs, dst);
}

_solve_impl_transposed()

template<typename MatrixType_ , int UpLo_>

template<bool Conjugate, typename RhsType , typename DstType >

void Eigen::LDLT< MatrixType_, UpLo_ >::_solve_impl_transposed	(	const RhsType &	rhs,
		DstType &	dst
	)		const

                                                                                            {
  // dst = P b
  dst = m_transpositions * rhs;
 
  // dst = L^-1 (P b)
  // dst = L^-*T (P b)
  matrixL().template conjugateIf<!Conjugate>().solveInPlace(dst);
 
  // dst = D^-* (L^-1 P b)
  // dst = D^-1 (L^-*T P b)
  // more precisely, use pseudo-inverse of D (see bug 241)
  using std::abs;
  const typename Diagonal<const MatrixType>::RealReturnType vecD(vectorD());
  // In some previous versions, tolerance was set to the max of 1/highest (or rather numeric_limits::min())
  // and the maximal diagonal entry * epsilon as motivated by LAPACK's xGELSS:
  // RealScalar tolerance = numext::maxi(vecD.array().abs().maxCoeff() * NumTraits<RealScalar>::epsilon(),RealScalar(1)
  // / NumTraits<RealScalar>::highest()); However, LDLT is not rank revealing, and so adjusting the tolerance wrt to the
  // highest diagonal element is not well justified and leads to numerical issues in some cases. Moreover, Lapack's
  // xSYTRS routines use 0 for the tolerance. Using numeric_limits::min() gives us more robustness to denormals.
  RealScalar tolerance = (std::numeric_limits<RealScalar>::min)();
  for (Index i = 0; i < vecD.size(); ++i) {
    if (abs(vecD(i)) > tolerance)
      dst.row(i) /= vecD(i);
    else
      dst.row(i).setZero();
  }
 
  // dst = L^-* (D^-* L^-1 P b)
  // dst = L^-T (D^-1 L^-*T P b)
  matrixL().transpose().template conjugateIf<Conjugate>().solveInPlace(dst);
 
  // dst = P^T (L^-* D^-* L^-1 P b) = A^-1 b
  // dst = P^-T (L^-T D^-1 L^-*T P b) = A^-1 b
  dst = m_transpositions.transpose() * dst;
}

References abs(), i, Eigen::LDLT< MatrixType_, UpLo_ >::m_transpositions, Eigen::LDLT< MatrixType_, UpLo_ >::matrixL(), min, Eigen::TranspositionsBase< Derived >::transpose(), and Eigen::LDLT< MatrixType_, UpLo_ >::vectorD().

adjoint()

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:

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

{ return *this; }

Referenced by cholesky_verify_assert().

cols()

template<typename MatrixType_ , int UpLo_>

EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index Eigen::LDLT< MatrixType_, UpLo_ >::cols ( ) const

inline

{ return m_matrix.cols(); }

References Eigen::LDLT< MatrixType_, UpLo_ >::m_matrix.

Referenced by gdb.printers._MatrixEntryIterator::__next__(), gdb.printers.EigenMatrixPrinter::children(), gdb.printers.EigenSparseMatrixPrinter::children(), gdb.printers.EigenMatrixPrinter::to_string(), and gdb.printers.EigenSparseMatrixPrinter::to_string().

compute() [1/2]

template<typename MatrixType_ , int UpLo_>

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

                                                                                       {
  eigen_assert(a.rows() == a.cols());
  const Index size = a.rows();
 
  m_matrix = a.derived();
 
  // Compute matrix L1 norm = max abs column sum.
  m_l1_norm = RealScalar(0);
  // TODO move this code to SelfAdjointView
  for (Index col = 0; col < size; ++col) {
    RealScalar abs_col_sum;
    if (UpLo_ == Lower)
      abs_col_sum =
          m_matrix.col(col).tail(size - col).template lpNorm<1>() + m_matrix.row(col).head(col).template lpNorm<1>();
    else
      abs_col_sum =
          m_matrix.col(col).head(col).template lpNorm<1>() + m_matrix.row(col).tail(size - col).template lpNorm<1>();
    if (abs_col_sum > m_l1_norm) m_l1_norm = abs_col_sum;
  }
 
  m_transpositions.resize(size);
  m_isInitialized = false;
  m_temporary.resize(size);
  m_sign = internal::ZeroSign;
 
  m_info = internal::ldlt_inplace<UpLo>::unblocked(m_matrix, m_transpositions, m_temporary, m_sign) ? Success
                                                                                                    : NumericalIssue;
 
  m_isInitialized = true;
  return *this;
}

References a, col(), eigen_assert, Eigen::Lower, Eigen::LDLT< MatrixType_, UpLo_ >::m_info, Eigen::LDLT< MatrixType_, UpLo_ >::m_isInitialized, Eigen::LDLT< MatrixType_, UpLo_ >::m_l1_norm, Eigen::LDLT< MatrixType_, UpLo_ >::m_matrix, Eigen::LDLT< MatrixType_, UpLo_ >::m_sign, Eigen::LDLT< MatrixType_, UpLo_ >::m_temporary, Eigen::LDLT< MatrixType_, UpLo_ >::m_transpositions, Eigen::NumericalIssue, Eigen::TranspositionsBase< Derived >::resize(), Eigen::PlainObjectBase< Derived >::resize(), Eigen::EigenBase< Derived >::size(), Eigen::Success, and Eigen::internal::ZeroSign.

compute() [2/2]

template<typename MatrixType_ , int UpLo_>

template<typename InputType >

LDLT& Eigen::LDLT< MatrixType_, UpLo_ >::compute

(

const EigenBase< InputType > &

matrix

)

Referenced by cholesky(), cholesky_definiteness(), cholesky_faillure_cases(), ctms_decompositions(), and Eigen::LDLT< MatrixType_, UpLo_ >::LDLT().

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.

                               {
    eigen_assert(m_isInitialized && "LDLT is not initialized.");
    return m_info;
  }

References eigen_assert, Eigen::LDLT< MatrixType_, UpLo_ >::m_info, and Eigen::LDLT< MatrixType_, UpLo_ >::m_isInitialized.

Referenced by cholesky(), cholesky_cplx(), cholesky_definiteness(), and cholesky_faillure_cases().

isNegative()

template<typename MatrixType_ , int UpLo_>

bool Eigen::LDLT< MatrixType_, UpLo_ >::isNegative ( void  ) const

inline

Returns

true if the matrix is negative (semidefinite)

                                     {
    eigen_assert(m_isInitialized && "LDLT is not initialized.");
    return m_sign == internal::NegativeSemiDef || m_sign == internal::ZeroSign;
  }

References eigen_assert, Eigen::LDLT< MatrixType_, UpLo_ >::m_isInitialized, Eigen::LDLT< MatrixType_, UpLo_ >::m_sign, Eigen::internal::NegativeSemiDef, and Eigen::internal::ZeroSign.

Referenced by cholesky_definiteness(), and cholesky_verify_assert().

isPositive()

template<typename MatrixType_ , int UpLo_>

bool Eigen::LDLT< MatrixType_, UpLo_ >::isPositive ( ) const

inline

Returns

true if the matrix is positive (semidefinite)

                                 {
    eigen_assert(m_isInitialized && "LDLT is not initialized.");
    return m_sign == internal::PositiveSemiDef || m_sign == internal::ZeroSign;
  }

References eigen_assert, Eigen::LDLT< MatrixType_, UpLo_ >::m_isInitialized, Eigen::LDLT< MatrixType_, UpLo_ >::m_sign, Eigen::internal::PositiveSemiDef, and Eigen::internal::ZeroSign.

Referenced by cholesky_definiteness(), and cholesky_verify_assert().

matrixL()

template<typename MatrixType_ , int UpLo_>

Traits::MatrixL Eigen::LDLT< MatrixType_, UpLo_ >::matrixL ( ) const

inline

Returns

a view of the lower triangular matrix L

                                                {
    eigen_assert(m_isInitialized && "LDLT is not initialized.");
    return Traits::getL(m_matrix);
  }

References eigen_assert, Eigen::LDLT< MatrixType_, UpLo_ >::m_isInitialized, and Eigen::LDLT< MatrixType_, UpLo_ >::m_matrix.

Referenced by __attribute__(), Eigen::LDLT< MatrixType_, UpLo_ >::_solve_impl_transposed(), cholesky(), cholesky_verify_assert(), and Eigen::LDLT< MatrixType_, UpLo_ >::reconstructedMatrix().

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

                                              {
    eigen_assert(m_isInitialized && "LDLT is not initialized.");
    return m_matrix;
  }

References eigen_assert, Eigen::LDLT< MatrixType_, UpLo_ >::m_isInitialized, and Eigen::LDLT< MatrixType_, UpLo_ >::m_matrix.

matrixU()

template<typename MatrixType_ , int UpLo_>

Traits::MatrixU Eigen::LDLT< MatrixType_, UpLo_ >::matrixU ( ) const

inline

Returns

a view of the upper triangular matrix U

                                                {
    eigen_assert(m_isInitialized && "LDLT is not initialized.");
    return Traits::getU(m_matrix);
  }

References eigen_assert, Eigen::LDLT< MatrixType_, UpLo_ >::m_isInitialized, and Eigen::LDLT< MatrixType_, UpLo_ >::m_matrix.

Referenced by cholesky(), and Eigen::LDLT< MatrixType_, UpLo_ >::reconstructedMatrix().

rankUpdate() [1/2]

template<typename MatrixType_ , int UpLo_>

template<typename Derived >

LDLT& Eigen::LDLT< MatrixType_, UpLo_ >::rankUpdate	(	const MatrixBase< Derived > &	w,
		const RealScalar &	alpha = 1
	)

rankUpdate() [2/2]

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()

                                                                                           {
  typedef typename TranspositionType::StorageIndex IndexType;
  const Index size = w.rows();
  if (m_isInitialized) {
    eigen_assert(m_matrix.rows() == size);
  } else {
    m_matrix.resize(size, size);
    m_matrix.setZero();
    m_transpositions.resize(size);
    for (Index i = 0; i < size; i++) m_transpositions.coeffRef(i) = IndexType(i);
    m_temporary.resize(size);
    m_sign = sigma >= 0 ? internal::PositiveSemiDef : internal::NegativeSemiDef;
    m_isInitialized = true;
  }
 
  internal::ldlt_inplace<UpLo>::update(m_matrix, m_transpositions, m_temporary, w, sigma);
 
  return *this;
}

References Eigen::TranspositionsBase< Derived >::coeffRef(), eigen_assert, i, Eigen::LDLT< MatrixType_, UpLo_ >::m_isInitialized, Eigen::LDLT< MatrixType_, UpLo_ >::m_matrix, Eigen::LDLT< MatrixType_, UpLo_ >::m_sign, Eigen::LDLT< MatrixType_, UpLo_ >::m_temporary, Eigen::LDLT< MatrixType_, UpLo_ >::m_transpositions, Eigen::internal::NegativeSemiDef, Eigen::internal::PositiveSemiDef, Eigen::TranspositionsBase< Derived >::resize(), Eigen::PlainObjectBase< Derived >::resize(), calibrate::sigma, Eigen::EigenBase< Derived >::size(), and w.

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.

                           {
    eigen_assert(m_isInitialized && "LDLT is not initialized.");
    return internal::rcond_estimate_helper(m_l1_norm, *this);
  }

References eigen_assert, Eigen::LDLT< MatrixType_, UpLo_ >::m_isInitialized, Eigen::LDLT< MatrixType_, UpLo_ >::m_l1_norm, and Eigen::internal::rcond_estimate_helper().

Referenced by cholesky().

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.

                                                              {
  eigen_assert(m_isInitialized && "LDLT is not initialized.");
  const Index size = m_matrix.rows();
  MatrixType res(size, size);
 
  // P
  res.setIdentity();
  res = transpositionsP() * res;
  // L^* P
  res = matrixU() * res;
  // D(L^*P)
  res = vectorD().real().asDiagonal() * res;
  // L(DL^*P)
  res = matrixL() * res;
  // P^T (LDL^*P)
  res = transpositionsP().transpose() * res;
 
  return res;
}

References eigen_assert, Eigen::LDLT< MatrixType_, UpLo_ >::m_isInitialized, Eigen::LDLT< MatrixType_, UpLo_ >::m_matrix, Eigen::LDLT< MatrixType_, UpLo_ >::matrixL(), Eigen::LDLT< MatrixType_, UpLo_ >::matrixU(), res, Eigen::EigenBase< Derived >::size(), Eigen::TranspositionsBase< Derived >::transpose(), Eigen::LDLT< MatrixType_, UpLo_ >::transpositionsP(), and Eigen::LDLT< MatrixType_, UpLo_ >::vectorD().

Referenced by cholesky(), cholesky_cplx(), cholesky_definiteness(), and cholesky_faillure_cases().

rows()

template<typename MatrixType_ , int UpLo_>

EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index Eigen::LDLT< MatrixType_, UpLo_ >::rows ( ) const

inline

{ return m_matrix.rows(); }

References Eigen::LDLT< MatrixType_, UpLo_ >::m_matrix.

Referenced by gdb.printers._MatrixEntryIterator::__next__(), gdb.printers.EigenMatrixPrinter::children(), gdb.printers.EigenSparseMatrixPrinter::children(), gdb.printers.EigenMatrixPrinter::to_string(), and gdb.printers.EigenSparseMatrixPrinter::to_string().

setZero()

template<typename MatrixType_ , int UpLo_>

void Eigen::LDLT< MatrixType_, UpLo_ >::setZero ( )

inline

Clear any existing decomposition

See also

rankUpdate(w,sigma)

{ m_isInitialized = false; }

References Eigen::LDLT< MatrixType_, UpLo_ >::m_isInitialized.

solveInPlace()

template<typename MatrixType , int UpLo_>

template<typename Derived >

bool Eigen::LDLT< MatrixType, UpLo_ >::solveInPlace

(

MatrixBase< Derived > &

bAndX

)

const

use x = ldlt_object.solve(x);

This is the in-place version of solve().

Parameters

bAndX

represents both the right-hand side matrix b and result x.

Returns

true always! If you need to check for existence of solutions, use another decomposition like LU, QR, or SVD.

This version avoids a copy when the right hand side matrix b is not needed anymore.

See also

LDLT::solve(), MatrixBase::ldlt()

                                                                           {
  eigen_assert(m_isInitialized && "LDLT is not initialized.");
  eigen_assert(m_matrix.rows() == bAndX.rows());
 
  bAndX = this->solve(bAndX);
 
  return true;
}

References eigen_assert, Eigen::LDLT< MatrixType_, UpLo_ >::m_isInitialized, Eigen::LDLT< MatrixType_, UpLo_ >::m_matrix, and Eigen::SolverBase< LDLT< MatrixType_, UpLo_ > >::solve().

Referenced by cholesky_verify_assert().

transpositionsP()

template<typename MatrixType_ , int UpLo_>

const TranspositionType& Eigen::LDLT< MatrixType_, UpLo_ >::transpositionsP ( ) const

inline

Returns

the permutation matrix P as a transposition sequence.

                                                          {
    eigen_assert(m_isInitialized && "LDLT is not initialized.");
    return m_transpositions;
  }

References eigen_assert, Eigen::LDLT< MatrixType_, UpLo_ >::m_isInitialized, and Eigen::LDLT< MatrixType_, UpLo_ >::m_transpositions.

Referenced by cholesky_verify_assert(), and Eigen::LDLT< MatrixType_, UpLo_ >::reconstructedMatrix().

vectorD()

template<typename MatrixType_ , int UpLo_>

Diagonal<const MatrixType> Eigen::LDLT< MatrixType_, UpLo_ >::vectorD ( ) const

inline

Returns

the coefficients of the diagonal matrix D

                                                    {
    eigen_assert(m_isInitialized && "LDLT is not initialized.");
    return m_matrix.diagonal();
  }

References eigen_assert, Eigen::LDLT< MatrixType_, UpLo_ >::m_isInitialized, and Eigen::LDLT< MatrixType_, UpLo_ >::m_matrix.

Referenced by Eigen::LDLT< MatrixType_, UpLo_ >::_solve_impl_transposed(), cholesky(), cholesky_verify_assert(), and Eigen::LDLT< MatrixType_, UpLo_ >::reconstructedMatrix().

Friends And Related Function Documentation

SolverBase< LDLT >

template<typename MatrixType_ , int UpLo_>

friend class SolverBase< LDLT >

friend

Member Data Documentation

m_info

template<typename MatrixType_ , int UpLo_>

ComputationInfo Eigen::LDLT< MatrixType_, UpLo_ >::m_info

protected

Referenced by Eigen::LDLT< MatrixType_, UpLo_ >::compute(), and Eigen::LDLT< MatrixType_, UpLo_ >::info().

m_isInitialized

template<typename MatrixType_ , int UpLo_>

bool Eigen::LDLT< MatrixType_, UpLo_ >::m_isInitialized

protected

Referenced by Eigen::LDLT< MatrixType_, UpLo_ >::compute(), Eigen::LDLT< MatrixType_, UpLo_ >::info(), Eigen::LDLT< MatrixType_, UpLo_ >::isNegative(), Eigen::LDLT< MatrixType_, UpLo_ >::isPositive(), Eigen::LDLT< MatrixType_, UpLo_ >::matrixL(), Eigen::LDLT< MatrixType_, UpLo_ >::matrixLDLT(), Eigen::LDLT< MatrixType_, UpLo_ >::matrixU(), Eigen::LDLT< MatrixType_, UpLo_ >::rankUpdate(), Eigen::LDLT< MatrixType_, UpLo_ >::rcond(), Eigen::LDLT< MatrixType_, UpLo_ >::reconstructedMatrix(), Eigen::LDLT< MatrixType_, UpLo_ >::setZero(), Eigen::LDLT< MatrixType_, UpLo_ >::solveInPlace(), Eigen::LDLT< MatrixType_, UpLo_ >::transpositionsP(), and Eigen::LDLT< MatrixType_, UpLo_ >::vectorD().

m_l1_norm

template<typename MatrixType_ , int UpLo_>

RealScalar Eigen::LDLT< MatrixType_, UpLo_ >::m_l1_norm

protected

Referenced by Eigen::LDLT< MatrixType_, UpLo_ >::compute(), and Eigen::LDLT< MatrixType_, UpLo_ >::rcond().

m_matrix

template<typename MatrixType_ , int UpLo_>

MatrixType Eigen::LDLT< MatrixType_, UpLo_ >::m_matrix

protected

Used to compute and store the Cholesky decomposition A = L D L^* = U^* D U. The strict upper part is used during the decomposition, the strict lower part correspond to the coefficients of L (its diagonal is equal to 1 and is not stored), and the diagonal entries correspond to D.

Referenced by Eigen::LDLT< MatrixType_, UpLo_ >::cols(), Eigen::LDLT< MatrixType_, UpLo_ >::compute(), Eigen::SelfAdjointView< MatrixType_, UpLo >::ldlt(), Eigen::LDLT< MatrixType_, UpLo_ >::matrixL(), Eigen::LDLT< MatrixType_, UpLo_ >::matrixLDLT(), Eigen::LDLT< MatrixType_, UpLo_ >::matrixU(), Eigen::LDLT< MatrixType_, UpLo_ >::rankUpdate(), Eigen::LDLT< MatrixType_, UpLo_ >::reconstructedMatrix(), Eigen::LDLT< MatrixType_, UpLo_ >::rows(), Eigen::LDLT< MatrixType_, UpLo_ >::solveInPlace(), and Eigen::LDLT< MatrixType_, UpLo_ >::vectorD().

m_sign

template<typename MatrixType_ , int UpLo_>

internal::SignMatrix Eigen::LDLT< MatrixType_, UpLo_ >::m_sign

protected

Referenced by Eigen::LDLT< MatrixType_, UpLo_ >::compute(), Eigen::LDLT< MatrixType_, UpLo_ >::isNegative(), Eigen::LDLT< MatrixType_, UpLo_ >::isPositive(), and Eigen::LDLT< MatrixType_, UpLo_ >::rankUpdate().

m_temporary

template<typename MatrixType_ , int UpLo_>

TmpMatrixType Eigen::LDLT< MatrixType_, UpLo_ >::m_temporary

protected

Referenced by Eigen::LDLT< MatrixType_, UpLo_ >::compute(), and Eigen::LDLT< MatrixType_, UpLo_ >::rankUpdate().

m_transpositions

template<typename MatrixType_ , int UpLo_>

TranspositionType Eigen::LDLT< MatrixType_, UpLo_ >::m_transpositions

protected

Referenced by Eigen::LDLT< MatrixType_, UpLo_ >::_solve_impl_transposed(), Eigen::LDLT< MatrixType_, UpLo_ >::compute(), Eigen::LDLT< MatrixType_, UpLo_ >::rankUpdate(), and Eigen::LDLT< MatrixType_, UpLo_ >::transpositionsP().

---

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

• LDLT.h