17template<
typename _MatrixType,
int _UpLo>
struct traits<LLT<_MatrixType, _UpLo> >
20 typedef MatrixXpr XprKind;
21 typedef SolverStorage StorageKind;
22 typedef int StorageIndex;
26template<
typename MatrixType,
int UpLo>
struct LLT_Traits;
66template<
typename _MatrixType,
int _UpLo>
class LLT
70 typedef _MatrixType MatrixType;
74 EIGEN_GENERIC_PUBLIC_INTERFACE(
LLT)
76 MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
80 PacketSize = internal::packet_traits<Scalar>::size,
81 AlignmentMask = int(PacketSize)-1,
85 typedef internal::LLT_Traits<MatrixType,UpLo> Traits;
93 LLT() : m_matrix(), m_isInitialized(false) {}
102 m_isInitialized(false) {}
104 template<
typename InputType>
106 : m_matrix(matrix.rows(), matrix.cols()),
107 m_isInitialized(false)
119 template<
typename InputType>
122 m_isInitialized(false)
128 inline typename Traits::MatrixU
matrixU()
const
130 eigen_assert(m_isInitialized &&
"LLT is not initialized.");
131 return Traits::getU(m_matrix);
135 inline typename Traits::MatrixL
matrixL()
const
137 eigen_assert(m_isInitialized &&
"LLT is not initialized.");
138 return Traits::getL(m_matrix);
141 #ifdef EIGEN_PARSED_BY_DOXYGEN
152 template<
typename Rhs>
157 template<
typename Derived>
160 template<
typename InputType>
168 eigen_assert(m_isInitialized &&
"LLT is not initialized.");
169 eigen_assert(m_info ==
Success &&
"LLT failed because matrix appears to be negative");
170 return internal::rcond_estimate_helper(m_l1_norm, *
this);
179 eigen_assert(m_isInitialized &&
"LLT is not initialized.");
193 eigen_assert(m_isInitialized &&
"LLT is not initialized.");
204 inline EIGEN_CONSTEXPR
Index rows() const EIGEN_NOEXCEPT {
return m_matrix.rows(); }
205 inline EIGEN_CONSTEXPR
Index cols() const EIGEN_NOEXCEPT {
return m_matrix.cols(); }
207 template<
typename VectorType>
208 LLT & rankUpdate(
const VectorType& vec,
const RealScalar& sigma = 1);
210 #ifndef EIGEN_PARSED_BY_DOXYGEN
211 template<
typename RhsType,
typename DstType>
212 void _solve_impl(
const RhsType &rhs, DstType &dst)
const;
214 template<
bool Conjugate,
typename RhsType,
typename DstType>
215 void _solve_impl_transposed(
const RhsType &rhs, DstType &dst)
const;
220 static void check_template_parameters()
222 EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
230 RealScalar m_l1_norm;
231 bool m_isInitialized;
237template<
typename Scalar,
int UpLo>
struct llt_inplace;
239template<
typename MatrixType,
typename VectorType>
240static Index llt_rank_update_lower(MatrixType& mat,
const VectorType& vec,
const typename MatrixType::RealScalar& sigma)
243 typedef typename MatrixType::Scalar Scalar;
244 typedef typename MatrixType::RealScalar RealScalar;
245 typedef typename MatrixType::ColXpr ColXpr;
246 typedef typename internal::remove_all<ColXpr>::type ColXprCleaned;
247 typedef typename ColXprCleaned::SegmentReturnType ColXprSegment;
248 typedef Matrix<Scalar,Dynamic,1> TempVectorType;
249 typedef typename TempVectorType::SegmentReturnType TempVecSegment;
251 Index n = mat.cols();
252 eigen_assert(mat.rows()==n && vec.size()==n);
261 temp = sqrt(sigma) * vec;
263 for(
Index i=0; i<n; ++i)
265 JacobiRotation<Scalar> g;
266 g.makeGivens(mat(i,i), -temp(i), &mat(i,i));
271 ColXprSegment x(mat.col(i).tail(rs));
272 TempVecSegment y(temp.tail(rs));
273 apply_rotation_in_the_plane(x, y, g);
281 for(
Index j=0; j<n; ++j)
283 RealScalar Ljj = numext::real(mat.coeff(j,j));
284 RealScalar dj = numext::abs2(Ljj);
285 Scalar wj = temp.coeff(j);
286 RealScalar swj2 = sigma*numext::abs2(wj);
287 RealScalar gamma = dj*beta + swj2;
289 RealScalar x = dj + swj2/beta;
290 if (x<=RealScalar(0))
292 RealScalar nLjj = sqrt(x);
293 mat.coeffRef(j,j) = nLjj;
300 temp.tail(rs) -= (wj/Ljj) * mat.col(j).tail(rs);
302 mat.col(j).tail(rs) = (nLjj/Ljj) * mat.col(j).tail(rs) + (nLjj * sigma*numext::conj(wj)/gamma)*temp.tail(rs);
309template<
typename Scalar>
struct llt_inplace<Scalar,
Lower>
311 typedef typename NumTraits<Scalar>::Real RealScalar;
312 template<
typename MatrixType>
313 static Index unblocked(MatrixType& mat)
317 eigen_assert(mat.rows()==mat.cols());
318 const Index size = mat.rows();
319 for(
Index k = 0; k < size; ++k)
323 Block<MatrixType,Dynamic,1> A21(mat,k+1,k,rs,1);
324 Block<MatrixType,1,Dynamic> A10(mat,k,0,1,k);
325 Block<MatrixType,Dynamic,Dynamic> A20(mat,k+1,0,rs,k);
327 RealScalar x = numext::real(mat.coeff(k,k));
328 if (k>0) x -= A10.squaredNorm();
329 if (x<=RealScalar(0))
331 mat.coeffRef(k,k) = x = sqrt(x);
332 if (k>0 && rs>0) A21.noalias() -= A20 * A10.adjoint();
338 template<
typename MatrixType>
339 static Index blocked(MatrixType& m)
341 eigen_assert(m.rows()==m.cols());
342 Index size = m.rows();
346 Index blockSize = size/8;
347 blockSize = (blockSize/16)*16;
348 blockSize = (std::min)((std::max)(blockSize,
Index(8)),
Index(128));
350 for (
Index k=0; k<size; k+=blockSize)
356 Index bs = (std::min)(blockSize, size-k);
357 Index rs = size - k - bs;
363 if((ret=unblocked(A11))>=0)
return k+ret;
364 if(rs>0) A11.adjoint().template triangularView<Upper>().template solveInPlace<OnTheRight>(A21);
370 template<
typename MatrixType,
typename VectorType>
371 static Index rankUpdate(MatrixType& mat,
const VectorType& vec,
const RealScalar& sigma)
373 return Eigen::internal::llt_rank_update_lower(mat, vec, sigma);
377template<
typename Scalar>
struct llt_inplace<Scalar,
Upper>
379 typedef typename NumTraits<Scalar>::Real RealScalar;
381 template<
typename MatrixType>
382 static EIGEN_STRONG_INLINE
Index unblocked(MatrixType& mat)
384 Transpose<MatrixType> matt(mat);
385 return llt_inplace<Scalar, Lower>::unblocked(matt);
387 template<
typename MatrixType>
388 static EIGEN_STRONG_INLINE
Index blocked(MatrixType& mat)
390 Transpose<MatrixType> matt(mat);
391 return llt_inplace<Scalar, Lower>::blocked(matt);
393 template<
typename MatrixType,
typename VectorType>
394 static Index rankUpdate(MatrixType& mat,
const VectorType& vec,
const RealScalar& sigma)
396 Transpose<MatrixType> matt(mat);
397 return llt_inplace<Scalar, Lower>::rankUpdate(matt, vec.conjugate(), sigma);
401template<
typename MatrixType>
struct LLT_Traits<MatrixType,
Lower>
403 typedef const TriangularView<const MatrixType, Lower> MatrixL;
404 typedef const TriangularView<const typename MatrixType::AdjointReturnType, Upper> MatrixU;
405 static inline MatrixL getL(
const MatrixType& m) {
return MatrixL(m); }
406 static inline MatrixU getU(
const MatrixType& m) {
return MatrixU(m.adjoint()); }
407 static bool inplace_decomposition(MatrixType& m)
408 {
return llt_inplace<typename MatrixType::Scalar, Lower>::blocked(m)==-1; }
411template<
typename MatrixType>
struct LLT_Traits<MatrixType,
Upper>
413 typedef const TriangularView<const typename MatrixType::AdjointReturnType, Lower> MatrixL;
414 typedef const TriangularView<const MatrixType, Upper> MatrixU;
415 static inline MatrixL getL(
const MatrixType& m) {
return MatrixL(m.adjoint()); }
416 static inline MatrixU getU(
const MatrixType& m) {
return MatrixU(m); }
417 static bool inplace_decomposition(MatrixType& m)
418 {
return llt_inplace<typename MatrixType::Scalar, Upper>::blocked(m)==-1; }
430template<
typename MatrixType,
int _UpLo>
431template<
typename InputType>
434 check_template_parameters();
438 m_matrix.resize(size, size);
439 if (!internal::is_same_dense(m_matrix, a.
derived()))
443 m_l1_norm = RealScalar(0);
445 for (
Index col = 0; col < size; ++col) {
446 RealScalar abs_col_sum;
448 abs_col_sum = m_matrix.col(col).tail(size - col).template lpNorm<1>() + m_matrix.row(col).head(col).template lpNorm<1>();
450 abs_col_sum = m_matrix.col(col).head(col).template lpNorm<1>() + m_matrix.row(col).tail(size - col).template lpNorm<1>();
451 if (abs_col_sum > m_l1_norm)
452 m_l1_norm = abs_col_sum;
455 m_isInitialized =
true;
456 bool ok = Traits::inplace_decomposition(m_matrix);
467template<
typename _MatrixType,
int _UpLo>
468template<
typename VectorType>
471 EIGEN_STATIC_ASSERT_VECTOR_ONLY(VectorType);
472 eigen_assert(v.size()==m_matrix.cols());
473 eigen_assert(m_isInitialized);
474 if(internal::llt_inplace<typename MatrixType::Scalar, UpLo>::rankUpdate(m_matrix,v,sigma)>=0)
482#ifndef EIGEN_PARSED_BY_DOXYGEN
483template<
typename _MatrixType,
int _UpLo>
484template<
typename RhsType,
typename DstType>
487 _solve_impl_transposed<true>(rhs, dst);
490template<
typename _MatrixType,
int _UpLo>
491template<
bool Conjugate,
typename RhsType,
typename DstType>
492void LLT<_MatrixType,_UpLo>::_solve_impl_transposed(
const RhsType &rhs, DstType &dst)
const
496 matrixL().template conjugateIf<!Conjugate>().solveInPlace(dst);
497 matrixU().template conjugateIf<!Conjugate>().solveInPlace(dst);
514template<
typename MatrixType,
int _UpLo>
515template<
typename Derived>
516void LLT<MatrixType,_UpLo>::solveInPlace(
const MatrixBase<Derived> &bAndX)
const
518 eigen_assert(m_isInitialized &&
"LLT is not initialized.");
519 eigen_assert(m_matrix.rows()==bAndX.rows());
520 matrixL().solveInPlace(bAndX);
521 matrixU().solveInPlace(bAndX);
527template<
typename MatrixType,
int _UpLo>
530 eigen_assert(m_isInitialized &&
"LLT is not initialized.");
531 return matrixL() * matrixL().adjoint().toDenseMatrix();
538template<
typename Derived>
549template<
typename MatrixType,
unsigned int UpLo>
Expression of a fixed-size or dynamic-size block.
Definition: Block.h:105
Standard Cholesky decomposition (LL^T) of a matrix and associated features.
Definition: LLT.h:68
LLT()
Default Constructor.
Definition: LLT.h:93
LLT(EigenBase< InputType > &matrix)
Constructs a LLT factorization from a given matrix.
Definition: LLT.h:120
Traits::MatrixU matrixU() const
Definition: LLT.h:128
const Solve< LLT, Rhs > solve(const MatrixBase< Rhs > &b) const
RealScalar rcond() const
Definition: LLT.h:166
const MatrixType & matrixLLT() const
Definition: LLT.h:177
Traits::MatrixL matrixL() const
Definition: LLT.h:135
const LLT & adjoint() const EIGEN_NOEXCEPT
Definition: LLT.h:202
MatrixType reconstructedMatrix() const
Definition: LLT.h:528
LLT(Index size)
Default Constructor with memory preallocation.
Definition: LLT.h:101
ComputationInfo info() const
Reports whether previous computation was successful.
Definition: LLT.h:191
Base class for all dense matrices, vectors, and expressions.
Definition: MatrixBase.h:50
Expression of a selfadjoint matrix from a triangular part of a dense matrix.
Definition: SelfAdjointView.h:51
Pseudo expression representing a solving operation.
Definition: Solve.h:63
A base class for matrix decomposition and solvers.
Definition: SolverBase.h:69
LLT< _MatrixType, _UpLo > & derived()
Definition: EigenBase.h:46
ComputationInfo
Definition: Constants.h:440
@ Lower
Definition: Constants.h:209
@ Upper
Definition: Constants.h:211
@ NumericalIssue
Definition: Constants.h:444
@ Success
Definition: Constants.h:442
Namespace containing all symbols from the Eigen library.
Definition: Core:141
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:74
Definition: EigenBase.h:30
EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT
Definition: EigenBase.h:63
Eigen::Index Index
The interface type of indices.
Definition: EigenBase.h:39
Derived & derived()
Definition: EigenBase.h:46
EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT
Definition: EigenBase.h:60
EIGEN_CONSTEXPR Index size() const EIGEN_NOEXCEPT
Definition: EigenBase.h:67
Holds information about the various numeric (i.e. scalar) types allowed by Eigen.
Definition: NumTraits.h:233