16 template<
typename MatrixType,
int UpLo>
struct LLT_Traits;
56 template<
typename _MatrixType,
int _UpLo>
class LLT
59 typedef _MatrixType MatrixType;
61 RowsAtCompileTime = MatrixType::RowsAtCompileTime,
62 ColsAtCompileTime = MatrixType::ColsAtCompileTime,
63 MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
65 typedef typename MatrixType::Scalar Scalar;
68 typedef typename MatrixType::StorageIndex StorageIndex;
71 PacketSize = internal::packet_traits<Scalar>::size,
72 AlignmentMask = int(PacketSize)-1,
76 typedef internal::LLT_Traits<MatrixType,UpLo> Traits;
84 LLT() : m_matrix(), m_isInitialized(false) {}
92 explicit LLT(
Index size) : m_matrix(size, size),
93 m_isInitialized(false) {}
95 template<
typename InputType>
97 : m_matrix(matrix.rows(), matrix.cols()),
98 m_isInitialized(false)
110 template<
typename InputType>
112 : m_matrix(matrix.derived()),
113 m_isInitialized(false)
119 inline typename Traits::MatrixU
matrixU()
const
121 eigen_assert(m_isInitialized &&
"LLT is not initialized.");
122 return Traits::getU(m_matrix);
126 inline typename Traits::MatrixL
matrixL()
const
128 eigen_assert(m_isInitialized &&
"LLT is not initialized.");
129 return Traits::getL(m_matrix);
142 template<
typename Rhs>
146 eigen_assert(m_isInitialized &&
"LLT is not initialized.");
147 eigen_assert(m_matrix.rows()==b.
rows()
148 &&
"LLT::solve(): invalid number of rows of the right hand side matrix b");
152 template<
typename Derived>
155 template<
typename InputType>
163 eigen_assert(m_isInitialized &&
"LLT is not initialized.");
164 eigen_assert(m_info ==
Success &&
"LLT failed because matrix appears to be negative");
165 return internal::rcond_estimate_helper(m_l1_norm, *
this);
174 eigen_assert(m_isInitialized &&
"LLT is not initialized.");
188 eigen_assert(m_isInitialized &&
"LLT is not initialized.");
199 inline Index rows()
const {
return m_matrix.rows(); }
200 inline Index cols()
const {
return m_matrix.cols(); }
202 template<
typename VectorType>
203 LLT rankUpdate(
const VectorType& vec,
const RealScalar& sigma = 1);
205 #ifndef EIGEN_PARSED_BY_DOXYGEN
206 template<
typename RhsType,
typename DstType>
208 void _solve_impl(
const RhsType &rhs, DstType &dst)
const;
213 static void check_template_parameters()
215 EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
223 RealScalar m_l1_norm;
224 bool m_isInitialized;
230 template<
typename Scalar,
int UpLo>
struct llt_inplace;
232 template<
typename MatrixType,
typename VectorType>
233 static Index llt_rank_update_lower(MatrixType& mat,
const VectorType& vec,
const typename MatrixType::RealScalar& sigma)
236 typedef typename MatrixType::Scalar Scalar;
237 typedef typename MatrixType::RealScalar RealScalar;
238 typedef typename MatrixType::ColXpr ColXpr;
239 typedef typename internal::remove_all<ColXpr>::type ColXprCleaned;
240 typedef typename ColXprCleaned::SegmentReturnType ColXprSegment;
241 typedef Matrix<Scalar,Dynamic,1> TempVectorType;
242 typedef typename TempVectorType::SegmentReturnType TempVecSegment;
244 Index n = mat.cols();
245 eigen_assert(mat.rows()==n && vec.size()==n);
254 temp =
sqrt(sigma) * vec;
256 for(
Index i=0; i<n; ++i)
258 JacobiRotation<Scalar> g;
259 g.makeGivens(mat(i,i), -temp(i), &mat(i,i));
264 ColXprSegment x(mat.col(i).tail(rs));
265 TempVecSegment y(temp.tail(rs));
266 apply_rotation_in_the_plane(x, y, g);
274 for(
Index j=0; j<n; ++j)
276 RealScalar Ljj = numext::real(mat.coeff(j,j));
277 RealScalar dj = numext::abs2(Ljj);
278 Scalar wj = temp.coeff(j);
279 RealScalar swj2 = sigma*numext::abs2(wj);
280 RealScalar gamma = dj*beta + swj2;
282 RealScalar x = dj + swj2/beta;
283 if (x<=RealScalar(0))
285 RealScalar nLjj =
sqrt(x);
286 mat.coeffRef(j,j) = nLjj;
293 temp.tail(rs) -= (wj/Ljj) * mat.col(j).tail(rs);
295 mat.col(j).tail(rs) = (nLjj/Ljj) * mat.col(j).tail(rs) + (nLjj * sigma*numext::conj(wj)/gamma)*temp.tail(rs);
302 template<
typename Scalar>
struct llt_inplace<Scalar,
Lower>
304 typedef typename NumTraits<Scalar>::Real RealScalar;
305 template<
typename MatrixType>
306 static Index unblocked(MatrixType& mat)
310 eigen_assert(mat.rows()==mat.cols());
311 const Index size = mat.rows();
312 for(
Index k = 0; k < size; ++k)
316 Block<MatrixType,Dynamic,1> A21(mat,k+1,k,rs,1);
317 Block<MatrixType,1,Dynamic> A10(mat,k,0,1,k);
318 Block<MatrixType,Dynamic,Dynamic> A20(mat,k+1,0,rs,k);
320 RealScalar x = numext::real(mat.coeff(k,k));
321 if (k>0) x -= A10.squaredNorm();
322 if (x<=RealScalar(0))
324 mat.coeffRef(k,k) = x =
sqrt(x);
325 if (k>0 && rs>0) A21.noalias() -= A20 * A10.adjoint();
331 template<
typename MatrixType>
332 static Index blocked(MatrixType& m)
334 eigen_assert(m.rows()==m.cols());
335 Index size = m.rows();
339 Index blockSize = size/8;
340 blockSize = (blockSize/16)*16;
341 blockSize = (std::min)((std::max)(blockSize,
Index(8)),
Index(128));
343 for (
Index k=0; k<size; k+=blockSize)
349 Index bs = (std::min)(blockSize, size-k);
350 Index rs = size - k - bs;
356 if((ret=unblocked(A11))>=0)
return k+ret;
357 if(rs>0) A11.adjoint().template triangularView<Upper>().template solveInPlace<OnTheRight>(A21);
363 template<
typename MatrixType,
typename VectorType>
364 static Index rankUpdate(MatrixType& mat,
const VectorType& vec,
const RealScalar& sigma)
366 return Eigen::internal::llt_rank_update_lower(mat, vec, sigma);
370 template<
typename Scalar>
struct llt_inplace<Scalar,
Upper>
372 typedef typename NumTraits<Scalar>::Real RealScalar;
374 template<
typename MatrixType>
375 static EIGEN_STRONG_INLINE
Index unblocked(MatrixType& mat)
377 Transpose<MatrixType> matt(mat);
378 return llt_inplace<Scalar, Lower>::unblocked(matt);
380 template<
typename MatrixType>
381 static EIGEN_STRONG_INLINE
Index blocked(MatrixType& mat)
383 Transpose<MatrixType> matt(mat);
384 return llt_inplace<Scalar, Lower>::blocked(matt);
386 template<
typename MatrixType,
typename VectorType>
387 static Index rankUpdate(MatrixType& mat,
const VectorType& vec,
const RealScalar& sigma)
389 Transpose<MatrixType> matt(mat);
390 return llt_inplace<Scalar, Lower>::rankUpdate(matt, vec.conjugate(), sigma);
394 template<
typename MatrixType>
struct LLT_Traits<MatrixType,
Lower>
396 typedef const TriangularView<const MatrixType, Lower> MatrixL;
397 typedef const TriangularView<const typename MatrixType::AdjointReturnType, Upper> MatrixU;
398 static inline MatrixL getL(
const MatrixType& m) {
return MatrixL(m); }
399 static inline MatrixU getU(
const MatrixType& m) {
return MatrixU(m.adjoint()); }
400 static bool inplace_decomposition(MatrixType& m)
401 {
return llt_inplace<typename MatrixType::Scalar, Lower>::blocked(m)==-1; }
404 template<
typename MatrixType>
struct LLT_Traits<MatrixType,
Upper>
406 typedef const TriangularView<const typename MatrixType::AdjointReturnType, Lower> MatrixL;
407 typedef const TriangularView<const MatrixType, Upper> MatrixU;
408 static inline MatrixL getL(
const MatrixType& m) {
return MatrixL(m.adjoint()); }
409 static inline MatrixU getU(
const MatrixType& m) {
return MatrixU(m); }
410 static bool inplace_decomposition(MatrixType& m)
411 {
return llt_inplace<typename MatrixType::Scalar, Upper>::blocked(m)==-1; }
423 template<
typename MatrixType,
int _UpLo>
424 template<
typename InputType>
427 check_template_parameters();
431 m_matrix.resize(size, size);
432 if (!internal::is_same_dense(m_matrix, a.
derived()))
436 m_l1_norm = RealScalar(0);
438 for (
Index col = 0; col < size; ++col) {
439 RealScalar abs_col_sum;
441 abs_col_sum = m_matrix.col(col).tail(size - col).template lpNorm<1>() + m_matrix.row(col).head(col).template lpNorm<1>();
443 abs_col_sum = m_matrix.col(col).head(col).template lpNorm<1>() + m_matrix.row(col).tail(size - col).template lpNorm<1>();
444 if (abs_col_sum > m_l1_norm)
445 m_l1_norm = abs_col_sum;
448 m_isInitialized =
true;
449 bool ok = Traits::inplace_decomposition(m_matrix);
460 template<
typename _MatrixType,
int _UpLo>
461 template<
typename VectorType>
464 EIGEN_STATIC_ASSERT_VECTOR_ONLY(VectorType);
465 eigen_assert(v.size()==m_matrix.cols());
466 eigen_assert(m_isInitialized);
467 if(internal::llt_inplace<typename MatrixType::Scalar, UpLo>::rankUpdate(m_matrix,v,sigma)>=0)
475 #ifndef EIGEN_PARSED_BY_DOXYGEN
476 template<
typename _MatrixType,
int _UpLo>
477 template<
typename RhsType,
typename DstType>
498 template<
typename MatrixType,
int _UpLo>
499 template<
typename Derived>
500 void LLT<MatrixType,_UpLo>::solveInPlace(
const MatrixBase<Derived> &bAndX)
const
502 eigen_assert(m_isInitialized &&
"LLT is not initialized.");
503 eigen_assert(m_matrix.rows()==bAndX.rows());
504 matrixL().solveInPlace(bAndX);
505 matrixU().solveInPlace(bAndX);
511 template<
typename MatrixType,
int _UpLo>
514 eigen_assert(m_isInitialized &&
"LLT is not initialized.");
515 return matrixL() * matrixL().adjoint().toDenseMatrix();
522 template<
typename Derived>
533 template<
typename MatrixType,
unsigned int UpLo>
542 #endif // EIGEN_LLT_H