1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
5 //
6 // This Source Code Form is subject to the terms of the Mozilla
7 // Public License v. 2.0. If a copy of the MPL was not distributed
8 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
9
10 #ifndef EIGEN_LLT_H
11 #define EIGEN_LLT_H
12
13 namespace Eigen {
14
15 namespace internal{
16 template<typename MatrixType, int UpLo> struct LLT_Traits;
17 }
18
19 /** \ingroup Cholesky_Module
20 *
21 * \class LLT
22 *
23 * \brief Standard Cholesky decomposition (LL^T) of a matrix and associated features
24 *
25 * \param MatrixType the type of the matrix of which we are computing the LL^T Cholesky decomposition
26 * \param UpLo the triangular part that will be used for the decompositon: Lower (default) or Upper.
27 * The other triangular part won't be read.
28 *
29 * This class performs a LL^T Cholesky decomposition of a symmetric, positive definite
30 * matrix A such that A = LL^* = U^*U, where L is lower triangular.
31 *
32 * While the Cholesky decomposition is particularly useful to solve selfadjoint problems like D^*D x = b,
33 * for that purpose, we recommend the Cholesky decomposition without square root which is more stable
34 * and even faster. Nevertheless, this standard Cholesky decomposition remains useful in many other
35 * situations like generalised eigen problems with hermitian matrices.
36 *
37 * Remember that Cholesky decompositions are not rank-revealing. This LLT decomposition is only stable on positive definite matrices,
38 * use LDLT instead for the semidefinite case. Also, do not use a Cholesky decomposition to determine whether a system of equations
39 * has a solution.
40 *
41 * Example: \include LLT_example.cpp
42 * Output: \verbinclude LLT_example.out
43 *
44 * \sa MatrixBase::llt(), class LDLT
45 */
46 /* HEY THIS DOX IS DISABLED BECAUSE THERE's A BUG EITHER HERE OR IN LDLT ABOUT THAT (OR BOTH)
47 * Note that during the decomposition, only the upper triangular part of A is considered. Therefore,
48 * the strict lower part does not have to store correct values.
49 */
50 template<typename _MatrixType, int _UpLo> class LLT
51 {
52 public:
53 typedef _MatrixType MatrixType;
54 enum {
55 RowsAtCompileTime = MatrixType::RowsAtCompileTime,
56 ColsAtCompileTime = MatrixType::ColsAtCompileTime,
57 Options = MatrixType::Options,
58 MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
59 };
60 typedef typename MatrixType::Scalar Scalar;
61 typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
62 typedef typename MatrixType::Index Index;
63
64 enum {
65 PacketSize = internal::packet_traits<Scalar>::size,
66 AlignmentMask = int(PacketSize)-1,
67 UpLo = _UpLo
68 };
69
70 typedef internal::LLT_Traits<MatrixType,UpLo> Traits;
71
72 /**
73 * \brief Default Constructor.
74 *
75 * The default constructor is useful in cases in which the user intends to
76 * perform decompositions via LLT::compute(const MatrixType&).
77 */
LLT()78 LLT() : m_matrix(), m_isInitialized(false) {}
79
80 /** \brief Default Constructor with memory preallocation
81 *
82 * Like the default constructor but with preallocation of the internal data
83 * according to the specified problem \a size.
84 * \sa LLT()
85 */
LLT(Index size)86 LLT(Index size) : m_matrix(size, size),
87 m_isInitialized(false) {}
88
LLT(const MatrixType & matrix)89 LLT(const MatrixType& matrix)
90 : m_matrix(matrix.rows(), matrix.cols()),
91 m_isInitialized(false)
92 {
93 compute(matrix);
94 }
95
96 /** \returns a view of the upper triangular matrix U */
matrixU()97 inline typename Traits::MatrixU matrixU() const
98 {
99 eigen_assert(m_isInitialized && "LLT is not initialized.");
100 return Traits::getU(m_matrix);
101 }
102
103 /** \returns a view of the lower triangular matrix L */
matrixL()104 inline typename Traits::MatrixL matrixL() const
105 {
106 eigen_assert(m_isInitialized && "LLT is not initialized.");
107 return Traits::getL(m_matrix);
108 }
109
110 /** \returns the solution x of \f$ A x = b \f$ using the current decomposition of A.
111 *
112 * Since this LLT class assumes anyway that the matrix A is invertible, the solution
113 * theoretically exists and is unique regardless of b.
114 *
115 * Example: \include LLT_solve.cpp
116 * Output: \verbinclude LLT_solve.out
117 *
118 * \sa solveInPlace(), MatrixBase::llt()
119 */
120 template<typename Rhs>
121 inline const internal::solve_retval<LLT, Rhs>
solve(const MatrixBase<Rhs> & b)122 solve(const MatrixBase<Rhs>& b) const
123 {
124 eigen_assert(m_isInitialized && "LLT is not initialized.");
125 eigen_assert(m_matrix.rows()==b.rows()
126 && "LLT::solve(): invalid number of rows of the right hand side matrix b");
127 return internal::solve_retval<LLT, Rhs>(*this, b.derived());
128 }
129
130 #ifdef EIGEN2_SUPPORT
131 template<typename OtherDerived, typename ResultType>
solve(const MatrixBase<OtherDerived> & b,ResultType * result)132 bool solve(const MatrixBase<OtherDerived>& b, ResultType *result) const
133 {
134 *result = this->solve(b);
135 return true;
136 }
137
isPositiveDefinite()138 bool isPositiveDefinite() const { return true; }
139 #endif
140
141 template<typename Derived>
142 void solveInPlace(MatrixBase<Derived> &bAndX) const;
143
144 LLT& compute(const MatrixType& matrix);
145
146 /** \returns the LLT decomposition matrix
147 *
148 * TODO: document the storage layout
149 */
matrixLLT()150 inline const MatrixType& matrixLLT() const
151 {
152 eigen_assert(m_isInitialized && "LLT is not initialized.");
153 return m_matrix;
154 }
155
156 MatrixType reconstructedMatrix() const;
157
158
159 /** \brief Reports whether previous computation was successful.
160 *
161 * \returns \c Success if computation was succesful,
162 * \c NumericalIssue if the matrix.appears to be negative.
163 */
info()164 ComputationInfo info() const
165 {
166 eigen_assert(m_isInitialized && "LLT is not initialized.");
167 return m_info;
168 }
169
rows()170 inline Index rows() const { return m_matrix.rows(); }
cols()171 inline Index cols() const { return m_matrix.cols(); }
172
173 template<typename VectorType>
174 LLT rankUpdate(const VectorType& vec, const RealScalar& sigma = 1);
175
176 protected:
177
check_template_parameters()178 static void check_template_parameters()
179 {
180 EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
181 }
182
183 /** \internal
184 * Used to compute and store L
185 * The strict upper part is not used and even not initialized.
186 */
187 MatrixType m_matrix;
188 bool m_isInitialized;
189 ComputationInfo m_info;
190 };
191
192 namespace internal {
193
194 template<typename Scalar, int UpLo> struct llt_inplace;
195
196 template<typename MatrixType, typename VectorType>
llt_rank_update_lower(MatrixType & mat,const VectorType & vec,const typename MatrixType::RealScalar & sigma)197 static typename MatrixType::Index llt_rank_update_lower(MatrixType& mat, const VectorType& vec, const typename MatrixType::RealScalar& sigma)
198 {
199 using std::sqrt;
200 typedef typename MatrixType::Scalar Scalar;
201 typedef typename MatrixType::RealScalar RealScalar;
202 typedef typename MatrixType::Index Index;
203 typedef typename MatrixType::ColXpr ColXpr;
204 typedef typename internal::remove_all<ColXpr>::type ColXprCleaned;
205 typedef typename ColXprCleaned::SegmentReturnType ColXprSegment;
206 typedef Matrix<Scalar,Dynamic,1> TempVectorType;
207 typedef typename TempVectorType::SegmentReturnType TempVecSegment;
208
209 Index n = mat.cols();
210 eigen_assert(mat.rows()==n && vec.size()==n);
211
212 TempVectorType temp;
213
214 if(sigma>0)
215 {
216 // This version is based on Givens rotations.
217 // It is faster than the other one below, but only works for updates,
218 // i.e., for sigma > 0
219 temp = sqrt(sigma) * vec;
220
221 for(Index i=0; i<n; ++i)
222 {
223 JacobiRotation<Scalar> g;
224 g.makeGivens(mat(i,i), -temp(i), &mat(i,i));
225
226 Index rs = n-i-1;
227 if(rs>0)
228 {
229 ColXprSegment x(mat.col(i).tail(rs));
230 TempVecSegment y(temp.tail(rs));
231 apply_rotation_in_the_plane(x, y, g);
232 }
233 }
234 }
235 else
236 {
237 temp = vec;
238 RealScalar beta = 1;
239 for(Index j=0; j<n; ++j)
240 {
241 RealScalar Ljj = numext::real(mat.coeff(j,j));
242 RealScalar dj = numext::abs2(Ljj);
243 Scalar wj = temp.coeff(j);
244 RealScalar swj2 = sigma*numext::abs2(wj);
245 RealScalar gamma = dj*beta + swj2;
246
247 RealScalar x = dj + swj2/beta;
248 if (x<=RealScalar(0))
249 return j;
250 RealScalar nLjj = sqrt(x);
251 mat.coeffRef(j,j) = nLjj;
252 beta += swj2/dj;
253
254 // Update the terms of L
255 Index rs = n-j-1;
256 if(rs)
257 {
258 temp.tail(rs) -= (wj/Ljj) * mat.col(j).tail(rs);
259 if(gamma != 0)
260 mat.col(j).tail(rs) = (nLjj/Ljj) * mat.col(j).tail(rs) + (nLjj * sigma*numext::conj(wj)/gamma)*temp.tail(rs);
261 }
262 }
263 }
264 return -1;
265 }
266
267 template<typename Scalar> struct llt_inplace<Scalar, Lower>
268 {
269 typedef typename NumTraits<Scalar>::Real RealScalar;
270 template<typename MatrixType>
271 static typename MatrixType::Index unblocked(MatrixType& mat)
272 {
273 using std::sqrt;
274 typedef typename MatrixType::Index Index;
275
276 eigen_assert(mat.rows()==mat.cols());
277 const Index size = mat.rows();
278 for(Index k = 0; k < size; ++k)
279 {
280 Index rs = size-k-1; // remaining size
281
282 Block<MatrixType,Dynamic,1> A21(mat,k+1,k,rs,1);
283 Block<MatrixType,1,Dynamic> A10(mat,k,0,1,k);
284 Block<MatrixType,Dynamic,Dynamic> A20(mat,k+1,0,rs,k);
285
286 RealScalar x = numext::real(mat.coeff(k,k));
287 if (k>0) x -= A10.squaredNorm();
288 if (x<=RealScalar(0))
289 return k;
290 mat.coeffRef(k,k) = x = sqrt(x);
291 if (k>0 && rs>0) A21.noalias() -= A20 * A10.adjoint();
292 if (rs>0) A21 *= RealScalar(1)/x;
293 }
294 return -1;
295 }
296
297 template<typename MatrixType>
298 static typename MatrixType::Index blocked(MatrixType& m)
299 {
300 typedef typename MatrixType::Index Index;
301 eigen_assert(m.rows()==m.cols());
302 Index size = m.rows();
303 if(size<32)
304 return unblocked(m);
305
306 Index blockSize = size/8;
307 blockSize = (blockSize/16)*16;
308 blockSize = (std::min)((std::max)(blockSize,Index(8)), Index(128));
309
310 for (Index k=0; k<size; k+=blockSize)
311 {
312 // partition the matrix:
313 // A00 | - | -
314 // lu = A10 | A11 | -
315 // A20 | A21 | A22
316 Index bs = (std::min)(blockSize, size-k);
317 Index rs = size - k - bs;
318 Block<MatrixType,Dynamic,Dynamic> A11(m,k, k, bs,bs);
319 Block<MatrixType,Dynamic,Dynamic> A21(m,k+bs,k, rs,bs);
320 Block<MatrixType,Dynamic,Dynamic> A22(m,k+bs,k+bs,rs,rs);
321
322 Index ret;
323 if((ret=unblocked(A11))>=0) return k+ret;
324 if(rs>0) A11.adjoint().template triangularView<Upper>().template solveInPlace<OnTheRight>(A21);
325 if(rs>0) A22.template selfadjointView<Lower>().rankUpdate(A21,-1); // bottleneck
326 }
327 return -1;
328 }
329
330 template<typename MatrixType, typename VectorType>
331 static typename MatrixType::Index rankUpdate(MatrixType& mat, const VectorType& vec, const RealScalar& sigma)
332 {
333 return Eigen::internal::llt_rank_update_lower(mat, vec, sigma);
334 }
335 };
336
337 template<typename Scalar> struct llt_inplace<Scalar, Upper>
338 {
339 typedef typename NumTraits<Scalar>::Real RealScalar;
340
341 template<typename MatrixType>
342 static EIGEN_STRONG_INLINE typename MatrixType::Index unblocked(MatrixType& mat)
343 {
344 Transpose<MatrixType> matt(mat);
345 return llt_inplace<Scalar, Lower>::unblocked(matt);
346 }
347 template<typename MatrixType>
348 static EIGEN_STRONG_INLINE typename MatrixType::Index blocked(MatrixType& mat)
349 {
350 Transpose<MatrixType> matt(mat);
351 return llt_inplace<Scalar, Lower>::blocked(matt);
352 }
353 template<typename MatrixType, typename VectorType>
354 static typename MatrixType::Index rankUpdate(MatrixType& mat, const VectorType& vec, const RealScalar& sigma)
355 {
356 Transpose<MatrixType> matt(mat);
357 return llt_inplace<Scalar, Lower>::rankUpdate(matt, vec.conjugate(), sigma);
358 }
359 };
360
361 template<typename MatrixType> struct LLT_Traits<MatrixType,Lower>
362 {
363 typedef const TriangularView<const MatrixType, Lower> MatrixL;
364 typedef const TriangularView<const typename MatrixType::AdjointReturnType, Upper> MatrixU;
365 static inline MatrixL getL(const MatrixType& m) { return m; }
366 static inline MatrixU getU(const MatrixType& m) { return m.adjoint(); }
367 static bool inplace_decomposition(MatrixType& m)
368 { return llt_inplace<typename MatrixType::Scalar, Lower>::blocked(m)==-1; }
369 };
370
371 template<typename MatrixType> struct LLT_Traits<MatrixType,Upper>
372 {
373 typedef const TriangularView<const typename MatrixType::AdjointReturnType, Lower> MatrixL;
374 typedef const TriangularView<const MatrixType, Upper> MatrixU;
375 static inline MatrixL getL(const MatrixType& m) { return m.adjoint(); }
376 static inline MatrixU getU(const MatrixType& m) { return m; }
377 static bool inplace_decomposition(MatrixType& m)
378 { return llt_inplace<typename MatrixType::Scalar, Upper>::blocked(m)==-1; }
379 };
380
381 } // end namespace internal
382
383 /** Computes / recomputes the Cholesky decomposition A = LL^* = U^*U of \a matrix
384 *
385 * \returns a reference to *this
386 *
387 * Example: \include TutorialLinAlgComputeTwice.cpp
388 * Output: \verbinclude TutorialLinAlgComputeTwice.out
389 */
390 template<typename MatrixType, int _UpLo>
391 LLT<MatrixType,_UpLo>& LLT<MatrixType,_UpLo>::compute(const MatrixType& a)
392 {
393 check_template_parameters();
394
395 eigen_assert(a.rows()==a.cols());
396 const Index size = a.rows();
397 m_matrix.resize(size, size);
398 m_matrix = a;
399
400 m_isInitialized = true;
401 bool ok = Traits::inplace_decomposition(m_matrix);
402 m_info = ok ? Success : NumericalIssue;
403
404 return *this;
405 }
406
407 /** Performs a rank one update (or dowdate) of the current decomposition.
408 * If A = LL^* before the rank one update,
409 * then after it we have LL^* = A + sigma * v v^* where \a v must be a vector
410 * of same dimension.
411 */
412 template<typename _MatrixType, int _UpLo>
413 template<typename VectorType>
414 LLT<_MatrixType,_UpLo> LLT<_MatrixType,_UpLo>::rankUpdate(const VectorType& v, const RealScalar& sigma)
415 {
416 EIGEN_STATIC_ASSERT_VECTOR_ONLY(VectorType);
417 eigen_assert(v.size()==m_matrix.cols());
418 eigen_assert(m_isInitialized);
419 if(internal::llt_inplace<typename MatrixType::Scalar, UpLo>::rankUpdate(m_matrix,v,sigma)>=0)
420 m_info = NumericalIssue;
421 else
422 m_info = Success;
423
424 return *this;
425 }
426
427 namespace internal {
428 template<typename _MatrixType, int UpLo, typename Rhs>
429 struct solve_retval<LLT<_MatrixType, UpLo>, Rhs>
430 : solve_retval_base<LLT<_MatrixType, UpLo>, Rhs>
431 {
432 typedef LLT<_MatrixType,UpLo> LLTType;
433 EIGEN_MAKE_SOLVE_HELPERS(LLTType,Rhs)
434
435 template<typename Dest> void evalTo(Dest& dst) const
436 {
437 dst = rhs();
438 dec().solveInPlace(dst);
439 }
440 };
441 }
442
443 /** \internal use x = llt_object.solve(x);
444 *
445 * This is the \em in-place version of solve().
446 *
447 * \param bAndX represents both the right-hand side matrix b and result x.
448 *
449 * \returns true always! If you need to check for existence of solutions, use another decomposition like LU, QR, or SVD.
450 *
451 * This version avoids a copy when the right hand side matrix b is not
452 * needed anymore.
453 *
454 * \sa LLT::solve(), MatrixBase::llt()
455 */
456 template<typename MatrixType, int _UpLo>
457 template<typename Derived>
458 void LLT<MatrixType,_UpLo>::solveInPlace(MatrixBase<Derived> &bAndX) const
459 {
460 eigen_assert(m_isInitialized && "LLT is not initialized.");
461 eigen_assert(m_matrix.rows()==bAndX.rows());
462 matrixL().solveInPlace(bAndX);
463 matrixU().solveInPlace(bAndX);
464 }
465
466 /** \returns the matrix represented by the decomposition,
467 * i.e., it returns the product: L L^*.
468 * This function is provided for debug purpose. */
469 template<typename MatrixType, int _UpLo>
470 MatrixType LLT<MatrixType,_UpLo>::reconstructedMatrix() const
471 {
472 eigen_assert(m_isInitialized && "LLT is not initialized.");
473 return matrixL() * matrixL().adjoint().toDenseMatrix();
474 }
475
476 /** \cholesky_module
477 * \returns the LLT decomposition of \c *this
478 */
479 template<typename Derived>
480 inline const LLT<typename MatrixBase<Derived>::PlainObject>
481 MatrixBase<Derived>::llt() const
482 {
483 return LLT<PlainObject>(derived());
484 }
485
486 /** \cholesky_module
487 * \returns the LLT decomposition of \c *this
488 */
489 template<typename MatrixType, unsigned int UpLo>
490 inline const LLT<typename SelfAdjointView<MatrixType, UpLo>::PlainObject, UpLo>
491 SelfAdjointView<MatrixType, UpLo>::llt() const
492 {
493 return LLT<PlainObject,UpLo>(m_matrix);
494 }
495
496 } // end namespace Eigen
497
498 #endif // EIGEN_LLT_H
499