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

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

Collaboration diagram for Eigen::LDLT< _MatrixType, _UpLo >:

Public Types
enum	{ RowsAtCompileTime = MatrixType::RowsAtCompileTime , ColsAtCompileTime = MatrixType::ColsAtCompileTime , 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, 0, 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.

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

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

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

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)

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

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

RealScalar	m_l1_norm

TranspositionType	m_transpositions

TmpMatrixType	m_temporary

internal::SignMatrix	m_sign

bool	m_isInitialized

ComputationInfo	m_info

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

This class supports the inplace decomposition mechanism.

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

◆ 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

◆ RealScalar

template<typename _MatrixType , int _UpLo>

typedef NumTraits<typenameMatrixType::Scalar>::Real Eigen::LDLT< _MatrixType, _UpLo >::RealScalar

◆ Scalar

template<typename _MatrixType , int _UpLo>

typedef MatrixType::Scalar Eigen::LDLT< _MatrixType, _UpLo >::Scalar

◆ StorageIndex

template<typename _MatrixType , int _UpLo>

typedef MatrixType::StorageIndex Eigen::LDLT< _MatrixType, _UpLo >::StorageIndex

◆ 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
RowsAtCompileTime
ColsAtCompileTime
MaxRowsAtCompileTime
MaxColsAtCompileTime
UpLo

         {
      RowsAtCompileTime = MatrixType::RowsAtCompileTime,
      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
      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 Eigen::EigenBase< Derived >::derived().

Here is the call graph for this function:

◆ 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 Eigen::EigenBase< Derived >::derived().

Here is the call graph for this function:

Member Function Documentation

◆ _solve_impl() [1/2]

template<typename _MatrixType , int _UpLo>

template<typename RhsType , typename DstType >

EIGEN_DEVICE_FUNC void Eigen::LDLT< _MatrixType, _UpLo >::_solve_impl	(	const RhsType &	rhs,
		DstType &	dst
	)		const

◆ _solve_impl() [2/2]

template<typename _MatrixType , int _UpLo>

template<typename RhsType , typename DstType >

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

{
  eigen_assert(rhs.rows() == rows());
  // dst = P b
  dst = m_transpositions * rhs;
 
  // dst = L^-1 (P b)
  matrixL().solveInPlace(dst);
 
  // dst = D^-1 (L^-1 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^-T (D^-1 L^-1 P b)
  matrixU().solveInPlace(dst);
 
  // dst = P^-1 (L^-T D^-1 L^-1 P b) = A^-1 b
  dst = m_transpositions.transpose() * dst;
}

References eigen_assert.

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

243{ return *this; };

◆ check_template_parameters()

template<typename _MatrixType , int _UpLo>

static void Eigen::LDLT< _MatrixType, _UpLo >::check_template_parameters ( )

inlinestaticprotected

    {
      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
    }

References EIGEN_STATIC_ASSERT_NON_INTEGER.

◆ cols()

template<typename _MatrixType , int _UpLo>

Index Eigen::LDLT< _MatrixType, _UpLo >::cols ( ) const

inline

246{ return m_matrix.cols(); }

References Eigen::LDLT< _MatrixType, _UpLo >::m_matrix.

◆ 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

{
  check_template_parameters();
 
  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 col(), eigen_assert, Eigen::Lower, Eigen::NumericalIssue, Eigen::Success, and Eigen::internal::ZeroSign.

Here is the call graph for this function:

◆ compute() [2/2]

template<typename _MatrixType , int _UpLo>

template<typename InputType >

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

Referenced by Eigen::LDLT< _MatrixType, _UpLo >::LDLT(), and Eigen::LDLT< _MatrixType, _UpLo >::LDLT().

Here is the caller graph for this function:

◆ 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 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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_assert, Eigen::internal::NegativeSemiDef, and Eigen::internal::PositiveSemiDef.

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

Here is the call graph for this function:

◆ 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.

◆ rows()

template<typename _MatrixType , int _UpLo>

Index Eigen::LDLT< _MatrixType, _UpLo >::rows ( ) const

inline

245{ return m_matrix.rows(); }

References Eigen::LDLT< _MatrixType, _UpLo >::m_matrix.

◆ 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.

◆ 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.

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

    {
      eigen_assert(m_isInitialized && "LDLT is not initialized.");
      eigen_assert(m_matrix.rows()==b.rows()
                && "LDLT::solve(): invalid number of rows of the right hand side matrix b");
      return Solve<LDLT, Rhs>(*this, b.derived());
    }

References eigen_assert, Eigen::LDLT< _MatrixType, _UpLo >::m_isInitialized, and Eigen::LDLT< _MatrixType, _UpLo >::m_matrix.

◆ solveInPlace()

template<typename MatrixType , int _UpLo>

template<typename Derived >

bool Eigen::LDLT< MatrixType, _UpLo >::solveInPlace ( MatrixBase< Derived > & bAndX ) const

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

References eigen_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.

◆ 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.

Member Data Documentation

◆ m_info

template<typename _MatrixType , int _UpLo>

ComputationInfo Eigen::LDLT< _MatrixType, _UpLo >::m_info

protected

Referenced by Eigen::LDLT< _MatrixType, _UpLo >::info().

◆ m_isInitialized

template<typename _MatrixType , int _UpLo>

bool Eigen::LDLT< _MatrixType, _UpLo >::m_isInitialized

protected

◆ m_l1_norm

template<typename _MatrixType , int _UpLo>

RealScalar Eigen::LDLT< _MatrixType, _UpLo >::m_l1_norm

protected

Referenced by Eigen::LDLT< _MatrixType, _UpLo >::rcond().

◆ m_matrix

template<typename _MatrixType , int _UpLo>

MatrixType Eigen::LDLT< _MatrixType, _UpLo >::m_matrix

protected

Referenced by Eigen::LDLT< _MatrixType, _UpLo >::cols(), Eigen::LDLT< _MatrixType, _UpLo >::matrixL(), Eigen::LDLT< _MatrixType, _UpLo >::matrixLDLT(), Eigen::LDLT< _MatrixType, _UpLo >::matrixU(), Eigen::LDLT< _MatrixType, _UpLo >::rows(), Eigen::LDLT< _MatrixType, _UpLo >::solve(), 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 >::isNegative(), and Eigen::LDLT< _MatrixType, _UpLo >::isPositive().

◆ m_temporary

template<typename _MatrixType , int _UpLo>

TmpMatrixType Eigen::LDLT< _MatrixType, _UpLo >::m_temporary

protected

◆ m_transpositions

template<typename _MatrixType , int _UpLo>

TranspositionType Eigen::LDLT< _MatrixType, _UpLo >::m_transpositions

protected

Referenced by Eigen::LDLT< _MatrixType, _UpLo >::transpositionsP().

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

src/eigen/Eigen/src/Cholesky/LDLT.h

Public Types

Public Member Functions

Static Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ Index

◆ MatrixType

◆ PermutationType

◆ RealScalar

◆ Scalar

◆ StorageIndex

◆ TmpMatrixType

◆ Traits

◆ TranspositionType

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ LDLT() [1/4]

◆ LDLT() [2/4]

◆ LDLT() [3/4]

◆ LDLT() [4/4]

Member Function Documentation

◆ _solve_impl() [1/2]

◆ _solve_impl() [2/2]

◆ adjoint()

◆ check_template_parameters()

◆ cols()

◆ compute() [1/2]

◆ compute() [2/2]

◆ info()

◆ isNegative()

◆ isPositive()

◆ matrixL()

◆ matrixLDLT()

◆ matrixU()

◆ rankUpdate() [1/2]

◆ rankUpdate() [2/2]

◆ rcond()

◆ reconstructedMatrix()

◆ rows()

◆ setZero()

◆ solve()

◆ solveInPlace()

◆ transpositionsP()

◆ vectorD()

Member Data Documentation

◆ m_info

◆ m_isInitialized

◆ m_l1_norm

◆ m_matrix

◆ m_sign

◆ m_temporary

◆ m_transpositions