Eigen  3.3.90 (mercurial changeset 94875feeeeb9)
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 
14 namespace Eigen {
15 
48 template<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
90 
91 
92 
93 #ifndef EIGEN_PARSED_BY_DOXYGEN
94 
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
107 
110  typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
113  >::type AdjointReturnType;
115  typedef Matrix<std::complex<RealScalar>, internal::traits<Derived>::ColsAtCompileTime, 1, ColMajor> EigenvaluesReturnType;
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 
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>
177  void applyOnTheLeft(const EigenBase<OtherDerived>& other);
178 
179  template<typename OtherDerived>
180  void applyOnTheRight(const EigenBase<OtherDerived>& other);
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 
206  EIGEN_DEVICE_FUNC
208 
209  typedef typename internal::add_const<Diagonal<const Derived> >::type ConstDiagonalReturnType;
210  EIGEN_DEVICE_FUNC
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
264  const DiagonalWrapper<const Derived> asDiagonal() const;
265  const PermutationWrapper<const Derived> asPermutation() const;
266 
267  EIGEN_DEVICE_FUNC
268  Derived& setIdentity();
269  EIGEN_DEVICE_FUNC
270  Derived& setIdentity(Index rows, Index cols);
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 
301  NoAlias<Derived,Eigen::MatrixBase > EIGEN_DEVICE_FUNC noalias();
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;
327  inline const PartialPivLU<PlainObject> partialPivLu() 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>
335  inline void computeInverseAndDetWithCheck(
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>
343  inline void computeInverseWithCheck(
344  ResultType& inverse,
345  bool& invertible,
346  const RealScalar& absDeterminantThreshold = NumTraits<Scalar>::dummy_precision()
347  ) const;
348 
349  EIGEN_DEVICE_FUNC
350  Scalar determinant() const;
351 
353 
354  inline const LLT<PlainObject> llt() const;
355  inline const LDLT<PlainObject> ldlt() const;
356 
358 
359  inline const HouseholderQR<PlainObject> householderQr() const;
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
377  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
400  inline Matrix<Scalar,3,1> eulerAngles(Index a0, Index a1, Index a2) const;
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 {
410  SizeMinusOne = SizeAtCompileTime==Dynamic ? Dynamic : SizeAtCompileTime-1
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
442  void applyOnTheLeft(Index p, Index q, const JacobiRotation<OtherScalar>& j);
443  template<typename OtherScalar>
444  EIGEN_DEVICE_FUNC
445  void applyOnTheRight(Index p, Index q, const JacobiRotation<OtherScalar>& j);
446 
448 
449  template<typename OtherDerived>
450  EIGEN_STRONG_INLINE const typename SparseMatrixBase<OtherDerived>::template CwiseProductDenseReturnType<Derived>::Type
451  cwiseProduct(const SparseMatrixBase<OtherDerived> &other) const
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_DEVICE_FUNC MatrixBase() : Base() {}
485 
486  private:
487  EIGEN_DEVICE_FUNC explicit MatrixBase(int);
488  EIGEN_DEVICE_FUNC MatrixBase(int,int);
489  template<typename OtherDerived> EIGEN_DEVICE_FUNC explicit MatrixBase(const MatrixBase<OtherDerived>&);
490  protected:
491  // mixing arrays and matrices is not legal
492  template<typename OtherDerived> Derived& operator+=(const ArrayBase<OtherDerived>& )
493  {EIGEN_STATIC_ASSERT(std::ptrdiff_t(sizeof(typename OtherDerived::Scalar))==-1,YOU_CANNOT_MIX_ARRAYS_AND_MATRICES); return *this;}
494  // mixing arrays and matrices is not legal
495  template<typename OtherDerived> Derived& operator-=(const ArrayBase<OtherDerived>& )
496  {EIGEN_STATIC_ASSERT(std::ptrdiff_t(sizeof(typename OtherDerived::Scalar))==-1,YOU_CANNOT_MIX_ARRAYS_AND_MATRICES); return *this;}
497 };
498 
499 
500 /***************************************************************************
501 * Implementation of matrix base methods
502 ***************************************************************************/
503 
511 template<typename Derived>
512 template<typename OtherDerived>
513 inline Derived&
515 {
516  other.derived().applyThisOnTheRight(derived());
517  return derived();
518 }
519 
525 template<typename Derived>
526 template<typename OtherDerived>
528 {
529  other.derived().applyThisOnTheRight(derived());
530 }
531 
537 template<typename Derived>
538 template<typename OtherDerived>
540 {
541  other.derived().applyThisOnTheLeft(derived());
542 }
543 
544 } // end namespace Eigen
545 
546 #endif // EIGEN_MATRIXBASE_H
const MatrixFunctionReturnValue< Derived > cosh() const
This function requires the unsupported MatrixFunctions module. To compute the coefficient-wise hyperb...
Generic expression of a matrix where all coefficients are defined by a functor.
Definition: CwiseNullaryOp.h:60
Scalar trace() const
Definition: Redux.h:500
Robust Cholesky decomposition of a matrix with pivoting.
Definition: LDLT.h:59
const MatrixFunctionReturnValue< Derived > asinh() const
This function requires the unsupported MatrixFunctions module. To compute the coefficient-wise invers...
const MatrixPowerReturnValue< Derived > pow(const RealScalar &p) const
This function requires the unsupported MatrixFunctions module. To compute the coefficient-wise power ...
void makeHouseholder(EssentialPart &essential, Scalar &tau, RealScalar &beta) const
Definition: Householder.h:67
RealScalar blueNorm() const
Definition: StableNorm.h:242
BDCSVD< PlainObject > bdcSvd(unsigned int computationOptions=0) const
Definition: BDCSVD.h:1342
const CwiseBinaryOp< std::not_equal_to< Scalar >, const Derived, const OtherDerived > cwiseNotEqual(const Eigen::MatrixBase< OtherDerived > &other) const
Definition: MatrixBase.h:64
internal::traits< Derived >::Scalar Scalar
Definition: DenseBase.h:66
Definition: Constants.h:318
Expression of the product of two arbitrary matrices or vectors.
Definition: Product.h:71
Expression of a mathematical vector or matrix as an array object.
Definition: ArrayWrapper.h:42
Householder rank-revealing QR decomposition of a matrix with full pivoting.
Definition: ForwardDeclarations.h:273
const AdjointReturnType adjoint() const
Definition: Transpose.h:219
const CompleteOrthogonalDecomposition< PlainObject > completeOrthogonalDecomposition() const
Definition: CompleteOrthogonalDecomposition.h:629
Definition: DenseBase.h:100
void applyOnTheLeft(const EigenBase< OtherDerived > &other)
Definition: MatrixBase.h:539
Definition: Constants.h:263
Pseudo expression providing an operator = assuming no aliasing.
Definition: NoAlias.h:31
Definition: DenseBase.h:106
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
Expression of the transpose of a matrix.
Definition: Transpose.h:52
static const BasisReturnType UnitW()
Definition: CwiseNullaryOp.h:881
bool isUnitary(const RealScalar &prec=NumTraits< Scalar >::dummy_precision()) const
Definition: Dot.h:302
const ColPivHouseholderQR< PlainObject > colPivHouseholderQr() const
Definition: ColPivHouseholderQR.h:667
const CwiseBinaryOp< std::equal_to< Scalar >, const Derived, const OtherDerived > cwiseEqual(const Eigen::MatrixBase< OtherDerived > &other) const
Definition: MatrixBase.h:44
void applyOnTheRight(const EigenBase< OtherDerived > &other)
Definition: MatrixBase.h:527
LU decomposition of a matrix with partial pivoting, and related features.
Definition: ForwardDeclarations.h:267
Namespace containing all symbols from the Eigen library.
Definition: Core:129
const MatrixFunctionReturnValue< Derived > sinh() const
This function requires the unsupported MatrixFunctions module. To compute the coefficient-wise hyperb...
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_square_op< typename Derived::Scalar >, const Derived > square(const Eigen::ArrayBase< Derived > &x)
Holds information about the various numeric (i.e. scalar) types allowed by Eigen. ...
Definition: NumTraits.h:191
const PlainObject normalized() const
Definition: Dot.h:124
const MatrixSquareRootReturnValue< Derived > sqrt() const
This function requires the unsupported MatrixFunctions module. To compute the coefficient-wise square...
Derived & setIdentity()
Definition: CwiseNullaryOp.h:794
Matrix< Scalar, 3, 1 > eulerAngles(Index a0, Index a1, Index a2) const
Definition: EulerAngles.h:37
Derived & derived()
Definition: EigenBase.h:46
Complete orthogonal decomposition (COD) of a matrix.
Definition: ForwardDeclarations.h:274
RealScalar stableNorm() const
Definition: StableNorm.h:226
Eigen::Index Index
The interface type of indices.
Definition: EigenBase.h:39
const FullPivLU< PlainObject > fullPivLu() const
Definition: FullPivLU.h:868
const unsigned int RowMajorBit
Definition: Constants.h:65
Base class for all dense matrices, vectors, and arrays.
Definition: DenseBase.h:41
PlainObject cross3(const MatrixBase< OtherDerived > &other) const
Definition: OrthoMethods.h:83
internal::traits< Derived >::StorageIndex StorageIndex
The type used to store indices.
Definition: DenseBase.h:63
Definition: EigenBase.h:29
void applyHouseholderOnTheLeft(const EssentialPart &essential, const Scalar &tau, Scalar *workspace)
Definition: Householder.h:116
PlainObject unitOrthogonal(void) const
Definition: OrthoMethods.h:227
void computeInverseAndDetWithCheck(ResultType &inverse, typename ResultType::Scalar &determinant, bool &invertible, const RealScalar &absDeterminantThreshold=NumTraits< Scalar >::dummy_precision()) const
Definition: InverseImpl.h:364
void normalize()
Definition: Dot.h:145
RealScalar norm() const
Definition: Dot.h:108
Expression of the inverse of another expression.
Definition: Inverse.h:43
bool operator!=(const MatrixBase< OtherDerived > &other) const
Definition: MatrixBase.h:298
bool isUpperTriangular(const RealScalar &prec=NumTraits< Scalar >::dummy_precision()) const
Definition: TriangularMatrix.h:663
static const BasisReturnType UnitX()
Definition: CwiseNullaryOp.h:851
Derived & operator+=(const MatrixBase< OtherDerived > &other)
Definition: CwiseBinaryOp.h:181
void stableNormalize()
Definition: Dot.h:191
const Derived & forceAlignedAccess() const
Definition: MatrixBase.h:305
RealScalar squaredNorm() const
Definition: Dot.h:96
Index size() const
Definition: EigenBase.h:67
JacobiSVD< PlainObject > jacobiSvd(unsigned int computationOptions=0) const
Definition: JacobiSVD.h:798
PlainObject cross(const MatrixBase< OtherDerived > &other) const
Definition: OrthoMethods.h:35
const MatrixFunctionReturnValue< Derived > cos() const
This function requires the unsupported MatrixFunctions module. To compute the coefficient-wise cosine...
Index rows() const
Definition: EigenBase.h:60
const MatrixLogarithmReturnValue< Derived > log() const
This function requires the unsupported MatrixFunctions module. To compute the coefficient-wise logari...
ArrayWrapper< Derived > array()
Definition: MatrixBase.h:319
Householder rank-revealing QR decomposition of a matrix with column-pivoting.
Definition: ForwardDeclarations.h:272
Standard Cholesky decomposition (LL^T) of a matrix and associated features.
Definition: LLT.h:66
const MatrixFunctionReturnValue< Derived > atanh() const
This function requires the unsupported MatrixFunctions module. To compute the coefficient-wise invers...
const HouseholderQR< PlainObject > householderQr() const
Definition: HouseholderQR.h:427
const ArrayWrapper< const Derived > array() const
Definition: MatrixBase.h:322
bool isDiagonal(const RealScalar &prec=NumTraits< Scalar >::dummy_precision()) const
Definition: DiagonalMatrix.h:339
const MatrixFunctionReturnValue< Derived > sin() const
This function requires the unsupported MatrixFunctions module. To compute the coefficient-wise sine u...
const DiagonalWrapper< const Derived > asDiagonal() const
Definition: DiagonalMatrix.h:325
const MatrixExponentialReturnValue< Derived > exp() const
This function requires the unsupported MatrixFunctions module. To compute the coefficient-wise expone...
static const BasisReturnType UnitY()
Definition: CwiseNullaryOp.h:861
void adjointInPlace()
Definition: Transpose.h:324
static const BasisReturnType Unit(Index size, Index i)
Definition: CwiseNullaryOp.h:823
const PartialPivLU< PlainObject > partialPivLu() const
Definition: PartialPivLU.h:597
class Bidiagonal Divide and Conquer SVD
Definition: ForwardDeclarations.h:277
const LDLT< PlainObject > ldlt() const
Definition: LDLT.h:681
Definition: Constants.h:266
const MatrixFunctionReturnValue< Derived > acosh() const
This function requires the unsupported MatrixFunctions module. To compute the coefficient-wise invers...
RealScalar operatorNorm() const
Computes the L2 operator norm.
Definition: MatrixBaseEigenvalues.h:120
const PlainObject stableNormalized() const
Definition: Dot.h:167
const Inverse< Derived > inverse() const
Definition: InverseImpl.h:337
bool isLowerTriangular(const RealScalar &prec=NumTraits< Scalar >::dummy_precision()) const
Definition: TriangularMatrix.h:688
const HNormalizedReturnType hnormalized() const
homogeneous normalization
Definition: Homogeneous.h:172
Definition: DenseBase.h:113
internal::conditional< internal::is_same< typename internal::traits< Derived >::XprKind, MatrixXpr >::value, PlainMatrix, PlainArray >::type PlainObject
The plain matrix or array type corresponding to this expression.
Definition: DenseBase.h:210
static const IdentityReturnType Identity()
Definition: CwiseNullaryOp.h:720
Expression of a fixed-size or dynamic-size block.
Definition: Block.h:103
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
Derived & operator-=(const MatrixBase< OtherDerived > &other)
Definition: CwiseBinaryOp.h:168
ScalarBinaryOpTraits< typename internal::traits< Derived >::Scalar, typename internal::traits< OtherDerived >::Scalar >::ReturnType dot(const MatrixBase< OtherDerived > &other) const
Definition: Dot.h:72
LU decomposition of a matrix with complete pivoting, and related features.
Definition: ForwardDeclarations.h:266
void applyHouseholderOnTheRight(const EssentialPart &essential, const Scalar &tau, Scalar *workspace)
Definition: Householder.h:154
RealScalar lpNorm() const
Definition: Dot.h:267
Householder QR decomposition of a matrix.
Definition: ForwardDeclarations.h:271
Two-sided Jacobi SVD decomposition of a rectangular matrix.
Definition: ForwardDeclarations.h:276
Derived & operator=(const MatrixBase &other)
Definition: Assign.h:55
Derived & forceAlignedAccess()
Definition: MatrixBase.h:306
const LLT< PlainObject > llt() const
Definition: LLT.h:540
Derived & operator*=(const EigenBase< OtherDerived > &other)
Definition: MatrixBase.h:514
DiagonalReturnType diagonal()
Definition: Diagonal.h:191
const MatrixFunctionReturnValue< Derived > matrixFunction(StemFunction f) const
Helper function for the unsupported MatrixFunctions module.
Determines whether the given binary operation of two numeric types is allowed and what the scalar ret...
Definition: XprHelper.h:806
NoAlias< Derived, Eigen::MatrixBase > noalias()
Definition: NoAlias.h:102
bool isOrthogonal(const MatrixBase< OtherDerived > &other, const RealScalar &prec=NumTraits< Scalar >::dummy_precision()) const
Definition: Dot.h:283
const PartialPivLU< PlainObject > lu() const
Definition: PartialPivLU.h:612
Expression of a diagonal/subdiagonal/superdiagonal in a matrix.
Definition: Diagonal.h:63
void makeHouseholderInPlace(Scalar &tau, RealScalar &beta)
Definition: Householder.h:43
const int Dynamic
Definition: Constants.h:21
bool isIdentity(const RealScalar &prec=NumTraits< Scalar >::dummy_precision()) const
Definition: CwiseNullaryOp.h:737
Generic expression where a coefficient-wise unary operator is applied to an expression.
Definition: CwiseUnaryOp.h:55
The matrix class, also used for vectors and row-vectors.
Definition: Matrix.h:178
void computeInverseWithCheck(ResultType &inverse, bool &invertible, const RealScalar &absDeterminantThreshold=NumTraits< Scalar >::dummy_precision()) const
Definition: InverseImpl.h:403
HomogeneousReturnType homogeneous() const
Definition: Homogeneous.h:130
Index cols() const
Definition: EigenBase.h:63
bool operator==(const MatrixBase< OtherDerived > &other) const
Definition: MatrixBase.h:290
Index diagonalSize() const
Definition: MatrixBase.h:102
const FullPivHouseholderQR< PlainObject > fullPivHouseholderQr() const
Definition: FullPivHouseholderQR.h:706
EigenvaluesReturnType eigenvalues() const
Computes the eigenvalues of a matrix.
Definition: MatrixBaseEigenvalues.h:67
Base class for all dense matrices, vectors, and expressions.
Definition: MatrixBase.h:48
const CwiseBinaryOp< internal::scalar_product_op< Scalar, T >, Derived, Constant< T > > operator*(const T &scalar) const
Scalar determinant() const
Definition: Determinant.h:108
static const BasisReturnType UnitZ()
Definition: CwiseNullaryOp.h:871
Derived & setUnit(Index i)
Set the coefficients of *this to the i-th unit (basis) vector.
Definition: CwiseNullaryOp.h:893
const Product< Derived, OtherDerived, LazyProduct > lazyProduct(const MatrixBase< OtherDerived > &other) const
Definition: GeneralProduct.h:444
RealScalar hypotNorm() const
Definition: StableNorm.h:254