MatrixBase.h (23856B)
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 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