Branch data Line data Source code
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 : :
16 : : /** \class MatrixBase
17 : : * \ingroup Core_Module
18 : : *
19 : : * \brief Base class for all dense matrices, vectors, and expressions
20 : : *
21 : : * This class is the base that is inherited by all matrix, vector, and related expression
22 : : * types. Most of the Eigen API is contained in this class, and its base classes. Other important
23 : : * classes for the Eigen API are Matrix, and VectorwiseOp.
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 : : */
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 : : /** type of the equivalent square matrix */
95 : : typedef Matrix<Scalar,EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime),
96 : : EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime)> SquareMatrixType;
97 : : #endif // not EIGEN_PARSED_BY_DOXYGEN
98 : :
99 : : /** \returns the size of the main diagonal, which is min(rows(),cols()).
100 : : * \sa rows(), cols(), SizeAtCompileTime. */
101 : : EIGEN_DEVICE_FUNC
102 : : inline Index diagonalSize() const { return (numext::mini)(rows(),cols()); }
103 : :
104 : : typedef typename Base::PlainObject PlainObject;
105 : :
106 : : #ifndef EIGEN_PARSED_BY_DOXYGEN
107 : : /** \internal Represents a matrix with all coefficients equal to one another*/
108 : : typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,PlainObject> ConstantReturnType;
109 : : /** \internal the return type of MatrixBase::adjoint() */
110 : : typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
111 : : CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, ConstTransposeReturnType>,
112 : : ConstTransposeReturnType
113 : : >::type AdjointReturnType;
114 : : /** \internal Return type of eigenvalues() */
115 : : typedef Matrix<std::complex<RealScalar>, internal::traits<Derived>::ColsAtCompileTime, 1, ColMajor> EigenvaluesReturnType;
116 : : /** \internal the return type of identity */
117 : : typedef CwiseNullaryOp<internal::scalar_identity_op<Scalar>,PlainObject> IdentityReturnType;
118 : : /** \internal the return type of unit vectors */
119 : : typedef Block<const CwiseNullaryOp<internal::scalar_identity_op<Scalar>, SquareMatrixType>,
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 : :
135 : : /** Special case of the template operator=, in order to prevent the compiler
136 : : * from generating a default operator= (issue hit with g++ 4.1)
137 : : */
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
165 : : const Product<Derived,OtherDerived>
166 : : operator*(const MatrixBase<OtherDerived> &other) const;
167 : :
168 : : template<typename OtherDerived>
169 : : EIGEN_DEVICE_FUNC
170 : : const Product<Derived,OtherDerived,LazyProduct>
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
184 : : const Product<Derived, DiagonalDerived, LazyProduct>
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
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 : :
285 : : /** \returns true if each coefficients of \c *this and \a other are all exactly equal.
286 : : * \warning When using floating point scalar values you probably should rather use a
287 : : * fuzzy comparison such as isApprox()
288 : : * \sa isApprox(), operator!= */
289 : : template<typename OtherDerived>
290 : : EIGEN_DEVICE_FUNC inline bool operator==(const MatrixBase<OtherDerived>& other) const
291 : : { return cwiseEqual(other).all(); }
292 : :
293 : : /** \returns true if at least one pair of coefficients of \c *this and \a other are not exactly equal to each other.
294 : : * \warning When using floating point scalar values you probably should rather use a
295 : : * fuzzy comparison such as isApprox()
296 : : * \sa isApprox(), operator== */
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 : :
317 : : /** \returns an \link Eigen::ArrayBase Array \endlink expression of this matrix
318 : : * \sa ArrayBase::matrix() */
319 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ArrayWrapper<Derived> array() { return ArrayWrapper<Derived>(derived()); }
320 : : /** \returns a const \link Eigen::ArrayBase Array \endlink expression of this matrix
321 : : * \sa ArrayBase::matrix() */
322 : : EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const ArrayWrapper<const Derived> array() const { return ArrayWrapper<const Derived>(derived()); }
323 : :
324 : : /////////// LU module ///////////
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 : :
352 : : /////////// Cholesky module ///////////
353 : :
354 : : inline const LLT<PlainObject> llt() const;
355 : : inline const LDLT<PlainObject> ldlt() const;
356 : :
357 : : /////////// QR module ///////////
358 : :
359 : : inline const HouseholderQR<PlainObject> householderQr() const;
360 : : inline const ColPivHouseholderQR<PlainObject> colPivHouseholderQr() const;
361 : : inline const FullPivHouseholderQR<PlainObject> fullPivHouseholderQr() const;
362 : : inline const CompleteOrthogonalDecomposition<PlainObject> completeOrthogonalDecomposition() const;
363 : :
364 : : /////////// Eigenvalues module ///////////
365 : :
366 : : inline EigenvaluesReturnType eigenvalues() const;
367 : : inline RealScalar operatorNorm() const;
368 : :
369 : : /////////// SVD module ///////////
370 : :
371 : : inline JacobiSVD<PlainObject> jacobiSvd(unsigned int computationOptions = 0) const;
372 : : inline BDCSVD<PlainObject> bdcSvd(unsigned int computationOptions = 0) const;
373 : :
374 : : /////////// Geometry module ///////////
375 : :
376 : : #ifndef EIGEN_PARSED_BY_DOXYGEN
377 : : /// \internal helper struct to form the return type of the cross product
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;
380 : : typedef Matrix<Scalar,MatrixBase::RowsAtCompileTime,MatrixBase::ColsAtCompileTime> type;
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)
404 : : : ColsAtCompileTime==1 ? Vertical : Horizontal };
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 : :
419 : : ////////// Householder module ///////////
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 : :
438 : : ///////// Jacobi module /////////
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 : :
447 : : ///////// SparseCore module /////////
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 : :
456 : : ///////// MatrixFunctions module /////////
457 : :
458 : : typedef typename internal::stem_function<Scalar>::type StemFunction;
459 : : #define EIGEN_MATRIX_FUNCTION(ReturnType, Name, Description) \
460 : : /** \returns an expression of the matrix Description of \c *this. \brief This function requires the <a href="unsupported/group__MatrixFunctions__Module.html"> unsupported MatrixFunctions module</a>. To compute the coefficient-wise Description use ArrayBase::##Name . */ \
461 : : const ReturnType<Derived> Name() const;
462 : : #define EIGEN_MATRIX_FUNCTION_1(ReturnType, Name, Description, Argument) \
463 : : /** \returns an expression of the matrix Description of \c *this. \brief This function requires the <a href="unsupported/group__MatrixFunctions__Module.html"> unsupported MatrixFunctions module</a>. To compute the coefficient-wise Description use ArrayBase::##Name . */ \
464 : : const ReturnType<Derived> Name(Argument) const;
465 : :
466 : : EIGEN_MATRIX_FUNCTION(MatrixExponentialReturnValue, exp, exponential)
467 : : /** \brief Helper function for the <a href="unsupported/group__MatrixFunctions__Module.html"> unsupported MatrixFunctions module</a>.*/
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 : 352363 : 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 : :
505 : : /** replaces \c *this by \c *this * \a other.
506 : : *
507 : : * \returns a reference to \c *this
508 : : *
509 : : * Example: \include MatrixBase_applyOnTheRight.cpp
510 : : * Output: \verbinclude MatrixBase_applyOnTheRight.out
511 : : */
512 : : template<typename Derived>
513 : : template<typename OtherDerived>
514 : : inline Derived&
515 : : MatrixBase<Derived>::operator*=(const EigenBase<OtherDerived> &other)
516 : : {
517 : : other.derived().applyThisOnTheRight(derived());
518 : : return derived();
519 : : }
520 : :
521 : : /** replaces \c *this by \c *this * \a other. It is equivalent to MatrixBase::operator*=().
522 : : *
523 : : * Example: \include MatrixBase_applyOnTheRight.cpp
524 : : * Output: \verbinclude MatrixBase_applyOnTheRight.out
525 : : */
526 : : template<typename Derived>
527 : : template<typename OtherDerived>
528 : : inline void MatrixBase<Derived>::applyOnTheRight(const EigenBase<OtherDerived> &other)
529 : : {
530 : : other.derived().applyThisOnTheRight(derived());
531 : : }
532 : :
533 : : /** replaces \c *this by \a other * \c *this.
534 : : *
535 : : * Example: \include MatrixBase_applyOnTheLeft.cpp
536 : : * Output: \verbinclude MatrixBase_applyOnTheLeft.out
537 : : */
538 : : template<typename Derived>
539 : : template<typename OtherDerived>
540 : : inline void MatrixBase<Derived>::applyOnTheLeft(const EigenBase<OtherDerived> &other)
541 : : {
542 : : other.derived().applyThisOnTheLeft(derived());
543 : : }
544 : :
545 : : } // end namespace Eigen
546 : :
547 : : #endif // EIGEN_MATRIXBASE_H
|
