Please, help us to better know about our user community by answering the following short survey: https://forms.gle/wpyrxWi18ox9Z5ae9
Eigen  3.4.0
Loading...
Searching...
No Matches
MatrixBase.h
1// This file is part of Eigen, a lightweight C++ template library
2// for linear algebra.
3//
4// Copyright (C) 2006-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
5// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
6//
7// This Source Code Form is subject to the terms of the Mozilla
8// Public License v. 2.0. If a copy of the MPL was not distributed
9// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
10
11#ifndef EIGEN_MATRIXBASE_H
12#define EIGEN_MATRIXBASE_H
13
14namespace Eigen {
15
24 *
25 * Note that some methods are defined in other modules such as the \ref LU_Module LU module
26 * for all functions related to matrix inversions.
27 *
28 * \tparam Derived is the derived type, e.g. a matrix type, or an expression, etc.
29 *
30 * When writing a function taking Eigen objects as argument, if you want your function
31 * to take as argument any matrix, vector, or expression, just let it take a
32 * MatrixBase argument. As an example, here is a function printFirstRow which, given
33 * a matrix, vector, or expression \a x, prints the first row of \a x.
34 *
35 * \code
36 template<typename Derived>
37 void printFirstRow(const Eigen::MatrixBase<Derived>& x)
38 {
39 cout << x.row(0) << endl;
40 }
41 * \endcode
42 *
43 * This class can be extended with the help of the plugin mechanism described on the page
44 * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_MATRIXBASE_PLUGIN.
45 *
46 * \sa \blank \ref TopicClassHierarchy
47 */
48template<typename Derived> class MatrixBase
49 : public DenseBase<Derived>
50{
51 public:
52#ifndef EIGEN_PARSED_BY_DOXYGEN
53 typedef MatrixBase StorageBaseType;
54 typedef typename internal::traits<Derived>::StorageKind StorageKind;
55 typedef typename internal::traits<Derived>::StorageIndex StorageIndex;
56 typedef typename internal::traits<Derived>::Scalar Scalar;
57 typedef typename internal::packet_traits<Scalar>::type PacketScalar;
58 typedef typename NumTraits<Scalar>::Real RealScalar;
59
60 typedef DenseBase<Derived> Base;
61 using Base::RowsAtCompileTime;
62 using Base::ColsAtCompileTime;
63 using Base::SizeAtCompileTime;
64 using Base::MaxRowsAtCompileTime;
65 using Base::MaxColsAtCompileTime;
66 using Base::MaxSizeAtCompileTime;
67 using Base::IsVectorAtCompileTime;
68 using Base::Flags;
69
70 using Base::derived;
71 using Base::const_cast_derived;
72 using Base::rows;
73 using Base::cols;
74 using Base::size;
75 using Base::coeff;
76 using Base::coeffRef;
77 using Base::lazyAssign;
78 using Base::eval;
79 using Base::operator-;
80 using Base::operator+=;
81 using Base::operator-=;
82 using Base::operator*=;
83 using Base::operator/=;
84
85 typedef typename Base::CoeffReturnType CoeffReturnType;
86 typedef typename Base::ConstTransposeReturnType ConstTransposeReturnType;
87 typedef typename Base::RowXpr RowXpr;
88 typedef typename Base::ColXpr ColXpr;
89#endif // not EIGEN_PARSED_BY_DOXYGEN
91
93#ifndef EIGEN_PARSED_BY_DOXYGEN
95 typedef Matrix<Scalar,EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime),
96 EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime)> SquareMatrixType;
97#endif // not EIGEN_PARSED_BY_DOXYGEN
98
101 EIGEN_DEVICE_FUNC
102 inline Index diagonalSize() const { return (numext::mini)(rows(),cols()); }
103
104 typedef typename Base::PlainObject PlainObject;
106#ifndef EIGEN_PARSED_BY_DOXYGEN
108 typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,PlainObject> ConstantReturnType;
109
110 typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
112 ConstTransposeReturnType
113 >::type AdjointReturnType;
115 typedef Matrix<std::complex<RealScalar>, internal::traits<Derived>::ColsAtCompileTime, 1, ColMajor> EigenvaluesReturnType;
117 typedef CwiseNullaryOp<internal::scalar_identity_op<Scalar>,PlainObject> IdentityReturnType;
120 internal::traits<Derived>::RowsAtCompileTime,
121 internal::traits<Derived>::ColsAtCompileTime> BasisReturnType;
122#endif // not EIGEN_PARSED_BY_DOXYGEN
123
124#define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::MatrixBase
125#define EIGEN_DOC_UNARY_ADDONS(X,Y)
126# include "../plugins/CommonCwiseBinaryOps.h"
127# include "../plugins/MatrixCwiseUnaryOps.h"
128# include "../plugins/MatrixCwiseBinaryOps.h"
129# ifdef EIGEN_MATRIXBASE_PLUGIN
130# include EIGEN_MATRIXBASE_PLUGIN
131# endif
132#undef EIGEN_CURRENT_STORAGE_BASE_CLASS
133#undef EIGEN_DOC_UNARY_ADDONS
134
136
138 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
139 Derived& operator=(const MatrixBase& other);
140
141 // We cannot inherit here via Base::operator= since it is causing
142 // trouble with MSVC.
143
144 template <typename OtherDerived>
145 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
146 Derived& operator=(const DenseBase<OtherDerived>& other);
147
148 template <typename OtherDerived>
149 EIGEN_DEVICE_FUNC
150 Derived& operator=(const EigenBase<OtherDerived>& other);
151
152 template<typename OtherDerived>
153 EIGEN_DEVICE_FUNC
154 Derived& operator=(const ReturnByValue<OtherDerived>& other);
155
156 template<typename OtherDerived>
157 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
158 Derived& operator+=(const MatrixBase<OtherDerived>& other);
159 template<typename OtherDerived>
160 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
161 Derived& operator-=(const MatrixBase<OtherDerived>& other);
162
163 template<typename OtherDerived>
164 EIGEN_DEVICE_FUNC
166 operator*(const MatrixBase<OtherDerived> &other) const;
167
168 template<typename OtherDerived>
169 EIGEN_DEVICE_FUNC
171 lazyProduct(const MatrixBase<OtherDerived> &other) const;
172
173 template<typename OtherDerived>
174 Derived& operator*=(const EigenBase<OtherDerived>& other);
175
176 template<typename OtherDerived>
178
179 template<typename OtherDerived>
181
182 template<typename DiagonalDerived>
183 EIGEN_DEVICE_FUNC
185 operator*(const DiagonalBase<DiagonalDerived> &diagonal) const;
186
187 template<typename OtherDerived>
188 EIGEN_DEVICE_FUNC
189 typename ScalarBinaryOpTraits<typename internal::traits<Derived>::Scalar,typename internal::traits<OtherDerived>::Scalar>::ReturnType
190 dot(const MatrixBase<OtherDerived>& other) const;
191
192 EIGEN_DEVICE_FUNC RealScalar squaredNorm() const;
193 EIGEN_DEVICE_FUNC RealScalar norm() const;
194 RealScalar stableNorm() const;
195 RealScalar blueNorm() const;
196 RealScalar hypotNorm() const;
197 EIGEN_DEVICE_FUNC const PlainObject normalized() const;
198 EIGEN_DEVICE_FUNC const PlainObject stableNormalized() const;
199 EIGEN_DEVICE_FUNC void normalize();
200 EIGEN_DEVICE_FUNC void stableNormalize();
201
202 EIGEN_DEVICE_FUNC const AdjointReturnType adjoint() const;
203 EIGEN_DEVICE_FUNC void adjointInPlace();
204
205 typedef Diagonal<Derived> DiagonalReturnType;
206 EIGEN_DEVICE_FUNC
207 DiagonalReturnType diagonal();
208
209 typedef typename internal::add_const<Diagonal<const Derived> >::type ConstDiagonalReturnType;
210 EIGEN_DEVICE_FUNC
211 ConstDiagonalReturnType diagonal() const;
212
213 template<int Index> struct DiagonalIndexReturnType { typedef Diagonal<Derived,Index> Type; };
214 template<int Index> struct ConstDiagonalIndexReturnType { typedef const Diagonal<const Derived,Index> Type; };
215
216 template<int Index>
217 EIGEN_DEVICE_FUNC
218 typename DiagonalIndexReturnType<Index>::Type diagonal();
219
220 template<int Index>
221 EIGEN_DEVICE_FUNC
222 typename ConstDiagonalIndexReturnType<Index>::Type diagonal() const;
223
224 typedef Diagonal<Derived,DynamicIndex> DiagonalDynamicIndexReturnType;
225 typedef typename internal::add_const<Diagonal<const Derived,DynamicIndex> >::type ConstDiagonalDynamicIndexReturnType;
226
227 EIGEN_DEVICE_FUNC
228 DiagonalDynamicIndexReturnType diagonal(Index index);
229 EIGEN_DEVICE_FUNC
230 ConstDiagonalDynamicIndexReturnType diagonal(Index index) const;
231
232 template<unsigned int Mode> struct TriangularViewReturnType { typedef TriangularView<Derived, Mode> Type; };
233 template<unsigned int Mode> struct ConstTriangularViewReturnType { typedef const TriangularView<const Derived, Mode> Type; };
234
235 template<unsigned int Mode>
236 EIGEN_DEVICE_FUNC
237 typename TriangularViewReturnType<Mode>::Type triangularView();
238 template<unsigned int Mode>
239 EIGEN_DEVICE_FUNC
240 typename ConstTriangularViewReturnType<Mode>::Type triangularView() const;
241
242 template<unsigned int UpLo> struct SelfAdjointViewReturnType { typedef SelfAdjointView<Derived, UpLo> Type; };
243 template<unsigned int UpLo> struct ConstSelfAdjointViewReturnType { typedef const SelfAdjointView<const Derived, UpLo> Type; };
244
245 template<unsigned int UpLo>
246 EIGEN_DEVICE_FUNC
247 typename SelfAdjointViewReturnType<UpLo>::Type selfadjointView();
248 template<unsigned int UpLo>
249 EIGEN_DEVICE_FUNC
250 typename ConstSelfAdjointViewReturnType<UpLo>::Type selfadjointView() const;
251
252 const SparseView<Derived> sparseView(const Scalar& m_reference = Scalar(0),
253 const typename NumTraits<Scalar>::Real& m_epsilon = NumTraits<Scalar>::dummy_precision()) const;
254 EIGEN_DEVICE_FUNC static const IdentityReturnType Identity();
255 EIGEN_DEVICE_FUNC static const IdentityReturnType Identity(Index rows, Index cols);
256 EIGEN_DEVICE_FUNC static const BasisReturnType Unit(Index size, Index i);
257 EIGEN_DEVICE_FUNC static const BasisReturnType Unit(Index i);
258 EIGEN_DEVICE_FUNC static const BasisReturnType UnitX();
259 EIGEN_DEVICE_FUNC static const BasisReturnType UnitY();
260 EIGEN_DEVICE_FUNC static const BasisReturnType UnitZ();
261 EIGEN_DEVICE_FUNC static const BasisReturnType UnitW();
262
263 EIGEN_DEVICE_FUNC
265 const PermutationWrapper<const Derived> asPermutation() const;
266
267 EIGEN_DEVICE_FUNC
268 Derived& setIdentity();
269 EIGEN_DEVICE_FUNC
271 EIGEN_DEVICE_FUNC Derived& setUnit(Index i);
272 EIGEN_DEVICE_FUNC Derived& setUnit(Index newSize, Index i);
273
274 bool isIdentity(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
275 bool isDiagonal(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
276
277 bool isUpperTriangular(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
278 bool isLowerTriangular(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
279
280 template<typename OtherDerived>
281 bool isOrthogonal(const MatrixBase<OtherDerived>& other,
282 const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
283 bool isUnitary(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
284
289 template<typename OtherDerived>
290 EIGEN_DEVICE_FUNC inline bool operator==(const MatrixBase<OtherDerived>& other) const
291 { return cwiseEqual(other).all(); }
292
297 template<typename OtherDerived>
298 EIGEN_DEVICE_FUNC inline bool operator!=(const MatrixBase<OtherDerived>& other) const
299 { return cwiseNotEqual(other).any(); }
300
302
303 // TODO forceAlignedAccess is temporarily disabled
304 // Need to find a nicer workaround.
305 inline const Derived& forceAlignedAccess() const { return derived(); }
306 inline Derived& forceAlignedAccess() { return derived(); }
307 template<bool Enable> inline const Derived& forceAlignedAccessIf() const { return derived(); }
308 template<bool Enable> inline Derived& forceAlignedAccessIf() { return derived(); }
309
310 EIGEN_DEVICE_FUNC Scalar trace() const;
311
312 template<int p> EIGEN_DEVICE_FUNC RealScalar lpNorm() const;
313
314 EIGEN_DEVICE_FUNC MatrixBase<Derived>& matrix() { return *this; }
315 EIGEN_DEVICE_FUNC const MatrixBase<Derived>& matrix() const { return *this; }
316
319 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ArrayWrapper<Derived> array() { return ArrayWrapper<Derived>(derived()); }
322 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const ArrayWrapper<const Derived> array() const { return ArrayWrapper<const Derived>(derived()); }
323
325
326 inline const FullPivLU<PlainObject> fullPivLu() const;
328
329 inline const PartialPivLU<PlainObject> lu() const;
330
331 EIGEN_DEVICE_FUNC
332 inline const Inverse<Derived> inverse() const;
333
334 template<typename ResultType>
336 ResultType& inverse,
337 typename ResultType::Scalar& determinant,
338 bool& invertible,
339 const RealScalar& absDeterminantThreshold = NumTraits<Scalar>::dummy_precision()
340 ) const;
341
342 template<typename ResultType>
344 ResultType& inverse,
345 bool& invertible,
346 const RealScalar& absDeterminantThreshold = NumTraits<Scalar>::dummy_precision()
347 ) const;
348
349 EIGEN_DEVICE_FUNC
351
353
354 inline const LLT<PlainObject> llt() const;
355 inline const LDLT<PlainObject> ldlt() const;
356
358
363
365
366 inline EigenvaluesReturnType eigenvalues() const;
367 inline RealScalar operatorNorm() const;
368
370
371 inline JacobiSVD<PlainObject> jacobiSvd(unsigned int computationOptions = 0) const;
372 inline BDCSVD<PlainObject> bdcSvd(unsigned int computationOptions = 0) const;
373
375
376 #ifndef EIGEN_PARSED_BY_DOXYGEN
378 template<typename OtherDerived> struct cross_product_return_type {
379 typedef typename ScalarBinaryOpTraits<typename internal::traits<Derived>::Scalar,typename internal::traits<OtherDerived>::Scalar>::ReturnType Scalar;
381 };
382 #endif // EIGEN_PARSED_BY_DOXYGEN
383 template<typename OtherDerived>
384 EIGEN_DEVICE_FUNC
385#ifndef EIGEN_PARSED_BY_DOXYGEN
386 inline typename cross_product_return_type<OtherDerived>::type
387#else
388 inline PlainObject
389#endif
390 cross(const MatrixBase<OtherDerived>& other) const;
391
392 template<typename OtherDerived>
393 EIGEN_DEVICE_FUNC
394 inline PlainObject cross3(const MatrixBase<OtherDerived>& other) const;
395
396 EIGEN_DEVICE_FUNC
397 inline PlainObject unitOrthogonal(void) const;
398
399 EIGEN_DEVICE_FUNC
401
402 // put this as separate enum value to work around possible GCC 4.3 bug (?)
403 enum { HomogeneousReturnTypeDirection = ColsAtCompileTime==1&&RowsAtCompileTime==1 ? ((internal::traits<Derived>::Flags&RowMajorBit)==RowMajorBit ? Horizontal : Vertical)
405 typedef Homogeneous<Derived, HomogeneousReturnTypeDirection> HomogeneousReturnType;
406 EIGEN_DEVICE_FUNC
407 inline HomogeneousReturnType homogeneous() const;
408
409 enum {
411 };
412 typedef Block<const Derived,
413 internal::traits<Derived>::ColsAtCompileTime==1 ? SizeMinusOne : 1,
414 internal::traits<Derived>::ColsAtCompileTime==1 ? 1 : SizeMinusOne> ConstStartMinusOne;
415 typedef EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(ConstStartMinusOne,Scalar,quotient) HNormalizedReturnType;
416 EIGEN_DEVICE_FUNC
417 inline const HNormalizedReturnType hnormalized() const;
418
420
421 EIGEN_DEVICE_FUNC
422 void makeHouseholderInPlace(Scalar& tau, RealScalar& beta);
423 template<typename EssentialPart>
424 EIGEN_DEVICE_FUNC
425 void makeHouseholder(EssentialPart& essential,
426 Scalar& tau, RealScalar& beta) const;
427 template<typename EssentialPart>
428 EIGEN_DEVICE_FUNC
429 void applyHouseholderOnTheLeft(const EssentialPart& essential,
430 const Scalar& tau,
431 Scalar* workspace);
432 template<typename EssentialPart>
433 EIGEN_DEVICE_FUNC
434 void applyHouseholderOnTheRight(const EssentialPart& essential,
435 const Scalar& tau,
436 Scalar* workspace);
437
439
440 template<typename OtherScalar>
441 EIGEN_DEVICE_FUNC
443 template<typename OtherScalar>
444 EIGEN_DEVICE_FUNC
446
448
449 template<typename OtherDerived>
450 EIGEN_STRONG_INLINE const typename SparseMatrixBase<OtherDerived>::template CwiseProductDenseReturnType<Derived>::Type
452 {
453 return other.cwiseProduct(derived());
454 }
455
457
458 typedef typename internal::stem_function<Scalar>::type StemFunction;
459#define EIGEN_MATRIX_FUNCTION(ReturnType, Name, Description) \
460 \
461 const ReturnType<Derived> Name() const;
462#define EIGEN_MATRIX_FUNCTION_1(ReturnType, Name, Description, Argument) \
463 \
464 const ReturnType<Derived> Name(Argument) const;
465
466 EIGEN_MATRIX_FUNCTION(MatrixExponentialReturnValue, exp, exponential)
468 const MatrixFunctionReturnValue<Derived> matrixFunction(StemFunction f) const;
469 EIGEN_MATRIX_FUNCTION(MatrixFunctionReturnValue, cosh, hyperbolic cosine)
470 EIGEN_MATRIX_FUNCTION(MatrixFunctionReturnValue, sinh, hyperbolic sine)
471#if EIGEN_HAS_CXX11_MATH
472 EIGEN_MATRIX_FUNCTION(MatrixFunctionReturnValue, atanh, inverse hyperbolic cosine)
473 EIGEN_MATRIX_FUNCTION(MatrixFunctionReturnValue, acosh, inverse hyperbolic cosine)
474 EIGEN_MATRIX_FUNCTION(MatrixFunctionReturnValue, asinh, inverse hyperbolic sine)
475#endif
476 EIGEN_MATRIX_FUNCTION(MatrixFunctionReturnValue, cos, cosine)
477 EIGEN_MATRIX_FUNCTION(MatrixFunctionReturnValue, sin, sine)
478 EIGEN_MATRIX_FUNCTION(MatrixSquareRootReturnValue, sqrt, square root)
479 EIGEN_MATRIX_FUNCTION(MatrixLogarithmReturnValue, log, logarithm)
480 EIGEN_MATRIX_FUNCTION_1(MatrixPowerReturnValue, pow, power to \c p, const RealScalar& p)
481 EIGEN_MATRIX_FUNCTION_1(MatrixComplexPowerReturnValue, pow, power to \c p, const std::complex<RealScalar>& p)
482
483 protected:
484 EIGEN_DEFAULT_COPY_CONSTRUCTOR(MatrixBase)
485 EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(MatrixBase)
486
487 private:
488 EIGEN_DEVICE_FUNC explicit MatrixBase(int);
489 EIGEN_DEVICE_FUNC MatrixBase(int,int);
490 template<typename OtherDerived> EIGEN_DEVICE_FUNC explicit MatrixBase(const MatrixBase<OtherDerived>&);
491 protected:
492 // mixing arrays and matrices is not legal
493 template<typename OtherDerived> Derived& operator+=(const ArrayBase<OtherDerived>& )
494 {EIGEN_STATIC_ASSERT(std::ptrdiff_t(sizeof(typename OtherDerived::Scalar))==-1,YOU_CANNOT_MIX_ARRAYS_AND_MATRICES); return *this;}
495 // mixing arrays and matrices is not legal
496 template<typename OtherDerived> Derived& operator-=(const ArrayBase<OtherDerived>& )
497 {EIGEN_STATIC_ASSERT(std::ptrdiff_t(sizeof(typename OtherDerived::Scalar))==-1,YOU_CANNOT_MIX_ARRAYS_AND_MATRICES); return *this;}
498};
499
500
501/***************************************************************************
502* Implementation of matrix base methods
503***************************************************************************/
504
512template<typename Derived>
513template<typename OtherDerived>
514inline Derived&
516{
517 other.derived().applyThisOnTheRight(derived());
518 return derived();
519}
520
526template<typename Derived>
527template<typename OtherDerived>
529{
530 other.derived().applyThisOnTheRight(derived());
531}
532
538template<typename Derived>
539template<typename OtherDerived>
541{
542 other.derived().applyThisOnTheLeft(derived());
543}
544
545} // end namespace Eigen
546
547#endif // EIGEN_MATRIXBASE_H
Base class for all 1D and 2D array, and related expressions.
Definition ArrayBase.h:41
Expression of a mathematical vector or matrix as an array object.
Definition ArrayWrapper.h:43
class Bidiagonal Divide and Conquer SVD
Definition BDCSVD.h:74
Expression of a fixed-size or dynamic-size block.
Definition Block.h:105
Householder rank-revealing QR decomposition of a matrix with column-pivoting.
Definition ColPivHouseholderQR.h:53
Complete orthogonal decomposition (COD) of a matrix.
Definition CompleteOrthogonalDecomposition.h:52
Generic expression of a matrix where all coefficients are defined by a functor.
Definition CwiseNullaryOp.h:61
Generic expression where a coefficient-wise unary operator is applied to an expression.
Definition CwiseUnaryOp.h:56
@ SizeAtCompileTime
Definition DenseBase.h:113
@ ColsAtCompileTime
Definition DenseBase.h:106
@ RowsAtCompileTime
Definition DenseBase.h:100
internal::traits< Derived >::StorageIndex StorageIndex
The type used to store indices.
Definition DenseBase.h:63
internal::traits< Derived >::Scalar Scalar
Definition DenseBase.h:66
DenseBase()
Definition DenseBase.h:681
internal::conditional< internal::is_same< typenameinternal::traits< Derived >::XprKind, MatrixXpr >::value, PlainMatrix, PlainArray >::type PlainObject
The plain matrix or array type corresponding to this expression.
Definition DenseBase.h:210
EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT
Definition EigenBase.h:63
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
Expression of a diagonal matrix.
Definition DiagonalMatrix.h:295
Expression of a diagonal/subdiagonal/superdiagonal in a matrix.
Definition Diagonal.h:65
Householder rank-revealing QR decomposition of a matrix with full pivoting.
Definition FullPivHouseholderQR.h:62
LU decomposition of a matrix with complete pivoting, and related features.
Definition FullPivLU.h:62
Expression of one (or a set of) homogeneous vector(s)
Definition Homogeneous.h:62
Householder QR decomposition of a matrix.
Definition HouseholderQR.h:58
Expression of the inverse of another expression.
Definition Inverse.h:44
Rotation given by a cosine-sine pair.
Definition Jacobi.h:35
Two-sided Jacobi SVD decomposition of a rectangular matrix.
Definition JacobiSVD.h:490
Robust Cholesky decomposition of a matrix with pivoting.
Definition LDLT.h:61
Standard Cholesky decomposition (LL^T) of a matrix and associated features.
Definition LLT.h:68
Base class for all dense matrices, vectors, and expressions.
Definition MatrixBase.h:50
static const BasisReturnType UnitY()
Definition CwiseNullaryOp.h:940
bool operator!=(const MatrixBase< OtherDerived > &other) const
Definition MatrixBase.h:298
MatrixBase< Derived >::template TriangularViewReturnType< Mode >::Type triangularView()
Definition TriangularMatrix.h:644
void stableNormalize()
Definition Dot.h:191
const LDLT< PlainObject > ldlt() const
Definition LDLT.h:681
RealScalar operatorNorm() const
Computes the L2 operator norm.
Definition MatrixBaseEigenvalues.h:120
Derived & operator-=(const MatrixBase< OtherDerived > &other)
Definition CwiseBinaryOp.h:162
const MatrixFunctionReturnValue< MatrixWrapper< ExpressionType > > matrixFunction(StemFunction f) const
void computeInverseWithCheck(ResultType &inverse, bool &invertible, const RealScalar &absDeterminantThreshold=NumTraits< Scalar >::dummy_precision()) const
Definition InverseImpl.h:418
void makeHouseholder(EssentialPart &essential, Scalar &tau, RealScalar &beta) const
Definition Householder.h:67
const MatrixLogarithmReturnValue< MatrixWrapper< ExpressionType > > log() const
const DiagonalWrapper< const Derived > asDiagonal() const
Definition DiagonalMatrix.h:325
Derived & setIdentity()
Definition CwiseNullaryOp.h:873
bool isLowerTriangular(const RealScalar &prec=NumTraits< Scalar >::dummy_precision()) const
Definition TriangularMatrix.h:690
const FullPivLU< PlainObject > fullPivLu() const
Definition FullPivLU.h:870
const CwiseBinaryOp< numext::not_equal_to< Scalar >, const Derived, const OtherDerived > cwiseNotEqual(const Eigen::MatrixBase< OtherDerived > &other) const
Definition MatrixBase.h:64
const MatrixFunctionReturnValue< MatrixWrapper< ExpressionType > > asinh() const
NoAlias< Derived, Eigen::MatrixBase > noalias()
Definition NoAlias.h:102
EigenvaluesReturnType eigenvalues() const
Computes the eigenvalues of a matrix.
Definition MatrixBaseEigenvalues.h:67
const Product< Derived, DiagonalDerived, LazyProduct > operator*(const DiagonalBase< DiagonalDerived > &diagonal) const
Definition DiagonalProduct.h:21
Derived & operator=(const MatrixBase &other)
Definition Assign.h:55
Derived & operator*=(const EigenBase< OtherDerived > &other)
Definition MatrixBase.h:515
const PlainObject stableNormalized() const
Definition Dot.h:167
void applyOnTheLeft(const EigenBase< OtherDerived > &other)
Definition MatrixBase.h:540
const MatrixExponentialReturnValue< MatrixWrapper< ExpressionType > > exp() const
const MatrixFunctionReturnValue< MatrixWrapper< ExpressionType > > cosh() const
void applyOnTheRight(const EigenBase< OtherDerived > &other)
Definition MatrixBase.h:528
RealScalar blueNorm() const
Definition StableNorm.h:229
bool isIdentity(const RealScalar &prec=NumTraits< Scalar >::dummy_precision()) const
Definition CwiseNullaryOp.h:816
void adjointInPlace()
Definition Transpose.h:375
Scalar trace() const
Definition Redux.h:508
RealScalar hypotNorm() const
Definition StableNorm.h:241
JacobiSVD< PlainObject > jacobiSvd(unsigned int computationOptions=0) const
Definition JacobiSVD.h:805
const PlainObject normalized() const
Definition Dot.h:124
const PartialPivLU< PlainObject > partialPivLu() const
Definition PartialPivLU.h:602
RealScalar stableNorm() const
Definition StableNorm.h:213
const CwiseBinaryOp< numext::equal_to< Scalar >, const Derived, const OtherDerived > cwiseEqual(const Eigen::MatrixBase< OtherDerived > &other) const
Definition MatrixBase.h:44
ArrayWrapper< Derived > array()
Definition MatrixBase.h:319
RealScalar lpNorm() const
Definition Dot.h:267
const MatrixFunctionReturnValue< MatrixWrapper< ExpressionType > > atanh() const
const Inverse< Derived > inverse() const
Definition InverseImpl.h:348
ScalarBinaryOpTraits< typenameinternal::traits< Derived >::Scalar, typenameinternal::traits< OtherDerived >::Scalar >::ReturnType dot(const MatrixBase< OtherDerived > &other) const
Definition Dot.h:72
void computeInverseAndDetWithCheck(ResultType &inverse, typename ResultType::Scalar &determinant, bool &invertible, const RealScalar &absDeterminantThreshold=NumTraits< Scalar >::dummy_precision()) const
Definition InverseImpl.h:377
bool operator==(const MatrixBase< OtherDerived > &other) const
Definition MatrixBase.h:290
const MatrixFunctionReturnValue< MatrixWrapper< ExpressionType > > sin() const
const FullPivHouseholderQR< PlainObject > fullPivHouseholderQr() const
Definition FullPivHouseholderQR.h:706
DiagonalDynamicIndexReturnType diagonal(Index index)
Definition Diagonal.h:213
static const BasisReturnType UnitX()
Definition CwiseNullaryOp.h:930
bool isUnitary(const RealScalar &prec=NumTraits< Scalar >::dummy_precision()) const
Definition Dot.h:302
void applyHouseholderOnTheLeft(const EssentialPart &essential, const Scalar &tau, Scalar *workspace)
Definition Householder.h:116
Derived & setUnit(Index newSize, Index i)
Resizes to the given newSize, and writes the i-th unit (basis) vector into *this.
Definition CwiseNullaryOp.h:991
const LLT< PlainObject > llt() const
Definition LLT.h:540
bool isDiagonal(const RealScalar &prec=NumTraits< Scalar >::dummy_precision()) const
Definition DiagonalMatrix.h:339
Derived & setIdentity(Index rows, Index cols)
Resizes to the given size, and writes the identity expression (not necessarily square) into *this.
Definition CwiseNullaryOp.h:889
Derived & operator+=(const MatrixBase< OtherDerived > &other)
Definition CwiseBinaryOp.h:175
static const IdentityReturnType Identity()
Definition CwiseNullaryOp.h:799
const HouseholderQR< PlainObject > householderQr() const
Definition HouseholderQR.h:427
const MatrixPowerReturnValue< MatrixWrapper< ExpressionType > > pow(const RealScalar &p) const
static const BasisReturnType Unit(Index i)
Definition CwiseNullaryOp.h:917
const ArrayWrapper< const Derived > array() const
Definition MatrixBase.h:322
const MatrixSquareRootReturnValue< MatrixWrapper< ExpressionType > > sqrt() const
const MatrixFunctionReturnValue< MatrixWrapper< ExpressionType > > sinh() const
ConstDiagonalReturnType diagonal() const
Definition Diagonal.h:195
static const BasisReturnType UnitZ()
Definition CwiseNullaryOp.h:950
bool isUpperTriangular(const RealScalar &prec=NumTraits< Scalar >::dummy_precision()) const
Definition TriangularMatrix.h:665
void applyHouseholderOnTheRight(const EssentialPart &essential, const Scalar &tau, Scalar *workspace)
Definition Householder.h:154
Index diagonalSize() const
Definition MatrixBase.h:102
const MatrixFunctionReturnValue< MatrixWrapper< ExpressionType > > cos() const
RealScalar squaredNorm() const
Definition Dot.h:96
MatrixBase< Derived >::template ConstSelfAdjointViewReturnType< UpLo >::Type selfadjointView() const
Definition SelfAdjointView.h:341
static const BasisReturnType Unit(Index size, Index i)
Definition CwiseNullaryOp.h:902
Derived & setUnit(Index i)
Set the coefficients of *this to the i-th unit (basis) vector.
Definition CwiseNullaryOp.h:972
const MatrixFunctionReturnValue< MatrixWrapper< ExpressionType > > acosh() const
static const IdentityReturnType Identity(Index rows, Index cols)
Definition CwiseNullaryOp.h:782
void normalize()
Definition Dot.h:145
const Derived & forceAlignedAccess() const
Definition MatrixBase.h:305
RealScalar norm() const
Definition Dot.h:108
const ColPivHouseholderQR< PlainObject > colPivHouseholderQr() const
Definition ColPivHouseholderQR.h:667
const Product< Derived, OtherDerived, LazyProduct > lazyProduct(const MatrixBase< OtherDerived > &other) const
Definition GeneralProduct.h:442
BDCSVD< PlainObject > bdcSvd(unsigned int computationOptions=0) const
Definition BDCSVD.h:1359
const Product< Derived, OtherDerived > operator*(const MatrixBase< OtherDerived > &other) const
Definition GeneralProduct.h:399
const CwiseBinaryOp< internal::scalar_product_op< Derived ::Scalar, OtherDerived ::Scalar >, const Derived, const OtherDerived > cwiseProduct(const Eigen::MatrixBase< OtherDerived > &other) const
Definition MatrixBase.h:24
void applyOnTheLeft(Index p, Index q, const JacobiRotation< OtherScalar > &j)
Definition Jacobi.h:295
internal::add_const_on_value_type< typenameinternal::conditional< Enable, ForceAlignedAccess< Derived >, Derived & >::type >::type forceAlignedAccessIf() const
Definition ForceAlignedAccess.h:132
const CompleteOrthogonalDecomposition< PlainObject > completeOrthogonalDecomposition() const
Definition CompleteOrthogonalDecomposition.h:629
void makeHouseholderInPlace(Scalar &tau, RealScalar &beta)
Definition Householder.h:43
ConstDiagonalDynamicIndexReturnType diagonal(Index index) const
Definition Diagonal.h:221
bool isOrthogonal(const MatrixBase< OtherDerived > &other, const RealScalar &prec=NumTraits< Scalar >::dummy_precision()) const
Definition Dot.h:283
static const BasisReturnType UnitW()
Definition CwiseNullaryOp.h:960
const AdjointReturnType adjoint() const
Definition Transpose.h:221
const PartialPivLU< PlainObject > lu() const
Definition PartialPivLU.h:617
Derived & forceAlignedAccess()
Definition MatrixBase.h:306
The matrix class, also used for vectors and row-vectors.
Definition Matrix.h:180
Pseudo expression providing an operator = assuming no aliasing.
Definition NoAlias.h:32
LU decomposition of a matrix with partial pivoting, and related features.
Definition PartialPivLU.h:78
Class to view a vector of integers as a permutation matrix.
Definition PermutationMatrix.h:487
Expression of the product of two arbitrary matrices or vectors.
Definition Product.h:75
Base class of any sparse matrices or sparse expressions.
Definition SparseMatrixBase.h:28
const CwiseBinaryOp< internal::scalar_product_op< Derived ::Scalar, OtherDerived ::Scalar >, const Derived, const OtherDerived > cwiseProduct(const Eigen::SparseMatrixBase< OtherDerived > &other) const
Definition SparseMatrixBase.h:24
Expression of a dense or sparse matrix with zero or too small values removed.
Definition SparseView.h:46
Expression of a triangular part in a matrix.
Definition TriangularMatrix.h:189
PlainObject cross(const MatrixBase< OtherDerived > &other) const
Definition OrthoMethods.h:35
Matrix< Scalar, 3, 1 > eulerAngles(Index a0, Index a1, Index a2) const
Definition EulerAngles.h:37
PlainObject unitOrthogonal(void) const
Definition OrthoMethods.h:227
PlainObject cross3(const MatrixBase< OtherDerived > &other) const
Definition OrthoMethods.h:83
const HNormalizedReturnType hnormalized() const
homogeneous normalization
Definition Homogeneous.h:174
HomogeneousReturnType homogeneous() const
Definition Homogeneous.h:132
void applyOnTheRight(Index p, Index q, const JacobiRotation< OtherScalar > &j)
Definition Jacobi.h:311
const SparseView< Derived > sparseView(const Scalar &m_reference=Scalar(0), const typename NumTraits< Scalar >::Real &m_epsilon=NumTraits< Scalar >::dummy_precision()) const
Definition SparseView.h:226
@ ColMajor
Definition Constants.h:319
@ Horizontal
Definition Constants.h:267
@ Vertical
Definition Constants.h:264
const unsigned int RowMajorBit
Definition Constants.h:66
Namespace containing all symbols from the Eigen library.
Definition Core:141
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_square_op< typename Derived::Scalar >, const Derived > square(const Eigen::ArrayBase< Derived > &x)
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition Meta.h:74
const int Dynamic
Definition Constants.h:22
Definition EigenBase.h:30
Derived & derived()
Definition EigenBase.h:46
Determines whether the given binary operation of two numeric types is allowed and what the scalar ret...
Definition XprHelper.h:806