WPILibC++ 2023.4.3
LLT.h
Go to the documentation of this file.
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
13namespace Eigen {
14
15namespace internal{
16
17template<typename _MatrixType, int _UpLo> struct traits<LLT<_MatrixType, _UpLo> >
18 : traits<_MatrixType>
19{
22 typedef int StorageIndex;
23 enum { Flags = 0 };
24};
25
26template<typename MatrixType, int UpLo> struct LLT_Traits;
27}
28
29/** \ingroup Cholesky_Module
30 *
31 * \class LLT
32 *
33 * \brief Standard Cholesky decomposition (LL^T) of a matrix and associated features
34 *
35 * \tparam _MatrixType the type of the matrix of which we are computing the LL^T Cholesky decomposition
36 * \tparam _UpLo the triangular part that will be used for the decompositon: Lower (default) or Upper.
37 * The other triangular part won't be read.
38 *
39 * This class performs a LL^T Cholesky decomposition of a symmetric, positive definite
40 * matrix A such that A = LL^* = U^*U, where L is lower triangular.
41 *
42 * While the Cholesky decomposition is particularly useful to solve selfadjoint problems like D^*D x = b,
43 * for that purpose, we recommend the Cholesky decomposition without square root which is more stable
44 * and even faster. Nevertheless, this standard Cholesky decomposition remains useful in many other
45 * situations like generalised eigen problems with hermitian matrices.
46 *
47 * Remember that Cholesky decompositions are not rank-revealing. This LLT decomposition is only stable on positive definite matrices,
48 * use LDLT instead for the semidefinite case. Also, do not use a Cholesky decomposition to determine whether a system of equations
49 * has a solution.
50 *
51 * Example: \include LLT_example.cpp
52 * Output: \verbinclude LLT_example.out
53 *
54 * \b Performance: for best performance, it is recommended to use a column-major storage format
55 * with the Lower triangular part (the default), or, equivalently, a row-major storage format
56 * with the Upper triangular part. Otherwise, you might get a 20% slowdown for the full factorization
57 * step, and rank-updates can be up to 3 times slower.
58 *
59 * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
60 *
61 * Note that during the decomposition, only the lower (or upper, as defined by _UpLo) triangular part of A is considered.
62 * Therefore, the strict lower part does not have to store correct values.
63 *
64 * \sa MatrixBase::llt(), SelfAdjointView::llt(), class LDLT
65 */
66template<typename _MatrixType, int _UpLo> class LLT
67 : public SolverBase<LLT<_MatrixType, _UpLo> >
68{
69 public:
70 typedef _MatrixType MatrixType;
72 friend class SolverBase<LLT>;
73
75 enum {
76 MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
77 };
78
79 enum {
82 UpLo = _UpLo
83 };
84
86
87 /**
88 * \brief Default Constructor.
89 *
90 * The default constructor is useful in cases in which the user intends to
91 * perform decompositions via LLT::compute(const MatrixType&).
92 */
93 LLT() : m_matrix(), m_isInitialized(false) {}
94
95 /** \brief Default Constructor with memory preallocation
96 *
97 * Like the default constructor but with preallocation of the internal data
98 * according to the specified problem \a size.
99 * \sa LLT()
100 */
102 m_isInitialized(false) {}
103
104 template<typename InputType>
105 explicit LLT(const EigenBase<InputType>& matrix)
106 : m_matrix(matrix.rows(), matrix.cols()),
107 m_isInitialized(false)
108 {
109 compute(matrix.derived());
110 }
111
112 /** \brief Constructs a LLT factorization from a given matrix
113 *
114 * This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when
115 * \c MatrixType is a Eigen::Ref.
116 *
117 * \sa LLT(const EigenBase&)
118 */
119 template<typename InputType>
120 explicit LLT(EigenBase<InputType>& matrix)
121 : m_matrix(matrix.derived()),
122 m_isInitialized(false)
123 {
124 compute(matrix.derived());
125 }
126
127 /** \returns a view of the upper triangular matrix U */
128 inline typename Traits::MatrixU matrixU() const
129 {
130 eigen_assert(m_isInitialized && "LLT is not initialized.");
131 return Traits::getU(m_matrix);
132 }
133
134 /** \returns a view of the lower triangular matrix L */
135 inline typename Traits::MatrixL matrixL() const
136 {
137 eigen_assert(m_isInitialized && "LLT is not initialized.");
138 return Traits::getL(m_matrix);
139 }
140
141 #ifdef EIGEN_PARSED_BY_DOXYGEN
142 /** \returns the solution x of \f$ A x = b \f$ using the current decomposition of A.
143 *
144 * Since this LLT class assumes anyway that the matrix A is invertible, the solution
145 * theoretically exists and is unique regardless of b.
146 *
147 * Example: \include LLT_solve.cpp
148 * Output: \verbinclude LLT_solve.out
149 *
150 * \sa solveInPlace(), MatrixBase::llt(), SelfAdjointView::llt()
151 */
152 template<typename Rhs>
153 inline const Solve<LLT, Rhs>
154 solve(const MatrixBase<Rhs>& b) const;
155 #endif
156
157 template<typename Derived>
158 void solveInPlace(const MatrixBase<Derived> &bAndX) const;
159
160 template<typename InputType>
162
163 /** \returns an estimate of the reciprocal condition number of the matrix of
164 * which \c *this is the Cholesky decomposition.
165 */
166 RealScalar rcond() const
167 {
168 eigen_assert(m_isInitialized && "LLT is not initialized.");
169 eigen_assert(m_info == Success && "LLT failed because matrix appears to be negative");
171 }
172
173 /** \returns the LLT decomposition matrix
174 *
175 * TODO: document the storage layout
176 */
177 inline const MatrixType& matrixLLT() const
178 {
179 eigen_assert(m_isInitialized && "LLT is not initialized.");
180 return m_matrix;
181 }
182
184
185
186 /** \brief Reports whether previous computation was successful.
187 *
188 * \returns \c Success if computation was successful,
189 * \c NumericalIssue if the matrix.appears not to be positive definite.
190 */
192 {
193 eigen_assert(m_isInitialized && "LLT is not initialized.");
194 return m_info;
195 }
196
197 /** \returns the adjoint of \c *this, that is, a const reference to the decomposition itself as the underlying matrix is self-adjoint.
198 *
199 * This method is provided for compatibility with other matrix decompositions, thus enabling generic code such as:
200 * \code x = decomposition.adjoint().solve(b) \endcode
201 */
202 const LLT& adjoint() const EIGEN_NOEXCEPT { return *this; };
203
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(); }
206
207 template<typename VectorType>
208 LLT & rankUpdate(const VectorType& vec, const RealScalar& sigma = 1);
209
210 #ifndef EIGEN_PARSED_BY_DOXYGEN
211 template<typename RhsType, typename DstType>
212 void _solve_impl(const RhsType &rhs, DstType &dst) const;
213
214 template<bool Conjugate, typename RhsType, typename DstType>
215 void _solve_impl_transposed(const RhsType &rhs, DstType &dst) const;
216 #endif
217
218 protected:
219
221 {
223 }
224
225 /** \internal
226 * Used to compute and store L
227 * The strict upper part is not used and even not initialized.
228 */
230 RealScalar m_l1_norm;
233};
234
235namespace internal {
236
237template<typename Scalar, int UpLo> struct llt_inplace;
238
239template<typename MatrixType, typename VectorType>
240static Index llt_rank_update_lower(MatrixType& mat, const VectorType& vec, const typename MatrixType::RealScalar& sigma)
241{
242 using std::sqrt;
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;
250
251 Index n = mat.cols();
252 eigen_assert(mat.rows()==n && vec.size()==n);
253
254 TempVectorType temp;
255
256 if(sigma>0)
257 {
258 // This version is based on Givens rotations.
259 // It is faster than the other one below, but only works for updates,
260 // i.e., for sigma > 0
261 temp = sqrt(sigma) * vec;
262
263 for(Index i=0; i<n; ++i)
264 {
266 g.makeGivens(mat(i,i), -temp(i), &mat(i,i));
267
268 Index rs = n-i-1;
269 if(rs>0)
270 {
271 ColXprSegment x(mat.col(i).tail(rs));
272 TempVecSegment y(temp.tail(rs));
274 }
275 }
276 }
277 else
278 {
279 temp = vec;
280 RealScalar beta = 1;
281 for(Index j=0; j<n; ++j)
282 {
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;
288
289 RealScalar x = dj + swj2/beta;
290 if (x<=RealScalar(0))
291 return j;
292 RealScalar nLjj = sqrt(x);
293 mat.coeffRef(j,j) = nLjj;
294 beta += swj2/dj;
295
296 // Update the terms of L
297 Index rs = n-j-1;
298 if(rs)
299 {
300 temp.tail(rs) -= (wj/Ljj) * mat.col(j).tail(rs);
301 if(gamma != 0)
302 mat.col(j).tail(rs) = (nLjj/Ljj) * mat.col(j).tail(rs) + (nLjj * sigma*numext::conj(wj)/gamma)*temp.tail(rs);
303 }
304 }
305 }
306 return -1;
307}
308
309template<typename Scalar> struct llt_inplace<Scalar, Lower>
310{
312 template<typename MatrixType>
313 static Index unblocked(MatrixType& mat)
314 {
315 using std::sqrt;
316
317 eigen_assert(mat.rows()==mat.cols());
318 const Index size = mat.rows();
319 for(Index k = 0; k < size; ++k)
320 {
321 Index rs = size-k-1; // remaining size
322
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);
326
327 RealScalar x = numext::real(mat.coeff(k,k));
328 if (k>0) x -= A10.squaredNorm();
329 if (x<=RealScalar(0))
330 return k;
331 mat.coeffRef(k,k) = x = sqrt(x);
332 if (k>0 && rs>0) A21.noalias() -= A20 * A10.adjoint();
333 if (rs>0) A21 /= x;
334 }
335 return -1;
336 }
337
338 template<typename MatrixType>
339 static Index blocked(MatrixType& m)
340 {
341 eigen_assert(m.rows()==m.cols());
342 Index size = m.rows();
343 if(size<32)
344 return unblocked(m);
345
346 Index blockSize = size/8;
347 blockSize = (blockSize/16)*16;
348 blockSize = (std::min)((std::max)(blockSize,Index(8)), Index(128));
349
350 for (Index k=0; k<size; k+=blockSize)
351 {
352 // partition the matrix:
353 // A00 | - | -
354 // lu = A10 | A11 | -
355 // A20 | A21 | A22
356 Index bs = (std::min)(blockSize, size-k);
357 Index rs = size - k - bs;
358 Block<MatrixType,Dynamic,Dynamic> A11(m,k, k, bs,bs);
359 Block<MatrixType,Dynamic,Dynamic> A21(m,k+bs,k, rs,bs);
360 Block<MatrixType,Dynamic,Dynamic> A22(m,k+bs,k+bs,rs,rs);
361
362 Index ret;
363 if((ret=unblocked(A11))>=0) return k+ret;
364 if(rs>0) A11.adjoint().template triangularView<Upper>().template solveInPlace<OnTheRight>(A21);
365 if(rs>0) A22.template selfadjointView<Lower>().rankUpdate(A21,typename NumTraits<RealScalar>::Literal(-1)); // bottleneck
366 }
367 return -1;
368 }
369
370 template<typename MatrixType, typename VectorType>
371 static Index rankUpdate(MatrixType& mat, const VectorType& vec, const RealScalar& sigma)
372 {
374 }
375};
376
377template<typename Scalar> struct llt_inplace<Scalar, Upper>
378{
380
381 template<typename MatrixType>
382 static EIGEN_STRONG_INLINE Index unblocked(MatrixType& mat)
383 {
384 Transpose<MatrixType> matt(mat);
386 }
387 template<typename MatrixType>
388 static EIGEN_STRONG_INLINE Index blocked(MatrixType& mat)
389 {
390 Transpose<MatrixType> matt(mat);
392 }
393 template<typename MatrixType, typename VectorType>
394 static Index rankUpdate(MatrixType& mat, const VectorType& vec, const RealScalar& sigma)
395 {
396 Transpose<MatrixType> matt(mat);
397 return llt_inplace<Scalar, Lower>::rankUpdate(matt, vec.conjugate(), sigma);
398 }
399};
400
401template<typename MatrixType> struct LLT_Traits<MatrixType,Lower>
402{
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)
409};
410
411template<typename MatrixType> struct LLT_Traits<MatrixType,Upper>
412{
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)
419};
420
421} // end namespace internal
422
423/** Computes / recomputes the Cholesky decomposition A = LL^* = U^*U of \a matrix
424 *
425 * \returns a reference to *this
426 *
427 * Example: \include TutorialLinAlgComputeTwice.cpp
428 * Output: \verbinclude TutorialLinAlgComputeTwice.out
429 */
430template<typename MatrixType, int _UpLo>
431template<typename InputType>
433{
434 check_template_parameters();
435
436 eigen_assert(a.rows()==a.cols());
437 const Index size = a.rows();
438 m_matrix.resize(size, size);
439 if (!internal::is_same_dense(m_matrix, a.derived()))
440 m_matrix = a.derived();
441
442 // Compute matrix L1 norm = max abs column sum.
443 m_l1_norm = RealScalar(0);
444 // TODO move this code to SelfAdjointView
445 for (Index col = 0; col < size; ++col) {
446 RealScalar abs_col_sum;
447 if (_UpLo == Lower)
448 abs_col_sum = m_matrix.col(col).tail(size - col).template lpNorm<1>() + m_matrix.row(col).head(col).template lpNorm<1>();
449 else
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;
453 }
454
455 m_isInitialized = true;
456 bool ok = Traits::inplace_decomposition(m_matrix);
457 m_info = ok ? Success : NumericalIssue;
458
459 return *this;
460}
461
462/** Performs a rank one update (or dowdate) of the current decomposition.
463 * If A = LL^* before the rank one update,
464 * then after it we have LL^* = A + sigma * v v^* where \a v must be a vector
465 * of same dimension.
466 */
467template<typename _MatrixType, int _UpLo>
468template<typename VectorType>
469LLT<_MatrixType,_UpLo> & LLT<_MatrixType,_UpLo>::rankUpdate(const VectorType& v, const RealScalar& sigma)
470{
472 eigen_assert(v.size()==m_matrix.cols());
473 eigen_assert(m_isInitialized);
475 m_info = NumericalIssue;
476 else
477 m_info = Success;
478
479 return *this;
480}
481
482#ifndef EIGEN_PARSED_BY_DOXYGEN
483template<typename _MatrixType,int _UpLo>
484template<typename RhsType, typename DstType>
485void LLT<_MatrixType,_UpLo>::_solve_impl(const RhsType &rhs, DstType &dst) const
486{
487 _solve_impl_transposed<true>(rhs, dst);
488}
489
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
493{
494 dst = rhs;
495
496 matrixL().template conjugateIf<!Conjugate>().solveInPlace(dst);
497 matrixU().template conjugateIf<!Conjugate>().solveInPlace(dst);
498}
499#endif
500
501/** \internal use x = llt_object.solve(x);
502 *
503 * This is the \em in-place version of solve().
504 *
505 * \param bAndX represents both the right-hand side matrix b and result x.
506 *
507 * This version avoids a copy when the right hand side matrix b is not needed anymore.
508 *
509 * \warning The parameter is only marked 'const' to make the C++ compiler accept a temporary expression here.
510 * This function will const_cast it, so constness isn't honored here.
511 *
512 * \sa LLT::solve(), MatrixBase::llt()
513 */
514template<typename MatrixType, int _UpLo>
515template<typename Derived>
517{
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);
522}
523
524/** \returns the matrix represented by the decomposition,
525 * i.e., it returns the product: L L^*.
526 * This function is provided for debug purpose. */
527template<typename MatrixType, int _UpLo>
529{
530 eigen_assert(m_isInitialized && "LLT is not initialized.");
531 return matrixL() * matrixL().adjoint().toDenseMatrix();
532}
533
534/** \cholesky_module
535 * \returns the LLT decomposition of \c *this
536 * \sa SelfAdjointView::llt()
537 */
538template<typename Derived>
541{
542 return LLT<PlainObject>(derived());
543}
544
545/** \cholesky_module
546 * \returns the LLT decomposition of \c *this
547 * \sa SelfAdjointView::llt()
548 */
549template<typename MatrixType, unsigned int UpLo>
552{
553 return LLT<PlainObject,UpLo>(m_matrix);
554}
555
556} // end namespace Eigen
557
558#endif // EIGEN_LLT_H
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ColXpr col(Index i)
This is the const version of col().
Definition: BlockMethods.h:1097
VectorBlock< Derived > SegmentReturnType
Definition: BlockMethods.h:38
Block< Derived, internal::traits< Derived >::RowsAtCompileTime, 1, !IsRowMajor > ColXpr
Definition: BlockMethods.h:14
EIGEN_DEVICE_FUNC RealReturnType real() const
Definition: CommonCwiseUnaryOps.h:100
#define EIGEN_GENERIC_PUBLIC_INTERFACE(Derived)
Just a side note.
Definition: Macros.h:1274
#define EIGEN_NOEXCEPT
Definition: Macros.h:1428
#define EIGEN_CONSTEXPR
Definition: Macros.h:797
#define eigen_assert(x)
Definition: Macros.h:1047
#define EIGEN_STRONG_INLINE
Definition: Macros.h:927
#define EIGEN_STATIC_ASSERT_NON_INTEGER(TYPE)
Definition: StaticAssert.h:187
#define EIGEN_STATIC_ASSERT_VECTOR_ONLY(TYPE)
Definition: StaticAssert.h:142
constexpr common_return_t< T1, T2 > beta(const T1 a, const T2 b) noexcept
Compile-time beta function.
Definition: beta.hpp:36
Expression of a fixed-size or dynamic-size block.
Definition: Block.h:105
\jacobi_module
Definition: Jacobi.h:35
EIGEN_DEVICE_FUNC void makeGivens(const Scalar &p, const Scalar &q, Scalar *r=0)
Makes *this as a Givens rotation G such that applying to the left of the vector yields: .
Definition: Jacobi.h:162
Standard Cholesky decomposition (LL^T) of a matrix and associated features.
Definition: LLT.h:68
SolverBase< LLT > Base
Definition: LLT.h:71
LLT(const EigenBase< InputType > &matrix)
Definition: LLT.h:105
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
RealScalar m_l1_norm
Definition: LLT.h:230
void _solve_impl(const RhsType &rhs, DstType &dst) const
Definition: LLT.h:485
EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT
Definition: LLT.h:205
ComputationInfo m_info
Definition: LLT.h:232
@ MaxColsAtCompileTime
Definition: LLT.h:76
_MatrixType MatrixType
Definition: LLT.h:70
void solveInPlace(const MatrixBase< Derived > &bAndX) const
Definition: LLT.h:516
RealScalar rcond() const
Definition: LLT.h:166
LLT & rankUpdate(const VectorType &vec, const RealScalar &sigma=1)
internal::LLT_Traits< MatrixType, UpLo > Traits
Definition: LLT.h:85
const MatrixType & matrixLLT() const
Definition: LLT.h:177
static void check_template_parameters()
Definition: LLT.h:220
Traits::MatrixL matrixL() const
Definition: LLT.h:135
const LLT & adjoint() const EIGEN_NOEXCEPT
Definition: LLT.h:202
EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT
Definition: LLT.h:204
MatrixType reconstructedMatrix() const
Definition: LLT.h:528
bool m_isInitialized
Definition: LLT.h:231
LLT & compute(const EigenBase< InputType > &matrix)
LLT(Index size)
Default Constructor with memory preallocation.
Definition: LLT.h:101
MatrixType m_matrix
Definition: LLT.h:229
@ PacketSize
Definition: LLT.h:80
@ UpLo
Definition: LLT.h:82
@ AlignmentMask
Definition: LLT.h:81
ComputationInfo info() const
Reports whether previous computation was successful.
Definition: LLT.h:191
void _solve_impl_transposed(const RhsType &rhs, DstType &dst) const
Definition: LLT.h:492
Base class for all dense matrices, vectors, and expressions.
Definition: MatrixBase.h:50
const LLT< PlainObject > llt() const
\cholesky_module
Definition: LLT.h:540
const LLT< PlainObject, UpLo > llt() const
\cholesky_module
Definition: LLT.h:551
Pseudo expression representing a solving operation.
Definition: Solve.h:63
A base class for matrix decomposition and solvers.
Definition: SolverBase.h:69
internal::traits< LLT< _MatrixType, _UpLo > >::Scalar Scalar
Definition: SolverBase.h:73
const Solve< LLT< _MatrixType, _UpLo >, Rhs > solve(const MatrixBase< Rhs > &b) const
Definition: SolverBase.h:106
EIGEN_DEVICE_FUNC LLT< _MatrixType, _UpLo > & derived()
Definition: EigenBase.h:46
Expression of the transpose of a matrix.
Definition: Transpose.h:54
Expression of a triangular part in a matrix.
Definition: TriangularMatrix.h:189
auto sqrt(const UnitType &value) noexcept -> unit_t< square_root< typename units::traits::unit_t_traits< UnitType >::unit_type >, typename units::traits::unit_t_traits< UnitType >::underlying_type, linear_scale >
computes the square root of value
Definition: math.h:483
ComputationInfo
Enum for reporting the status of a computation.
Definition: Constants.h:440
@ Lower
View matrix as a lower triangular matrix.
Definition: Constants.h:209
@ Upper
View matrix as an upper triangular matrix.
Definition: Constants.h:211
@ NumericalIssue
The provided data did not satisfy the prerequisites.
Definition: Constants.h:444
@ Success
Computation was successful.
Definition: Constants.h:442
constexpr common_t< T1, T2 > max(const T1 x, const T2 y) noexcept
Compile-time pairwise maximum function.
Definition: max.hpp:35
constexpr common_t< T1, T2 > min(const T1 x, const T2 y) noexcept
Compile-time pairwise minimum function.
Definition: min.hpp:35
static Index llt_rank_update_lower(MatrixType &mat, const VectorType &vec, const typename MatrixType::RealScalar &sigma)
Definition: LLT.h:240
const Scalar & y
Definition: MathFunctions.h:821
EIGEN_DEVICE_FUNC bool is_same_dense(const T1 &mat1, const T2 &mat2, typename enable_if< possibly_same_dense< T1, T2 >::value >::type *=0)
Definition: XprHelper.h:695
EIGEN_CONSTEXPR Index size(const T &x)
Definition: Meta.h:479
EIGEN_DEVICE_FUNC void apply_rotation_in_the_plane(DenseBase< VectorX > &xpr_x, DenseBase< VectorY > &xpr_y, const JacobiRotation< OtherScalar > &j)
\jacobi_module Applies the clock wise 2D rotation j to the set of 2D vectors of coordinates x and y:
Definition: Jacobi.h:453
Decomposition::RealScalar rcond_estimate_helper(typename Decomposition::RealScalar matrix_norm, const Decomposition &dec)
Reciprocal condition number estimator.
Definition: ConditionEstimator.h:159
EIGEN_DEVICE_FUNC bool abs2(bool x)
Definition: MathFunctions.h:1292
Namespace containing all symbols from the Eigen library.
Definition: MatrixExponential.h:16
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:74
Definition: Eigen_Colamd.h:50
static constexpr const unit_t< compound_unit< power::watts, inverse< area::square_meters >, inverse< squared< squared< temperature::kelvin > > > > > sigma((2 *math::cpow< 5 >(pi) *math::cpow< 4 >(R))/(15 *math::cpow< 3 >(h) *math::cpow< 2 >(c) *math::cpow< 4 >(N_A)))
Stefan-Boltzmann constant.
b
Definition: data.h:44
Common base class for all classes T such that MatrixBase has an operator=(T) and a constructor Matrix...
Definition: EigenBase.h:30
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT
Definition: EigenBase.h:63
Eigen::Index Index
The interface type of indices.
Definition: EigenBase.h:39
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index size() const EIGEN_NOEXCEPT
Definition: EigenBase.h:67
EIGEN_DEVICE_FUNC Derived & derived()
Definition: EigenBase.h:46
EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT
Definition: EigenBase.h:60
The type used to identify a matrix expression.
Definition: Constants.h:522
Holds information about the various numeric (i.e.
Definition: NumTraits.h:233
The type used to identify a general solver (factored) storage.
Definition: Constants.h:513
static bool inplace_decomposition(MatrixType &m)
Definition: LLT.h:407
const TriangularView< const typename MatrixType::AdjointReturnType, Upper > MatrixU
Definition: LLT.h:404
const TriangularView< const MatrixType, Lower > MatrixL
Definition: LLT.h:403
static MatrixL getL(const MatrixType &m)
Definition: LLT.h:405
static MatrixU getU(const MatrixType &m)
Definition: LLT.h:406
const TriangularView< const MatrixType, Upper > MatrixU
Definition: LLT.h:414
static MatrixU getU(const MatrixType &m)
Definition: LLT.h:416
static MatrixL getL(const MatrixType &m)
Definition: LLT.h:415
const TriangularView< const typename MatrixType::AdjointReturnType, Lower > MatrixL
Definition: LLT.h:413
static bool inplace_decomposition(MatrixType &m)
Definition: LLT.h:417
Definition: LLT.h:26
NumTraits< Scalar >::Real RealScalar
Definition: LLT.h:311
static Index blocked(MatrixType &m)
Definition: LLT.h:339
static Index unblocked(MatrixType &mat)
Definition: LLT.h:313
static Index rankUpdate(MatrixType &mat, const VectorType &vec, const RealScalar &sigma)
Definition: LLT.h:371
static EIGEN_STRONG_INLINE Index unblocked(MatrixType &mat)
Definition: LLT.h:382
NumTraits< Scalar >::Real RealScalar
Definition: LLT.h:379
static EIGEN_STRONG_INLINE Index blocked(MatrixType &mat)
Definition: LLT.h:388
static Index rankUpdate(MatrixType &mat, const VectorType &vec, const RealScalar &sigma)
Definition: LLT.h:394
Definition: LLT.h:237
Definition: GenericPacketMath.h:107
T type
Definition: Meta.h:126
SolverStorage StorageKind
Definition: LLT.h:21
Definition: ForwardDeclarations.h:17