Free cookie consent management tool by TermsFeed Policy Generator

source: branches/HeuristicLab.Problems.GaussianProcessTuning/HeuristicLab.Eigen/Eigen/src/Core/MatrixBase.h @ 9562

Last change on this file since 9562 was 9562, checked in by gkronber, 11 years ago

#1967 worked on Gaussian process evolution.
File size: 22.0 KB
Line 
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
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 TopicCustomizingEigen by defining the preprocessor symbol \c EIGEN_MATRIXBASE_PLUGIN.
45  *
46  * \sa \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>::Index Index;
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    using Base::CoeffReadCost;
70
71    using Base::derived;
72    using Base::const_cast_derived;
73    using Base::rows;
74    using Base::cols;
75    using Base::size;
76    using Base::coeff;
77    using Base::coeffRef;
78    using Base::lazyAssign;
79    using Base::eval;
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    inline Index diagonalSize() const { return (std::min)(rows(),cols()); }
102
103    /** \brief The plain matrix type corresponding to this expression.
104      *
105      * This is not necessarily exactly the return type of eval(). In the case of plain matrices,
106      * the return type of eval() is a const reference to a matrix, not a matrix! It is however guaranteed
107      * that the return type of eval() is either PlainObject or const PlainObject&.
108      */
109    typedef Matrix<typename internal::traits<Derived>::Scalar,
110                internal::traits<Derived>::RowsAtCompileTime,
111                internal::traits<Derived>::ColsAtCompileTime,
112                AutoAlign | (internal::traits<Derived>::Flags&RowMajorBit ? RowMajor : ColMajor),
113                internal::traits<Derived>::MaxRowsAtCompileTime,
114                internal::traits<Derived>::MaxColsAtCompileTime
115          > PlainObject;
116
117#ifndef EIGEN_PARSED_BY_DOXYGEN
118    /** \internal Represents a matrix with all coefficients equal to one another*/
119    typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,Derived> ConstantReturnType;
120    /** \internal the return type of MatrixBase::adjoint() */
121    typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
122                        CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, ConstTransposeReturnType>,
123                        ConstTransposeReturnType
124                     >::type AdjointReturnType;
125    /** \internal Return type of eigenvalues() */
126    typedef Matrix<std::complex<RealScalar>, internal::traits<Derived>::ColsAtCompileTime, 1, ColMajor> EigenvaluesReturnType;
127    /** \internal the return type of identity */
128    typedef CwiseNullaryOp<internal::scalar_identity_op<Scalar>,Derived> IdentityReturnType;
129    /** \internal the return type of unit vectors */
130    typedef Block<const CwiseNullaryOp<internal::scalar_identity_op<Scalar>, SquareMatrixType>,
131                  internal::traits<Derived>::RowsAtCompileTime,
132                  internal::traits<Derived>::ColsAtCompileTime> BasisReturnType;
133#endif // not EIGEN_PARSED_BY_DOXYGEN
134
135#define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::MatrixBase
136#   include "../plugins/CommonCwiseUnaryOps.h"
137#   include "../plugins/CommonCwiseBinaryOps.h"
138#   include "../plugins/MatrixCwiseUnaryOps.h"
139#   include "../plugins/MatrixCwiseBinaryOps.h"
140#   ifdef EIGEN_MATRIXBASE_PLUGIN
141#     include EIGEN_MATRIXBASE_PLUGIN
142#   endif
143#undef EIGEN_CURRENT_STORAGE_BASE_CLASS
144
145    /** Special case of the template operator=, in order to prevent the compiler
146      * from generating a default operator= (issue hit with g++ 4.1)
147      */
148    Derived& operator=(const MatrixBase& other);
149
150    // We cannot inherit here via Base::operator= since it is causing
151    // trouble with MSVC.
152
153    template <typename OtherDerived>
154    Derived& operator=(const DenseBase<OtherDerived>& other);
155
156    template <typename OtherDerived>
157    Derived& operator=(const EigenBase<OtherDerived>& other);
158
159    template<typename OtherDerived>
160    Derived& operator=(const ReturnByValue<OtherDerived>& other);
161
162#ifndef EIGEN_PARSED_BY_DOXYGEN
163    template<typename ProductDerived, typename Lhs, typename Rhs>
164    Derived& lazyAssign(const ProductBase<ProductDerived, Lhs,Rhs>& other);
165#endif // not EIGEN_PARSED_BY_DOXYGEN
166
167    template<typename OtherDerived>
168    Derived& operator+=(const MatrixBase<OtherDerived>& other);
169    template<typename OtherDerived>
170    Derived& operator-=(const MatrixBase<OtherDerived>& other);
171
172    template<typename OtherDerived>
173    const typename ProductReturnType<Derived,OtherDerived>::Type
174    operator*(const MatrixBase<OtherDerived> &other) const;
175
176    template<typename OtherDerived>
177    const typename LazyProductReturnType<Derived,OtherDerived>::Type
178    lazyProduct(const MatrixBase<OtherDerived> &other) const;
179
180    template<typename OtherDerived>
181    Derived& operator*=(const EigenBase<OtherDerived>& other);
182
183    template<typename OtherDerived>
184    void applyOnTheLeft(const EigenBase<OtherDerived>& other);
185
186    template<typename OtherDerived>
187    void applyOnTheRight(const EigenBase<OtherDerived>& other);
188
189    template<typename DiagonalDerived>
190    const DiagonalProduct<Derived, DiagonalDerived, OnTheRight>
191    operator*(const DiagonalBase<DiagonalDerived> &diagonal) const;
192
193    template<typename OtherDerived>
194    typename internal::scalar_product_traits<typename internal::traits<Derived>::Scalar,typename internal::traits<OtherDerived>::Scalar>::ReturnType
195    dot(const MatrixBase<OtherDerived>& other) const;
196
197    #ifdef EIGEN2_SUPPORT
198      template<typename OtherDerived>
199      Scalar eigen2_dot(const MatrixBase<OtherDerived>& other) const;
200    #endif
201
202    RealScalar squaredNorm() const;
203    RealScalar norm() const;
204    RealScalar stableNorm() const;
205    RealScalar blueNorm() const;
206    RealScalar hypotNorm() const;
207    const PlainObject normalized() const;
208    void normalize();
209
210    const AdjointReturnType adjoint() const;
211    void adjointInPlace();
212
213    typedef Diagonal<Derived> DiagonalReturnType;
214    DiagonalReturnType diagonal();
215    typedef const Diagonal<const Derived> ConstDiagonalReturnType;
216    const ConstDiagonalReturnType diagonal() const;
217
218    template<int Index> struct DiagonalIndexReturnType { typedef Diagonal<Derived,Index> Type; };
219    template<int Index> struct ConstDiagonalIndexReturnType { typedef const Diagonal<const Derived,Index> Type; };
220
221    template<int Index> typename DiagonalIndexReturnType<Index>::Type diagonal();
222    template<int Index> typename ConstDiagonalIndexReturnType<Index>::Type diagonal() const;
223
224    // Note: The "MatrixBase::" prefixes are added to help MSVC9 to match these declarations with the later implementations.
225    // On the other hand they confuse MSVC8...
226    #if (defined _MSC_VER) && (_MSC_VER >= 1500) // 2008 or later
227    typename MatrixBase::template DiagonalIndexReturnType<Dynamic>::Type diagonal(Index index);
228    typename MatrixBase::template ConstDiagonalIndexReturnType<Dynamic>::Type diagonal(Index index) const;
229    #else
230    typename DiagonalIndexReturnType<Dynamic>::Type diagonal(Index index);
231    typename ConstDiagonalIndexReturnType<Dynamic>::Type diagonal(Index index) const;
232    #endif
233
234    #ifdef EIGEN2_SUPPORT
235    template<unsigned int Mode> typename internal::eigen2_part_return_type<Derived, Mode>::type part();
236    template<unsigned int Mode> const typename internal::eigen2_part_return_type<Derived, Mode>::type part() const;
237   
238    // huuuge hack. make Eigen2's matrix.part<Diagonal>() work in eigen3. Problem: Diagonal is now a class template instead
239    // of an integer constant. Solution: overload the part() method template wrt template parameters list.
240    template<template<typename T, int N> class U>
241    const DiagonalWrapper<ConstDiagonalReturnType> part() const
242    { return diagonal().asDiagonal(); }
243    #endif // EIGEN2_SUPPORT
244
245    template<unsigned int Mode> struct TriangularViewReturnType { typedef TriangularView<Derived, Mode> Type; };
246    template<unsigned int Mode> struct ConstTriangularViewReturnType { typedef const TriangularView<const Derived, Mode> Type; };
247
248    template<unsigned int Mode> typename TriangularViewReturnType<Mode>::Type triangularView();
249    template<unsigned int Mode> typename ConstTriangularViewReturnType<Mode>::Type triangularView() const;
250
251    template<unsigned int UpLo> struct SelfAdjointViewReturnType { typedef SelfAdjointView<Derived, UpLo> Type; };
252    template<unsigned int UpLo> struct ConstSelfAdjointViewReturnType { typedef const SelfAdjointView<const Derived, UpLo> Type; };
253
254    template<unsigned int UpLo> typename SelfAdjointViewReturnType<UpLo>::Type selfadjointView();
255    template<unsigned int UpLo> typename ConstSelfAdjointViewReturnType<UpLo>::Type selfadjointView() const;
256
257    const SparseView<Derived> sparseView(const Scalar& m_reference = Scalar(0),
258                                         typename NumTraits<Scalar>::Real m_epsilon = NumTraits<Scalar>::dummy_precision()) const;
259    static const IdentityReturnType Identity();
260    static const IdentityReturnType Identity(Index rows, Index cols);
261    static const BasisReturnType Unit(Index size, Index i);
262    static const BasisReturnType Unit(Index i);
263    static const BasisReturnType UnitX();
264    static const BasisReturnType UnitY();
265    static const BasisReturnType UnitZ();
266    static const BasisReturnType UnitW();
267
268    const DiagonalWrapper<const Derived> asDiagonal() const;
269    const PermutationWrapper<const Derived> asPermutation() const;
270
271    Derived& setIdentity();
272    Derived& setIdentity(Index rows, Index cols);
273
274    bool isIdentity(RealScalar prec = NumTraits<Scalar>::dummy_precision()) const;
275    bool isDiagonal(RealScalar prec = NumTraits<Scalar>::dummy_precision()) const;
276
277    bool isUpperTriangular(RealScalar prec = NumTraits<Scalar>::dummy_precision()) const;
278    bool isLowerTriangular(RealScalar prec = NumTraits<Scalar>::dummy_precision()) const;
279
280    template<typename OtherDerived>
281    bool isOrthogonal(const MatrixBase<OtherDerived>& other,
282                      RealScalar prec = NumTraits<Scalar>::dummy_precision()) const;
283    bool isUnitary(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    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    inline bool operator!=(const MatrixBase<OtherDerived>& other) const
299    { return cwiseNotEqual(other).any(); }
300
301    NoAlias<Derived,Eigen::MatrixBase > noalias();
302
303    inline const ForceAlignedAccess<Derived> forceAlignedAccess() const;
304    inline ForceAlignedAccess<Derived> forceAlignedAccess();
305    template<bool Enable> inline typename internal::add_const_on_value_type<typename internal::conditional<Enable,ForceAlignedAccess<Derived>,Derived&>::type>::type forceAlignedAccessIf() const;
306    template<bool Enable> inline typename internal::conditional<Enable,ForceAlignedAccess<Derived>,Derived&>::type forceAlignedAccessIf();
307
308    Scalar trace() const;
309
310/////////// Array module ///////////
311
312    template<int p> RealScalar lpNorm() const;
313
314    MatrixBase<Derived>& matrix() { return *this; }
315    const MatrixBase<Derived>& matrix() const { return *this; }
316
317    /** \returns an \link ArrayBase Array \endlink expression of this matrix
318      * \sa ArrayBase::matrix() */
319    ArrayWrapper<Derived> array() { return derived(); }
320    const ArrayWrapper<const Derived> array() const { return derived(); }
321
322/////////// LU module ///////////
323
324    const FullPivLU<PlainObject> fullPivLu() const;
325    const PartialPivLU<PlainObject> partialPivLu() const;
326
327    #if EIGEN2_SUPPORT_STAGE < STAGE20_RESOLVE_API_CONFLICTS
328    const LU<PlainObject> lu() const;
329    #endif
330
331    #ifdef EIGEN2_SUPPORT
332    const LU<PlainObject> eigen2_lu() const;
333    #endif
334
335    #if EIGEN2_SUPPORT_STAGE > STAGE20_RESOLVE_API_CONFLICTS
336    const PartialPivLU<PlainObject> lu() const;
337    #endif
338   
339    #ifdef EIGEN2_SUPPORT
340    template<typename ResultType>
341    void computeInverse(MatrixBase<ResultType> *result) const {
342      *result = this->inverse();
343    }
344    #endif
345
346    const internal::inverse_impl<Derived> inverse() const;
347    template<typename ResultType>
348    void computeInverseAndDetWithCheck(
349      ResultType& inverse,
350      typename ResultType::Scalar& determinant,
351      bool& invertible,
352      const RealScalar& absDeterminantThreshold = NumTraits<Scalar>::dummy_precision()
353    ) const;
354    template<typename ResultType>
355    void computeInverseWithCheck(
356      ResultType& inverse,
357      bool& invertible,
358      const RealScalar& absDeterminantThreshold = NumTraits<Scalar>::dummy_precision()
359    ) const;
360    Scalar determinant() const;
361
362/////////// Cholesky module ///////////
363
364    const LLT<PlainObject>  llt() const;
365    const LDLT<PlainObject> ldlt() const;
366
367/////////// QR module ///////////
368
369    const HouseholderQR<PlainObject> householderQr() const;
370    const ColPivHouseholderQR<PlainObject> colPivHouseholderQr() const;
371    const FullPivHouseholderQR<PlainObject> fullPivHouseholderQr() const;
372   
373    #ifdef EIGEN2_SUPPORT
374    const QR<PlainObject> qr() const;
375    #endif
376
377    EigenvaluesReturnType eigenvalues() const;
378    RealScalar operatorNorm() const;
379
380/////////// SVD module ///////////
381
382    JacobiSVD<PlainObject> jacobiSvd(unsigned int computationOptions = 0) const;
383
384    #ifdef EIGEN2_SUPPORT
385    SVD<PlainObject> svd() const;
386    #endif
387
388/////////// Geometry module ///////////
389
390    #ifndef EIGEN_PARSED_BY_DOXYGEN
391    /// \internal helper struct to form the return type of the cross product
392    template<typename OtherDerived> struct cross_product_return_type {
393      typedef typename internal::scalar_product_traits<typename internal::traits<Derived>::Scalar,typename internal::traits<OtherDerived>::Scalar>::ReturnType Scalar;
394      typedef Matrix<Scalar,MatrixBase::RowsAtCompileTime,MatrixBase::ColsAtCompileTime> type;
395    };
396    #endif // EIGEN_PARSED_BY_DOXYGEN
397    template<typename OtherDerived>
398    typename cross_product_return_type<OtherDerived>::type
399    cross(const MatrixBase<OtherDerived>& other) const;
400    template<typename OtherDerived>
401    PlainObject cross3(const MatrixBase<OtherDerived>& other) const;
402    PlainObject unitOrthogonal(void) const;
403    Matrix<Scalar,3,1> eulerAngles(Index a0, Index a1, Index a2) const;
404   
405    #if EIGEN2_SUPPORT_STAGE > STAGE20_RESOLVE_API_CONFLICTS
406    ScalarMultipleReturnType operator*(const UniformScaling<Scalar>& s) const;
407    // put this as separate enum value to work around possible GCC 4.3 bug (?)
408    enum { HomogeneousReturnTypeDirection = ColsAtCompileTime==1?Vertical:Horizontal };
409    typedef Homogeneous<Derived, HomogeneousReturnTypeDirection> HomogeneousReturnType;
410    HomogeneousReturnType homogeneous() const;
411    #endif
412   
413    enum {
414      SizeMinusOne = SizeAtCompileTime==Dynamic ? Dynamic : SizeAtCompileTime-1
415    };
416    typedef Block<const Derived,
417                  internal::traits<Derived>::ColsAtCompileTime==1 ? SizeMinusOne : 1,
418                  internal::traits<Derived>::ColsAtCompileTime==1 ? 1 : SizeMinusOne> ConstStartMinusOne;
419    typedef CwiseUnaryOp<internal::scalar_quotient1_op<typename internal::traits<Derived>::Scalar>,
420                const ConstStartMinusOne > HNormalizedReturnType;
421
422    const HNormalizedReturnType hnormalized() const;
423
424////////// Householder module ///////////
425
426    void makeHouseholderInPlace(Scalar& tau, RealScalar& beta);
427    template<typename EssentialPart>
428    void makeHouseholder(EssentialPart& essential,
429                         Scalar& tau, RealScalar& beta) const;
430    template<typename EssentialPart>
431    void applyHouseholderOnTheLeft(const EssentialPart& essential,
432                                   const Scalar& tau,
433                                   Scalar* workspace);
434    template<typename EssentialPart>
435    void applyHouseholderOnTheRight(const EssentialPart& essential,
436                                    const Scalar& tau,
437                                    Scalar* workspace);
438
439///////// Jacobi module /////////
440
441    template<typename OtherScalar>
442    void applyOnTheLeft(Index p, Index q, const JacobiRotation<OtherScalar>& j);
443    template<typename OtherScalar>
444    void applyOnTheRight(Index p, Index q, const JacobiRotation<OtherScalar>& j);
445
446///////// MatrixFunctions module /////////
447
448    typedef typename internal::stem_function<Scalar>::type StemFunction;
449    const MatrixExponentialReturnValue<Derived> exp() const;
450    const MatrixFunctionReturnValue<Derived> matrixFunction(StemFunction f) const;
451    const MatrixFunctionReturnValue<Derived> cosh() const;
452    const MatrixFunctionReturnValue<Derived> sinh() const;
453    const MatrixFunctionReturnValue<Derived> cos() const;
454    const MatrixFunctionReturnValue<Derived> sin() const;
455    const MatrixSquareRootReturnValue<Derived> sqrt() const;
456    const MatrixLogarithmReturnValue<Derived> log() const;
457
458#ifdef EIGEN2_SUPPORT
459    template<typename ProductDerived, typename Lhs, typename Rhs>
460    Derived& operator+=(const Flagged<ProductBase<ProductDerived, Lhs,Rhs>, 0,
461                                      EvalBeforeAssigningBit>& other);
462
463    template<typename ProductDerived, typename Lhs, typename Rhs>
464    Derived& operator-=(const Flagged<ProductBase<ProductDerived, Lhs,Rhs>, 0,
465                                      EvalBeforeAssigningBit>& other);
466
467    /** \deprecated because .lazy() is deprecated
468      * Overloaded for cache friendly product evaluation */
469    template<typename OtherDerived>
470    Derived& lazyAssign(const Flagged<OtherDerived, 0, EvalBeforeAssigningBit>& other)
471    { return lazyAssign(other._expression()); }
472
473    template<unsigned int Added>
474    const Flagged<Derived, Added, 0> marked() const;
475    const Flagged<Derived, 0, EvalBeforeAssigningBit> lazy() const;
476
477    inline const Cwise<Derived> cwise() const;
478    inline Cwise<Derived> cwise();
479
480    VectorBlock<Derived> start(Index size);
481    const VectorBlock<const Derived> start(Index size) const;
482    VectorBlock<Derived> end(Index size);
483    const VectorBlock<const Derived> end(Index size) const;
484    template<int Size> VectorBlock<Derived,Size> start();
485    template<int Size> const VectorBlock<const Derived,Size> start() const;
486    template<int Size> VectorBlock<Derived,Size> end();
487    template<int Size> const VectorBlock<const Derived,Size> end() const;
488
489    Minor<Derived> minor(Index row, Index col);
490    const Minor<Derived> minor(Index row, Index col) const;
491#endif
492
493  protected:
494    MatrixBase() : Base() {}
495
496  private:
497    explicit MatrixBase(int);
498    MatrixBase(int,int);
499    template<typename OtherDerived> explicit MatrixBase(const MatrixBase<OtherDerived>&);
500  protected:
501    // mixing arrays and matrices is not legal
502    template<typename OtherDerived> Derived& operator+=(const ArrayBase<OtherDerived>& )
503    {EIGEN_STATIC_ASSERT(std::ptrdiff_t(sizeof(typename OtherDerived::Scalar))==-1,YOU_CANNOT_MIX_ARRAYS_AND_MATRICES); return *this;}
504    // mixing arrays and matrices is not legal
505    template<typename OtherDerived> Derived& operator-=(const ArrayBase<OtherDerived>& )
506    {EIGEN_STATIC_ASSERT(std::ptrdiff_t(sizeof(typename OtherDerived::Scalar))==-1,YOU_CANNOT_MIX_ARRAYS_AND_MATRICES); return *this;}
507};
508
509} // end namespace Eigen
510
511#endif // EIGEN_MATRIXBASE_H
Note: See TracBrowser for help on using the repository browser.