123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542 |
- // This file is part of Eigen, a lightweight C++ template library
- // for linear algebra.
- //
- // Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
- //
- // This Source Code Form is subject to the terms of the Mozilla
- // Public License v. 2.0. If a copy of the MPL was not distributed
- // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
- #ifndef EIGEN_LLT_H
- #define EIGEN_LLT_H
- namespace Eigen {
- namespace internal{
- template<typename MatrixType, int UpLo> struct LLT_Traits;
- }
- /** \ingroup Cholesky_Module
- *
- * \class LLT
- *
- * \brief Standard Cholesky decomposition (LL^T) of a matrix and associated features
- *
- * \tparam _MatrixType the type of the matrix of which we are computing the LL^T Cholesky decomposition
- * \tparam _UpLo the triangular part that will be used for the decompositon: Lower (default) or Upper.
- * The other triangular part won't be read.
- *
- * This class performs a LL^T Cholesky decomposition of a symmetric, positive definite
- * matrix A such that A = LL^* = U^*U, where L is lower triangular.
- *
- * While the Cholesky decomposition is particularly useful to solve selfadjoint problems like D^*D x = b,
- * for that purpose, we recommend the Cholesky decomposition without square root which is more stable
- * and even faster. Nevertheless, this standard Cholesky decomposition remains useful in many other
- * situations like generalised eigen problems with hermitian matrices.
- *
- * Remember that Cholesky decompositions are not rank-revealing. This LLT decomposition is only stable on positive definite matrices,
- * use LDLT instead for the semidefinite case. Also, do not use a Cholesky decomposition to determine whether a system of equations
- * has a solution.
- *
- * Example: \include LLT_example.cpp
- * Output: \verbinclude LLT_example.out
- *
- * \b Performance: for best performance, it is recommended to use a column-major storage format
- * with the Lower triangular part (the default), or, equivalently, a row-major storage format
- * with the Upper triangular part. Otherwise, you might get a 20% slowdown for the full factorization
- * step, and rank-updates can be up to 3 times slower.
- *
- * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
- *
- * Note that during the decomposition, only the lower (or upper, as defined by _UpLo) triangular part of A is considered.
- * Therefore, the strict lower part does not have to store correct values.
- *
- * \sa MatrixBase::llt(), SelfAdjointView::llt(), class LDLT
- */
- template<typename _MatrixType, int _UpLo> class LLT
- {
- public:
- typedef _MatrixType MatrixType;
- enum {
- RowsAtCompileTime = MatrixType::RowsAtCompileTime,
- ColsAtCompileTime = MatrixType::ColsAtCompileTime,
- MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
- };
- typedef typename MatrixType::Scalar Scalar;
- typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
- typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
- typedef typename MatrixType::StorageIndex StorageIndex;
- enum {
- PacketSize = internal::packet_traits<Scalar>::size,
- AlignmentMask = int(PacketSize)-1,
- UpLo = _UpLo
- };
- typedef internal::LLT_Traits<MatrixType,UpLo> Traits;
- /**
- * \brief Default Constructor.
- *
- * The default constructor is useful in cases in which the user intends to
- * perform decompositions via LLT::compute(const MatrixType&).
- */
- LLT() : m_matrix(), m_isInitialized(false) {}
- /** \brief Default Constructor with memory preallocation
- *
- * Like the default constructor but with preallocation of the internal data
- * according to the specified problem \a size.
- * \sa LLT()
- */
- explicit LLT(Index size) : m_matrix(size, size),
- m_isInitialized(false) {}
- template<typename InputType>
- explicit LLT(const EigenBase<InputType>& matrix)
- : m_matrix(matrix.rows(), matrix.cols()),
- m_isInitialized(false)
- {
- compute(matrix.derived());
- }
- /** \brief Constructs a LDLT factorization from a given matrix
- *
- * This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when
- * \c MatrixType is a Eigen::Ref.
- *
- * \sa LLT(const EigenBase&)
- */
- template<typename InputType>
- explicit LLT(EigenBase<InputType>& matrix)
- : m_matrix(matrix.derived()),
- m_isInitialized(false)
- {
- compute(matrix.derived());
- }
- /** \returns a view of the upper triangular matrix U */
- inline typename Traits::MatrixU matrixU() const
- {
- eigen_assert(m_isInitialized && "LLT is not initialized.");
- return Traits::getU(m_matrix);
- }
- /** \returns a view of the lower triangular matrix L */
- inline typename Traits::MatrixL matrixL() const
- {
- eigen_assert(m_isInitialized && "LLT is not initialized.");
- return Traits::getL(m_matrix);
- }
- /** \returns the solution x of \f$ A x = b \f$ using the current decomposition of A.
- *
- * Since this LLT class assumes anyway that the matrix A is invertible, the solution
- * theoretically exists and is unique regardless of b.
- *
- * Example: \include LLT_solve.cpp
- * Output: \verbinclude LLT_solve.out
- *
- * \sa solveInPlace(), MatrixBase::llt(), SelfAdjointView::llt()
- */
- template<typename Rhs>
- inline const Solve<LLT, Rhs>
- solve(const MatrixBase<Rhs>& b) const
- {
- eigen_assert(m_isInitialized && "LLT is not initialized.");
- eigen_assert(m_matrix.rows()==b.rows()
- && "LLT::solve(): invalid number of rows of the right hand side matrix b");
- return Solve<LLT, Rhs>(*this, b.derived());
- }
- template<typename Derived>
- void solveInPlace(const MatrixBase<Derived> &bAndX) const;
- template<typename InputType>
- LLT& compute(const EigenBase<InputType>& matrix);
- /** \returns an estimate of the reciprocal condition number of the matrix of
- * which \c *this is the Cholesky decomposition.
- */
- RealScalar rcond() const
- {
- eigen_assert(m_isInitialized && "LLT is not initialized.");
- eigen_assert(m_info == Success && "LLT failed because matrix appears to be negative");
- return internal::rcond_estimate_helper(m_l1_norm, *this);
- }
- /** \returns the LLT decomposition matrix
- *
- * TODO: document the storage layout
- */
- inline const MatrixType& matrixLLT() const
- {
- eigen_assert(m_isInitialized && "LLT is not initialized.");
- return m_matrix;
- }
- MatrixType reconstructedMatrix() const;
- /** \brief Reports whether previous computation was successful.
- *
- * \returns \c Success if computation was succesful,
- * \c NumericalIssue if the matrix.appears not to be positive definite.
- */
- ComputationInfo info() const
- {
- eigen_assert(m_isInitialized && "LLT is not initialized.");
- return m_info;
- }
- /** \returns the adjoint of \c *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:
- * \code x = decomposition.adjoint().solve(b) \endcode
- */
- const LLT& adjoint() const { return *this; };
- inline Index rows() const { return m_matrix.rows(); }
- inline Index cols() const { return m_matrix.cols(); }
- template<typename VectorType>
- LLT rankUpdate(const VectorType& vec, const RealScalar& sigma = 1);
- #ifndef EIGEN_PARSED_BY_DOXYGEN
- template<typename RhsType, typename DstType>
- EIGEN_DEVICE_FUNC
- void _solve_impl(const RhsType &rhs, DstType &dst) const;
- #endif
- protected:
- static void check_template_parameters()
- {
- EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
- }
- /** \internal
- * Used to compute and store L
- * The strict upper part is not used and even not initialized.
- */
- MatrixType m_matrix;
- RealScalar m_l1_norm;
- bool m_isInitialized;
- ComputationInfo m_info;
- };
- namespace internal {
- template<typename Scalar, int UpLo> struct llt_inplace;
- template<typename MatrixType, typename VectorType>
- static Index llt_rank_update_lower(MatrixType& mat, const VectorType& vec, const typename MatrixType::RealScalar& sigma)
- {
- using std::sqrt;
- typedef typename MatrixType::Scalar Scalar;
- typedef typename MatrixType::RealScalar RealScalar;
- typedef typename MatrixType::ColXpr ColXpr;
- typedef typename internal::remove_all<ColXpr>::type ColXprCleaned;
- typedef typename ColXprCleaned::SegmentReturnType ColXprSegment;
- typedef Matrix<Scalar,Dynamic,1> TempVectorType;
- typedef typename TempVectorType::SegmentReturnType TempVecSegment;
- Index n = mat.cols();
- eigen_assert(mat.rows()==n && vec.size()==n);
- TempVectorType temp;
- if(sigma>0)
- {
- // This version is based on Givens rotations.
- // It is faster than the other one below, but only works for updates,
- // i.e., for sigma > 0
- temp = sqrt(sigma) * vec;
- for(Index i=0; i<n; ++i)
- {
- JacobiRotation<Scalar> g;
- g.makeGivens(mat(i,i), -temp(i), &mat(i,i));
- Index rs = n-i-1;
- if(rs>0)
- {
- ColXprSegment x(mat.col(i).tail(rs));
- TempVecSegment y(temp.tail(rs));
- apply_rotation_in_the_plane(x, y, g);
- }
- }
- }
- else
- {
- temp = vec;
- RealScalar beta = 1;
- for(Index j=0; j<n; ++j)
- {
- RealScalar Ljj = numext::real(mat.coeff(j,j));
- RealScalar dj = numext::abs2(Ljj);
- Scalar wj = temp.coeff(j);
- RealScalar swj2 = sigma*numext::abs2(wj);
- RealScalar gamma = dj*beta + swj2;
- RealScalar x = dj + swj2/beta;
- if (x<=RealScalar(0))
- return j;
- RealScalar nLjj = sqrt(x);
- mat.coeffRef(j,j) = nLjj;
- beta += swj2/dj;
- // Update the terms of L
- Index rs = n-j-1;
- if(rs)
- {
- temp.tail(rs) -= (wj/Ljj) * mat.col(j).tail(rs);
- if(gamma != 0)
- mat.col(j).tail(rs) = (nLjj/Ljj) * mat.col(j).tail(rs) + (nLjj * sigma*numext::conj(wj)/gamma)*temp.tail(rs);
- }
- }
- }
- return -1;
- }
- template<typename Scalar> struct llt_inplace<Scalar, Lower>
- {
- typedef typename NumTraits<Scalar>::Real RealScalar;
- template<typename MatrixType>
- static Index unblocked(MatrixType& mat)
- {
- using std::sqrt;
- eigen_assert(mat.rows()==mat.cols());
- const Index size = mat.rows();
- for(Index k = 0; k < size; ++k)
- {
- Index rs = size-k-1; // remaining size
- Block<MatrixType,Dynamic,1> A21(mat,k+1,k,rs,1);
- Block<MatrixType,1,Dynamic> A10(mat,k,0,1,k);
- Block<MatrixType,Dynamic,Dynamic> A20(mat,k+1,0,rs,k);
- RealScalar x = numext::real(mat.coeff(k,k));
- if (k>0) x -= A10.squaredNorm();
- if (x<=RealScalar(0))
- return k;
- mat.coeffRef(k,k) = x = sqrt(x);
- if (k>0 && rs>0) A21.noalias() -= A20 * A10.adjoint();
- if (rs>0) A21 /= x;
- }
- return -1;
- }
- template<typename MatrixType>
- static Index blocked(MatrixType& m)
- {
- eigen_assert(m.rows()==m.cols());
- Index size = m.rows();
- if(size<32)
- return unblocked(m);
- Index blockSize = size/8;
- blockSize = (blockSize/16)*16;
- blockSize = (std::min)((std::max)(blockSize,Index(8)), Index(128));
- for (Index k=0; k<size; k+=blockSize)
- {
- // partition the matrix:
- // A00 | - | -
- // lu = A10 | A11 | -
- // A20 | A21 | A22
- Index bs = (std::min)(blockSize, size-k);
- Index rs = size - k - bs;
- Block<MatrixType,Dynamic,Dynamic> A11(m,k, k, bs,bs);
- Block<MatrixType,Dynamic,Dynamic> A21(m,k+bs,k, rs,bs);
- Block<MatrixType,Dynamic,Dynamic> A22(m,k+bs,k+bs,rs,rs);
- Index ret;
- if((ret=unblocked(A11))>=0) return k+ret;
- if(rs>0) A11.adjoint().template triangularView<Upper>().template solveInPlace<OnTheRight>(A21);
- if(rs>0) A22.template selfadjointView<Lower>().rankUpdate(A21,typename NumTraits<RealScalar>::Literal(-1)); // bottleneck
- }
- return -1;
- }
- template<typename MatrixType, typename VectorType>
- static Index rankUpdate(MatrixType& mat, const VectorType& vec, const RealScalar& sigma)
- {
- return Eigen::internal::llt_rank_update_lower(mat, vec, sigma);
- }
- };
- template<typename Scalar> struct llt_inplace<Scalar, Upper>
- {
- typedef typename NumTraits<Scalar>::Real RealScalar;
- template<typename MatrixType>
- static EIGEN_STRONG_INLINE Index unblocked(MatrixType& mat)
- {
- Transpose<MatrixType> matt(mat);
- return llt_inplace<Scalar, Lower>::unblocked(matt);
- }
- template<typename MatrixType>
- static EIGEN_STRONG_INLINE Index blocked(MatrixType& mat)
- {
- Transpose<MatrixType> matt(mat);
- return llt_inplace<Scalar, Lower>::blocked(matt);
- }
- template<typename MatrixType, typename VectorType>
- static Index rankUpdate(MatrixType& mat, const VectorType& vec, const RealScalar& sigma)
- {
- Transpose<MatrixType> matt(mat);
- return llt_inplace<Scalar, Lower>::rankUpdate(matt, vec.conjugate(), sigma);
- }
- };
- template<typename MatrixType> struct LLT_Traits<MatrixType,Lower>
- {
- typedef const TriangularView<const MatrixType, Lower> MatrixL;
- typedef const TriangularView<const typename MatrixType::AdjointReturnType, Upper> MatrixU;
- static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
- static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoint()); }
- static bool inplace_decomposition(MatrixType& m)
- { return llt_inplace<typename MatrixType::Scalar, Lower>::blocked(m)==-1; }
- };
- template<typename MatrixType> struct LLT_Traits<MatrixType,Upper>
- {
- typedef const TriangularView<const typename MatrixType::AdjointReturnType, Lower> MatrixL;
- typedef const TriangularView<const MatrixType, Upper> MatrixU;
- static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoint()); }
- static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); }
- static bool inplace_decomposition(MatrixType& m)
- { return llt_inplace<typename MatrixType::Scalar, Upper>::blocked(m)==-1; }
- };
- } // end namespace internal
- /** Computes / recomputes the Cholesky decomposition A = LL^* = U^*U of \a matrix
- *
- * \returns a reference to *this
- *
- * Example: \include TutorialLinAlgComputeTwice.cpp
- * Output: \verbinclude TutorialLinAlgComputeTwice.out
- */
- template<typename MatrixType, int _UpLo>
- template<typename InputType>
- LLT<MatrixType,_UpLo>& LLT<MatrixType,_UpLo>::compute(const EigenBase<InputType>& a)
- {
- check_template_parameters();
- eigen_assert(a.rows()==a.cols());
- const Index size = a.rows();
- m_matrix.resize(size, size);
- if (!internal::is_same_dense(m_matrix, a.derived()))
- 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_isInitialized = true;
- bool ok = Traits::inplace_decomposition(m_matrix);
- m_info = ok ? Success : NumericalIssue;
- return *this;
- }
- /** Performs a rank one update (or dowdate) of the current decomposition.
- * If A = LL^* before the rank one update,
- * then after it we have LL^* = A + sigma * v v^* where \a v must be a vector
- * of same dimension.
- */
- template<typename _MatrixType, int _UpLo>
- template<typename VectorType>
- LLT<_MatrixType,_UpLo> LLT<_MatrixType,_UpLo>::rankUpdate(const VectorType& v, const RealScalar& sigma)
- {
- EIGEN_STATIC_ASSERT_VECTOR_ONLY(VectorType);
- eigen_assert(v.size()==m_matrix.cols());
- eigen_assert(m_isInitialized);
- if(internal::llt_inplace<typename MatrixType::Scalar, UpLo>::rankUpdate(m_matrix,v,sigma)>=0)
- m_info = NumericalIssue;
- else
- m_info = Success;
- return *this;
- }
- #ifndef EIGEN_PARSED_BY_DOXYGEN
- template<typename _MatrixType,int _UpLo>
- template<typename RhsType, typename DstType>
- void LLT<_MatrixType,_UpLo>::_solve_impl(const RhsType &rhs, DstType &dst) const
- {
- dst = rhs;
- solveInPlace(dst);
- }
- #endif
- /** \internal use x = llt_object.solve(x);
- *
- * This is the \em in-place version of solve().
- *
- * \param bAndX represents both the right-hand side matrix b and result x.
- *
- * This version avoids a copy when the right hand side matrix b is not needed anymore.
- *
- * \warning The parameter is only marked 'const' to make the C++ compiler accept a temporary expression here.
- * This function will const_cast it, so constness isn't honored here.
- *
- * \sa LLT::solve(), MatrixBase::llt()
- */
- template<typename MatrixType, int _UpLo>
- template<typename Derived>
- void LLT<MatrixType,_UpLo>::solveInPlace(const MatrixBase<Derived> &bAndX) const
- {
- eigen_assert(m_isInitialized && "LLT is not initialized.");
- eigen_assert(m_matrix.rows()==bAndX.rows());
- matrixL().solveInPlace(bAndX);
- matrixU().solveInPlace(bAndX);
- }
- /** \returns the matrix represented by the decomposition,
- * i.e., it returns the product: L L^*.
- * This function is provided for debug purpose. */
- template<typename MatrixType, int _UpLo>
- MatrixType LLT<MatrixType,_UpLo>::reconstructedMatrix() const
- {
- eigen_assert(m_isInitialized && "LLT is not initialized.");
- return matrixL() * matrixL().adjoint().toDenseMatrix();
- }
- /** \cholesky_module
- * \returns the LLT decomposition of \c *this
- * \sa SelfAdjointView::llt()
- */
- template<typename Derived>
- inline const LLT<typename MatrixBase<Derived>::PlainObject>
- MatrixBase<Derived>::llt() const
- {
- return LLT<PlainObject>(derived());
- }
- /** \cholesky_module
- * \returns the LLT decomposition of \c *this
- * \sa SelfAdjointView::llt()
- */
- template<typename MatrixType, unsigned int UpLo>
- inline const LLT<typename SelfAdjointView<MatrixType, UpLo>::PlainObject, UpLo>
- SelfAdjointView<MatrixType, UpLo>::llt() const
- {
- return LLT<PlainObject,UpLo>(m_matrix);
- }
- } // end namespace Eigen
- #endif // EIGEN_LLT_H
|