Merge of itasc branch. Project files, scons and cmake should be working. Makefile...
[blender.git] / extern / Eigen2 / Eigen / src / Core / MatrixBase.h
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra. Eigen itself is part of the KDE project.
3 //
4 // Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
5 // Copyright (C) 2008 Gael Guennebaud <g.gael@free.fr>
6 //
7 // Eigen is free software; you can redistribute it and/or
8 // modify it under the terms of the GNU Lesser General Public
9 // License as published by the Free Software Foundation; either
10 // version 3 of the License, or (at your option) any later version.
11 //
12 // Alternatively, you can redistribute it and/or
13 // modify it under the terms of the GNU General Public License as
14 // published by the Free Software Foundation; either version 2 of
15 // the License, or (at your option) any later version.
16 //
17 // Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
18 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
19 // FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
20 // GNU General Public License for more details.
21 //
22 // You should have received a copy of the GNU Lesser General Public
23 // License and a copy of the GNU General Public License along with
24 // Eigen. If not, see <http://www.gnu.org/licenses/>.
25
26 #ifndef EIGEN_MATRIXBASE_H
27 #define EIGEN_MATRIXBASE_H
28
29 /** \class MatrixBase
30   *
31   * \brief Base class for all matrices, vectors, and expressions
32   *
33   * This class is the base that is inherited by all matrix, vector, and expression
34   * types. Most of the Eigen API is contained in this class. Other important classes for
35   * the Eigen API are Matrix, Cwise, and PartialRedux.
36   *
37   * Note that some methods are defined in the \ref Array module.
38   *
39   * \param Derived is the derived type, e.g. a matrix type, or an expression, etc.
40   *
41   * When writing a function taking Eigen objects as argument, if you want your function
42   * to take as argument any matrix, vector, or expression, just let it take a
43   * MatrixBase argument. As an example, here is a function printFirstRow which, given
44   * a matrix, vector, or expression \a x, prints the first row of \a x.
45   *
46   * \code
47     template<typename Derived>
48     void printFirstRow(const Eigen::MatrixBase<Derived>& x)
49     {
50       cout << x.row(0) << endl;
51     }
52   * \endcode
53   *
54   */
55 template<typename Derived> class MatrixBase
56 {
57   public:
58
59 #ifndef EIGEN_PARSED_BY_DOXYGEN
60     class InnerIterator;
61
62     typedef typename ei_traits<Derived>::Scalar Scalar;
63     typedef typename ei_packet_traits<Scalar>::type PacketScalar;
64 #endif // not EIGEN_PARSED_BY_DOXYGEN
65
66     enum {
67
68       RowsAtCompileTime = ei_traits<Derived>::RowsAtCompileTime,
69         /**< The number of rows at compile-time. This is just a copy of the value provided
70           * by the \a Derived type. If a value is not known at compile-time,
71           * it is set to the \a Dynamic constant.
72           * \sa MatrixBase::rows(), MatrixBase::cols(), ColsAtCompileTime, SizeAtCompileTime */
73
74       ColsAtCompileTime = ei_traits<Derived>::ColsAtCompileTime,
75         /**< The number of columns at compile-time. This is just a copy of the value provided
76           * by the \a Derived type. If a value is not known at compile-time,
77           * it is set to the \a Dynamic constant.
78           * \sa MatrixBase::rows(), MatrixBase::cols(), RowsAtCompileTime, SizeAtCompileTime */
79
80
81       SizeAtCompileTime = (ei_size_at_compile_time<ei_traits<Derived>::RowsAtCompileTime,
82                                                    ei_traits<Derived>::ColsAtCompileTime>::ret),
83         /**< This is equal to the number of coefficients, i.e. the number of
84           * rows times the number of columns, or to \a Dynamic if this is not
85           * known at compile-time. \sa RowsAtCompileTime, ColsAtCompileTime */
86
87       MaxRowsAtCompileTime = ei_traits<Derived>::MaxRowsAtCompileTime,
88         /**< This value is equal to the maximum possible number of rows that this expression
89           * might have. If this expression might have an arbitrarily high number of rows,
90           * this value is set to \a Dynamic.
91           *
92           * This value is useful to know when evaluating an expression, in order to determine
93           * whether it is possible to avoid doing a dynamic memory allocation.
94           *
95           * \sa RowsAtCompileTime, MaxColsAtCompileTime, MaxSizeAtCompileTime
96           */
97
98       MaxColsAtCompileTime = ei_traits<Derived>::MaxColsAtCompileTime,
99         /**< This value is equal to the maximum possible number of columns that this expression
100           * might have. If this expression might have an arbitrarily high number of columns,
101           * this value is set to \a Dynamic.
102           *
103           * This value is useful to know when evaluating an expression, in order to determine
104           * whether it is possible to avoid doing a dynamic memory allocation.
105           *
106           * \sa ColsAtCompileTime, MaxRowsAtCompileTime, MaxSizeAtCompileTime
107           */
108
109       MaxSizeAtCompileTime = (ei_size_at_compile_time<ei_traits<Derived>::MaxRowsAtCompileTime,
110                                                       ei_traits<Derived>::MaxColsAtCompileTime>::ret),
111         /**< This value is equal to the maximum possible number of coefficients that this expression
112           * might have. If this expression might have an arbitrarily high number of coefficients,
113           * this value is set to \a Dynamic.
114           *
115           * This value is useful to know when evaluating an expression, in order to determine
116           * whether it is possible to avoid doing a dynamic memory allocation.
117           *
118           * \sa SizeAtCompileTime, MaxRowsAtCompileTime, MaxColsAtCompileTime
119           */
120
121       IsVectorAtCompileTime = ei_traits<Derived>::RowsAtCompileTime == 1
122                            || ei_traits<Derived>::ColsAtCompileTime == 1,
123         /**< This is set to true if either the number of rows or the number of
124           * columns is known at compile-time to be equal to 1. Indeed, in that case,
125           * we are dealing with a column-vector (if there is only one column) or with
126           * a row-vector (if there is only one row). */
127
128       Flags = ei_traits<Derived>::Flags,
129         /**< This stores expression \ref flags flags which may or may not be inherited by new expressions
130           * constructed from this one. See the \ref flags "list of flags".
131           */
132
133       CoeffReadCost = ei_traits<Derived>::CoeffReadCost
134         /**< This is a rough measure of how expensive it is to read one coefficient from
135           * this expression.
136           */
137     };
138
139     /** Default constructor. Just checks at compile-time for self-consistency of the flags. */
140     MatrixBase()
141     {
142       ei_assert(ei_are_flags_consistent<Flags>::ret);
143     }
144
145 #ifndef EIGEN_PARSED_BY_DOXYGEN
146     /** This is the "real scalar" type; if the \a Scalar type is already real numbers
147       * (e.g. int, float or double) then \a RealScalar is just the same as \a Scalar. If
148       * \a Scalar is \a std::complex<T> then RealScalar is \a T.
149       *
150       * \sa class NumTraits
151       */
152     typedef typename NumTraits<Scalar>::Real RealScalar;
153
154     /** type of the equivalent square matrix */
155     typedef Matrix<Scalar,EIGEN_ENUM_MAX(RowsAtCompileTime,ColsAtCompileTime),
156                           EIGEN_ENUM_MAX(RowsAtCompileTime,ColsAtCompileTime)> SquareMatrixType;
157 #endif // not EIGEN_PARSED_BY_DOXYGEN
158
159     /** \returns the number of rows. \sa cols(), RowsAtCompileTime */
160     inline int rows() const { return derived().rows(); }
161     /** \returns the number of columns. \sa rows(), ColsAtCompileTime*/
162     inline int cols() const { return derived().cols(); }
163     /** \returns the number of coefficients, which is \a rows()*cols().
164       * \sa rows(), cols(), SizeAtCompileTime. */
165     inline int size() const { return rows() * cols(); }
166     /** \returns the number of nonzero coefficients which is in practice the number
167       * of stored coefficients. */
168     inline int nonZeros() const { return derived.nonZeros(); }
169     /** \returns true if either the number of rows or the number of columns is equal to 1.
170       * In other words, this function returns
171       * \code rows()==1 || cols()==1 \endcode
172       * \sa rows(), cols(), IsVectorAtCompileTime. */
173     inline bool isVector() const { return rows()==1 || cols()==1; }
174     /** \returns the size of the storage major dimension,
175       * i.e., the number of columns for a columns major matrix, and the number of rows otherwise */
176     int outerSize() const { return (int(Flags)&RowMajorBit) ? this->rows() : this->cols(); }
177     /** \returns the size of the inner dimension according to the storage order,
178       * i.e., the number of rows for a columns major matrix, and the number of cols otherwise */
179     int innerSize() const { return (int(Flags)&RowMajorBit) ? this->cols() : this->rows(); }
180
181 #ifndef EIGEN_PARSED_BY_DOXYGEN
182     /** \internal the plain matrix type corresponding to this expression. Note that is not necessarily
183       * exactly the return type of eval(): in the case of plain matrices, the return type of eval() is a const
184       * reference to a matrix, not a matrix! It guaranteed however, that the return type of eval() is either
185       * PlainMatrixType or const PlainMatrixType&.
186       */
187     typedef typename ei_plain_matrix_type<Derived>::type PlainMatrixType;
188     /** \internal the column-major plain matrix type corresponding to this expression. Note that is not necessarily
189       * exactly the return type of eval(): in the case of plain matrices, the return type of eval() is a const
190       * reference to a matrix, not a matrix!
191       * The only difference from PlainMatrixType is that PlainMatrixType_ColMajor is guaranteed to be column-major.
192       */
193     typedef typename ei_plain_matrix_type<Derived>::type PlainMatrixType_ColMajor;
194
195     /** \internal Represents a matrix with all coefficients equal to one another*/
196     typedef CwiseNullaryOp<ei_scalar_constant_op<Scalar>,Derived> ConstantReturnType;
197     /** \internal Represents a scalar multiple of a matrix */
198     typedef CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, Derived> ScalarMultipleReturnType;
199     /** \internal Represents a quotient of a matrix by a scalar*/
200     typedef CwiseUnaryOp<ei_scalar_quotient1_op<Scalar>, Derived> ScalarQuotient1ReturnType;
201     /** \internal the return type of MatrixBase::conjugate() */
202     typedef typename ei_meta_if<NumTraits<Scalar>::IsComplex,
203                         const CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, Derived>,
204                         const Derived&
205                      >::ret ConjugateReturnType;
206     /** \internal the return type of MatrixBase::real() */
207     typedef CwiseUnaryOp<ei_scalar_real_op<Scalar>, Derived> RealReturnType;
208     /** \internal the return type of MatrixBase::imag() */
209     typedef CwiseUnaryOp<ei_scalar_imag_op<Scalar>, Derived> ImagReturnType;
210     /** \internal the return type of MatrixBase::adjoint() */
211     typedef Eigen::Transpose<NestByValue<typename ei_cleantype<ConjugateReturnType>::type> >
212             AdjointReturnType;
213     /** \internal the return type of MatrixBase::eigenvalues() */
214     typedef Matrix<typename NumTraits<typename ei_traits<Derived>::Scalar>::Real, ei_traits<Derived>::ColsAtCompileTime, 1> EigenvaluesReturnType;
215     /** \internal expression tyepe of a column */
216     typedef Block<Derived, ei_traits<Derived>::RowsAtCompileTime, 1> ColXpr;
217     /** \internal expression tyepe of a column */
218     typedef Block<Derived, 1, ei_traits<Derived>::ColsAtCompileTime> RowXpr;
219     /** \internal the return type of identity */
220     typedef CwiseNullaryOp<ei_scalar_identity_op<Scalar>,Derived> IdentityReturnType;
221     /** \internal the return type of unit vectors */
222     typedef Block<CwiseNullaryOp<ei_scalar_identity_op<Scalar>, SquareMatrixType>,
223                   ei_traits<Derived>::RowsAtCompileTime,
224                   ei_traits<Derived>::ColsAtCompileTime> BasisReturnType;
225 #endif // not EIGEN_PARSED_BY_DOXYGEN
226
227
228     /** Copies \a other into *this. \returns a reference to *this. */
229     template<typename OtherDerived>
230     Derived& operator=(const MatrixBase<OtherDerived>& other);
231
232     /** Special case of the template operator=, in order to prevent the compiler
233       * from generating a default operator= (issue hit with g++ 4.1)
234       */
235     inline Derived& operator=(const MatrixBase& other)
236     {
237       return this->operator=<Derived>(other);
238     }
239
240 #ifndef EIGEN_PARSED_BY_DOXYGEN
241     /** Copies \a other into *this without evaluating other. \returns a reference to *this. */
242     template<typename OtherDerived>
243     Derived& lazyAssign(const MatrixBase<OtherDerived>& other);
244
245     /** Overloaded for cache friendly product evaluation */
246     template<typename Lhs, typename Rhs>
247     Derived& lazyAssign(const Product<Lhs,Rhs,CacheFriendlyProduct>& product);
248
249     /** Overloaded for cache friendly product evaluation */
250     template<typename OtherDerived>
251     Derived& lazyAssign(const Flagged<OtherDerived, 0, EvalBeforeNestingBit | EvalBeforeAssigningBit>& other)
252     { return lazyAssign(other._expression()); }
253 #endif // not EIGEN_PARSED_BY_DOXYGEN
254
255     CommaInitializer<Derived> operator<< (const Scalar& s);
256
257     template<typename OtherDerived>
258     CommaInitializer<Derived> operator<< (const MatrixBase<OtherDerived>& other);
259
260     const Scalar coeff(int row, int col) const;
261     const Scalar operator()(int row, int col) const;
262
263     Scalar& coeffRef(int row, int col);
264     Scalar& operator()(int row, int col);
265
266     const Scalar coeff(int index) const;
267     const Scalar operator[](int index) const;
268     const Scalar operator()(int index) const;
269
270     Scalar& coeffRef(int index);
271     Scalar& operator[](int index);
272     Scalar& operator()(int index);
273
274 #ifndef EIGEN_PARSED_BY_DOXYGEN
275     template<typename OtherDerived>
276     void copyCoeff(int row, int col, const MatrixBase<OtherDerived>& other);
277     template<typename OtherDerived>
278     void copyCoeff(int index, const MatrixBase<OtherDerived>& other);
279     template<typename OtherDerived, int StoreMode, int LoadMode>
280     void copyPacket(int row, int col, const MatrixBase<OtherDerived>& other);
281     template<typename OtherDerived, int StoreMode, int LoadMode>
282     void copyPacket(int index, const MatrixBase<OtherDerived>& other);
283 #endif // not EIGEN_PARSED_BY_DOXYGEN
284
285     template<int LoadMode>
286     PacketScalar packet(int row, int col) const;
287     template<int StoreMode>
288     void writePacket(int row, int col, const PacketScalar& x);
289
290     template<int LoadMode>
291     PacketScalar packet(int index) const;
292     template<int StoreMode>
293     void writePacket(int index, const PacketScalar& x);
294
295     const Scalar x() const;
296     const Scalar y() const;
297     const Scalar z() const;
298     const Scalar w() const;
299     Scalar& x();
300     Scalar& y();
301     Scalar& z();
302     Scalar& w();
303
304
305     const CwiseUnaryOp<ei_scalar_opposite_op<typename ei_traits<Derived>::Scalar>,Derived> operator-() const;
306
307     template<typename OtherDerived>
308     const CwiseBinaryOp<ei_scalar_sum_op<typename ei_traits<Derived>::Scalar>, Derived, OtherDerived>
309     operator+(const MatrixBase<OtherDerived> &other) const;
310
311     template<typename OtherDerived>
312     const CwiseBinaryOp<ei_scalar_difference_op<typename ei_traits<Derived>::Scalar>, Derived, OtherDerived>
313     operator-(const MatrixBase<OtherDerived> &other) const;
314
315     template<typename OtherDerived>
316     Derived& operator+=(const MatrixBase<OtherDerived>& other);
317     template<typename OtherDerived>
318     Derived& operator-=(const MatrixBase<OtherDerived>& other);
319
320     template<typename Lhs,typename Rhs>
321     Derived& operator+=(const Flagged<Product<Lhs,Rhs,CacheFriendlyProduct>, 0, EvalBeforeNestingBit | EvalBeforeAssigningBit>& other);
322
323     Derived& operator*=(const Scalar& other);
324     Derived& operator/=(const Scalar& other);
325
326     const ScalarMultipleReturnType operator*(const Scalar& scalar) const;
327     const CwiseUnaryOp<ei_scalar_quotient1_op<typename ei_traits<Derived>::Scalar>, Derived>
328     operator/(const Scalar& scalar) const;
329
330     inline friend const CwiseUnaryOp<ei_scalar_multiple_op<typename ei_traits<Derived>::Scalar>, Derived>
331     operator*(const Scalar& scalar, const MatrixBase& matrix)
332     { return matrix*scalar; }
333
334
335     template<typename OtherDerived>
336     const typename ProductReturnType<Derived,OtherDerived>::Type
337     operator*(const MatrixBase<OtherDerived> &other) const;
338
339     template<typename OtherDerived>
340     Derived& operator*=(const MatrixBase<OtherDerived>& other);
341
342     template<typename OtherDerived>
343     typename ei_plain_matrix_type_column_major<OtherDerived>::type
344                 solveTriangular(const MatrixBase<OtherDerived>& other) const;
345
346     template<typename OtherDerived>
347     void solveTriangularInPlace(const MatrixBase<OtherDerived>& other) const;
348
349
350     template<typename OtherDerived>
351     Scalar dot(const MatrixBase<OtherDerived>& other) const;
352     RealScalar squaredNorm() const;
353     RealScalar norm()  const;
354     const PlainMatrixType normalized() const;
355     void normalize();
356
357     Eigen::Transpose<Derived> transpose();
358     const Eigen::Transpose<Derived> transpose() const;
359     void transposeInPlace();
360     const AdjointReturnType adjoint() const;
361
362
363     RowXpr row(int i);
364     const RowXpr row(int i) const;
365
366     ColXpr col(int i);
367     const ColXpr col(int i) const;
368
369     Minor<Derived> minor(int row, int col);
370     const Minor<Derived> minor(int row, int col) const;
371
372     typename BlockReturnType<Derived>::Type block(int startRow, int startCol, int blockRows, int blockCols);
373     const typename BlockReturnType<Derived>::Type
374     block(int startRow, int startCol, int blockRows, int blockCols) const;
375
376     typename BlockReturnType<Derived>::SubVectorType segment(int start, int size);
377     const typename BlockReturnType<Derived>::SubVectorType segment(int start, int size) const;
378
379     typename BlockReturnType<Derived,Dynamic>::SubVectorType start(int size);
380     const typename BlockReturnType<Derived,Dynamic>::SubVectorType start(int size) const;
381
382     typename BlockReturnType<Derived,Dynamic>::SubVectorType end(int size);
383     const typename BlockReturnType<Derived,Dynamic>::SubVectorType end(int size) const;
384
385     typename BlockReturnType<Derived>::Type corner(CornerType type, int cRows, int cCols);
386     const typename BlockReturnType<Derived>::Type corner(CornerType type, int cRows, int cCols) const;
387
388     template<int BlockRows, int BlockCols>
389     typename BlockReturnType<Derived, BlockRows, BlockCols>::Type block(int startRow, int startCol);
390     template<int BlockRows, int BlockCols>
391     const typename BlockReturnType<Derived, BlockRows, BlockCols>::Type block(int startRow, int startCol) const;
392
393     template<int CRows, int CCols>
394     typename BlockReturnType<Derived, CRows, CCols>::Type corner(CornerType type);
395     template<int CRows, int CCols>
396     const typename BlockReturnType<Derived, CRows, CCols>::Type corner(CornerType type) const;
397
398     template<int Size> typename BlockReturnType<Derived,Size>::SubVectorType start(void);
399     template<int Size> const typename BlockReturnType<Derived,Size>::SubVectorType start() const;
400
401     template<int Size> typename BlockReturnType<Derived,Size>::SubVectorType end();
402     template<int Size> const typename BlockReturnType<Derived,Size>::SubVectorType end() const;
403
404     template<int Size> typename BlockReturnType<Derived,Size>::SubVectorType segment(int start);
405     template<int Size> const typename BlockReturnType<Derived,Size>::SubVectorType segment(int start) const;
406
407     DiagonalCoeffs<Derived> diagonal();
408     const DiagonalCoeffs<Derived> diagonal() const;
409
410     template<unsigned int Mode> Part<Derived, Mode> part();
411     template<unsigned int Mode> const Part<Derived, Mode> part() const;
412
413
414     static const ConstantReturnType
415     Constant(int rows, int cols, const Scalar& value);
416     static const ConstantReturnType
417     Constant(int size, const Scalar& value);
418     static const ConstantReturnType
419     Constant(const Scalar& value);
420
421     template<typename CustomNullaryOp>
422     static const CwiseNullaryOp<CustomNullaryOp, Derived>
423     NullaryExpr(int rows, int cols, const CustomNullaryOp& func);
424     template<typename CustomNullaryOp>
425     static const CwiseNullaryOp<CustomNullaryOp, Derived>
426     NullaryExpr(int size, const CustomNullaryOp& func);
427     template<typename CustomNullaryOp>
428     static const CwiseNullaryOp<CustomNullaryOp, Derived>
429     NullaryExpr(const CustomNullaryOp& func);
430
431     static const ConstantReturnType Zero(int rows, int cols);
432     static const ConstantReturnType Zero(int size);
433     static const ConstantReturnType Zero();
434     static const ConstantReturnType Ones(int rows, int cols);
435     static const ConstantReturnType Ones(int size);
436     static const ConstantReturnType Ones();
437     static const IdentityReturnType Identity();
438     static const IdentityReturnType Identity(int rows, int cols);
439     static const BasisReturnType Unit(int size, int i);
440     static const BasisReturnType Unit(int i);
441     static const BasisReturnType UnitX();
442     static const BasisReturnType UnitY();
443     static const BasisReturnType UnitZ();
444     static const BasisReturnType UnitW();
445
446     const DiagonalMatrix<Derived> asDiagonal() const;
447
448     void fill(const Scalar& value);
449     Derived& setConstant(const Scalar& value);
450     Derived& setZero();
451     Derived& setOnes();
452     Derived& setRandom();
453     Derived& setIdentity();
454
455
456     template<typename OtherDerived>
457     bool isApprox(const MatrixBase<OtherDerived>& other,
458                   RealScalar prec = precision<Scalar>()) const;
459     bool isMuchSmallerThan(const RealScalar& other,
460                            RealScalar prec = precision<Scalar>()) const;
461     template<typename OtherDerived>
462     bool isMuchSmallerThan(const MatrixBase<OtherDerived>& other,
463                            RealScalar prec = precision<Scalar>()) const;
464
465     bool isApproxToConstant(const Scalar& value, RealScalar prec = precision<Scalar>()) const;
466     bool isConstant(const Scalar& value, RealScalar prec = precision<Scalar>()) const;
467     bool isZero(RealScalar prec = precision<Scalar>()) const;
468     bool isOnes(RealScalar prec = precision<Scalar>()) const;
469     bool isIdentity(RealScalar prec = precision<Scalar>()) const;
470     bool isDiagonal(RealScalar prec = precision<Scalar>()) const;
471
472     bool isUpperTriangular(RealScalar prec = precision<Scalar>()) const;
473     bool isLowerTriangular(RealScalar prec = precision<Scalar>()) const;
474
475     template<typename OtherDerived>
476     bool isOrthogonal(const MatrixBase<OtherDerived>& other,
477                       RealScalar prec = precision<Scalar>()) const;
478     bool isUnitary(RealScalar prec = precision<Scalar>()) const;
479
480     template<typename OtherDerived>
481     inline bool operator==(const MatrixBase<OtherDerived>& other) const
482     { return (cwise() == other).all(); }
483
484     template<typename OtherDerived>
485     inline bool operator!=(const MatrixBase<OtherDerived>& other) const
486     { return (cwise() != other).any(); }
487
488
489     template<typename NewType>
490     const CwiseUnaryOp<ei_scalar_cast_op<typename ei_traits<Derived>::Scalar, NewType>, Derived> cast() const;
491
492     /** \returns the matrix or vector obtained by evaluating this expression.
493       *
494       * Notice that in the case of a plain matrix or vector (not an expression) this function just returns
495       * a const reference, in order to avoid a useless copy.
496       */
497     EIGEN_STRONG_INLINE const typename ei_eval<Derived>::type eval() const
498     { return typename ei_eval<Derived>::type(derived()); }
499
500     template<typename OtherDerived>
501     void swap(const MatrixBase<OtherDerived>& other);
502
503     template<unsigned int Added>
504     const Flagged<Derived, Added, 0> marked() const;
505     const Flagged<Derived, 0, EvalBeforeNestingBit | EvalBeforeAssigningBit> lazy() const;
506
507     /** \returns number of elements to skip to pass from one row (resp. column) to another
508       * for a row-major (resp. column-major) matrix.
509       * Combined with coeffRef() and the \ref flags flags, it allows a direct access to the data
510       * of the underlying matrix.
511       */
512     inline int stride(void) const { return derived().stride(); }
513
514     inline const NestByValue<Derived> nestByValue() const;
515
516
517     ConjugateReturnType conjugate() const;
518     const RealReturnType real() const;
519     const ImagReturnType imag() const;
520
521     template<typename CustomUnaryOp>
522     const CwiseUnaryOp<CustomUnaryOp, Derived> unaryExpr(const CustomUnaryOp& func = CustomUnaryOp()) const;
523
524     template<typename CustomBinaryOp, typename OtherDerived>
525     const CwiseBinaryOp<CustomBinaryOp, Derived, OtherDerived>
526     binaryExpr(const MatrixBase<OtherDerived> &other, const CustomBinaryOp& func = CustomBinaryOp()) const;
527
528
529     Scalar sum() const;
530     Scalar trace() const;
531
532     typename ei_traits<Derived>::Scalar minCoeff() const;
533     typename ei_traits<Derived>::Scalar maxCoeff() const;
534
535     typename ei_traits<Derived>::Scalar minCoeff(int* row, int* col) const;
536     typename ei_traits<Derived>::Scalar maxCoeff(int* row, int* col) const;
537
538     typename ei_traits<Derived>::Scalar minCoeff(int* index) const;
539     typename ei_traits<Derived>::Scalar maxCoeff(int* index) const;
540
541     template<typename BinaryOp>
542     typename ei_result_of<BinaryOp(typename ei_traits<Derived>::Scalar)>::type
543     redux(const BinaryOp& func) const;
544
545     template<typename Visitor>
546     void visit(Visitor& func) const;
547
548 #ifndef EIGEN_PARSED_BY_DOXYGEN
549     inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
550     inline Derived& derived() { return *static_cast<Derived*>(this); }
551     inline Derived& const_cast_derived() const
552     { return *static_cast<Derived*>(const_cast<MatrixBase*>(this)); }
553 #endif // not EIGEN_PARSED_BY_DOXYGEN
554
555     const Cwise<Derived> cwise() const;
556     Cwise<Derived> cwise();
557
558     inline const WithFormat<Derived> format(const IOFormat& fmt) const;
559
560 /////////// Array module ///////////
561
562     bool all(void) const;
563     bool any(void) const;
564     int count() const;
565
566     const PartialRedux<Derived,Horizontal> rowwise() const;
567     const PartialRedux<Derived,Vertical> colwise() const;
568
569     static const CwiseNullaryOp<ei_scalar_random_op<Scalar>,Derived> Random(int rows, int cols);
570     static const CwiseNullaryOp<ei_scalar_random_op<Scalar>,Derived> Random(int size);
571     static const CwiseNullaryOp<ei_scalar_random_op<Scalar>,Derived> Random();
572
573     template<typename ThenDerived,typename ElseDerived>
574     const Select<Derived,ThenDerived,ElseDerived>
575     select(const MatrixBase<ThenDerived>& thenMatrix,
576            const MatrixBase<ElseDerived>& elseMatrix) const;
577
578     template<typename ThenDerived>
579     inline const Select<Derived,ThenDerived, NestByValue<typename ThenDerived::ConstantReturnType> >
580     select(const MatrixBase<ThenDerived>& thenMatrix, typename ThenDerived::Scalar elseScalar) const;
581
582     template<typename ElseDerived>
583     inline const Select<Derived, NestByValue<typename ElseDerived::ConstantReturnType>, ElseDerived >
584     select(typename ElseDerived::Scalar thenScalar, const MatrixBase<ElseDerived>& elseMatrix) const;
585
586     template<int p> RealScalar lpNorm() const;
587
588 /////////// LU module ///////////
589
590     const LU<PlainMatrixType> lu() const;
591     const PlainMatrixType inverse() const;
592     void computeInverse(PlainMatrixType *result) const;
593     Scalar determinant() const;
594
595 /////////// Cholesky module ///////////
596
597     const LLT<PlainMatrixType>  llt() const;
598     const LDLT<PlainMatrixType> ldlt() const;
599
600 /////////// QR module ///////////
601
602     const QR<PlainMatrixType> qr() const;
603
604     EigenvaluesReturnType eigenvalues() const;
605     RealScalar operatorNorm() const;
606
607 /////////// SVD module ///////////
608
609     SVD<PlainMatrixType> svd() const;
610
611 /////////// Geometry module ///////////
612
613     template<typename OtherDerived>
614     PlainMatrixType cross(const MatrixBase<OtherDerived>& other) const;
615     PlainMatrixType unitOrthogonal(void) const;
616     Matrix<Scalar,3,1> eulerAngles(int a0, int a1, int a2) const;
617
618 /////////// Sparse module ///////////
619
620     // dense = spasre * dense
621     template<typename Derived1, typename Derived2>
622     Derived& lazyAssign(const SparseProduct<Derived1,Derived2,SparseTimeDenseProduct>& product);
623     // dense = dense * spasre
624     template<typename Derived1, typename Derived2>
625     Derived& lazyAssign(const SparseProduct<Derived1,Derived2,DenseTimeSparseProduct>& product);
626
627     #ifdef EIGEN_MATRIXBASE_PLUGIN
628     #include EIGEN_MATRIXBASE_PLUGIN
629     #endif
630 };
631
632 #endif // EIGEN_MATRIXBASE_H