Another set of UI messages fixes and tweaks! No functional changes.
[blender.git] / extern / Eigen3 / Eigen / src / Core / DenseBase.h
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2007-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
5 // Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.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_DENSEBASE_H
27 #define EIGEN_DENSEBASE_H
28
29 /** \class DenseBase
30   * \ingroup Core_Module
31   *
32   * \brief Base class for all dense matrices, vectors, and arrays
33   *
34   * This class is the base that is inherited by all dense objects (matrix, vector, arrays,
35   * and related expression types). The common Eigen API for dense objects is contained in this class.
36   *
37   * \tparam Derived is the derived type, e.g., a matrix type or an expression.
38   *
39   * This class can be extended with the help of the plugin mechanism described on the page
40   * \ref TopicCustomizingEigen by defining the preprocessor symbol \c EIGEN_DENSEBASE_PLUGIN.
41   *
42   * \sa \ref TopicClassHierarchy
43   */
44 template<typename Derived> class DenseBase
45 #ifndef EIGEN_PARSED_BY_DOXYGEN
46   : public internal::special_scalar_op_base<Derived,typename internal::traits<Derived>::Scalar,
47                                      typename NumTraits<typename internal::traits<Derived>::Scalar>::Real>
48 #else
49   : public DenseCoeffsBase<Derived>
50 #endif // not EIGEN_PARSED_BY_DOXYGEN
51 {
52   public:
53     using internal::special_scalar_op_base<Derived,typename internal::traits<Derived>::Scalar,
54                 typename NumTraits<typename internal::traits<Derived>::Scalar>::Real>::operator*;
55
56     class InnerIterator;
57
58     typedef typename internal::traits<Derived>::StorageKind StorageKind;
59
60     /** \brief The type of indices 
61       * \details To change this, \c \#define the preprocessor symbol \c EIGEN_DEFAULT_DENSE_INDEX_TYPE.
62       * \sa \ref TopicPreprocessorDirectives.
63       */
64     typedef typename internal::traits<Derived>::Index Index; 
65
66     typedef typename internal::traits<Derived>::Scalar Scalar;
67     typedef typename internal::packet_traits<Scalar>::type PacketScalar;
68     typedef typename NumTraits<Scalar>::Real RealScalar;
69
70     typedef DenseCoeffsBase<Derived> Base;
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::rowIndexByOuterInner;
77     using Base::colIndexByOuterInner;
78     using Base::coeff;
79     using Base::coeffByOuterInner;
80     using Base::packet;
81     using Base::packetByOuterInner;
82     using Base::writePacket;
83     using Base::writePacketByOuterInner;
84     using Base::coeffRef;
85     using Base::coeffRefByOuterInner;
86     using Base::copyCoeff;
87     using Base::copyCoeffByOuterInner;
88     using Base::copyPacket;
89     using Base::copyPacketByOuterInner;
90     using Base::operator();
91     using Base::operator[];
92     using Base::x;
93     using Base::y;
94     using Base::z;
95     using Base::w;
96     using Base::stride;
97     using Base::innerStride;
98     using Base::outerStride;
99     using Base::rowStride;
100     using Base::colStride;
101     typedef typename Base::CoeffReturnType CoeffReturnType;
102
103     enum {
104
105       RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
106         /**< The number of rows at compile-time. This is just a copy of the value provided
107           * by the \a Derived type. If a value is not known at compile-time,
108           * it is set to the \a Dynamic constant.
109           * \sa MatrixBase::rows(), MatrixBase::cols(), ColsAtCompileTime, SizeAtCompileTime */
110
111       ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
112         /**< The number of columns at compile-time. This is just a copy of the value provided
113           * by the \a Derived type. If a value is not known at compile-time,
114           * it is set to the \a Dynamic constant.
115           * \sa MatrixBase::rows(), MatrixBase::cols(), RowsAtCompileTime, SizeAtCompileTime */
116
117
118       SizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::RowsAtCompileTime,
119                                                    internal::traits<Derived>::ColsAtCompileTime>::ret),
120         /**< This is equal to the number of coefficients, i.e. the number of
121           * rows times the number of columns, or to \a Dynamic if this is not
122           * known at compile-time. \sa RowsAtCompileTime, ColsAtCompileTime */
123
124       MaxRowsAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime,
125         /**< This value is equal to the maximum possible number of rows that this expression
126           * might have. If this expression might have an arbitrarily high number of rows,
127           * this value is set to \a Dynamic.
128           *
129           * This value is useful to know when evaluating an expression, in order to determine
130           * whether it is possible to avoid doing a dynamic memory allocation.
131           *
132           * \sa RowsAtCompileTime, MaxColsAtCompileTime, MaxSizeAtCompileTime
133           */
134
135       MaxColsAtCompileTime = internal::traits<Derived>::MaxColsAtCompileTime,
136         /**< This value is equal to the maximum possible number of columns that this expression
137           * might have. If this expression might have an arbitrarily high number of columns,
138           * this value is set to \a Dynamic.
139           *
140           * This value is useful to know when evaluating an expression, in order to determine
141           * whether it is possible to avoid doing a dynamic memory allocation.
142           *
143           * \sa ColsAtCompileTime, MaxRowsAtCompileTime, MaxSizeAtCompileTime
144           */
145
146       MaxSizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::MaxRowsAtCompileTime,
147                                                       internal::traits<Derived>::MaxColsAtCompileTime>::ret),
148         /**< This value is equal to the maximum possible number of coefficients that this expression
149           * might have. If this expression might have an arbitrarily high number of coefficients,
150           * this value is set to \a Dynamic.
151           *
152           * This value is useful to know when evaluating an expression, in order to determine
153           * whether it is possible to avoid doing a dynamic memory allocation.
154           *
155           * \sa SizeAtCompileTime, MaxRowsAtCompileTime, MaxColsAtCompileTime
156           */
157
158       IsVectorAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime == 1
159                            || internal::traits<Derived>::MaxColsAtCompileTime == 1,
160         /**< This is set to true if either the number of rows or the number of
161           * columns is known at compile-time to be equal to 1. Indeed, in that case,
162           * we are dealing with a column-vector (if there is only one column) or with
163           * a row-vector (if there is only one row). */
164
165       Flags = internal::traits<Derived>::Flags,
166         /**< This stores expression \ref flags flags which may or may not be inherited by new expressions
167           * constructed from this one. See the \ref flags "list of flags".
168           */
169
170       IsRowMajor = int(Flags) & RowMajorBit, /**< True if this expression has row-major storage order. */
171
172       InnerSizeAtCompileTime = int(IsVectorAtCompileTime) ? SizeAtCompileTime
173                              : int(IsRowMajor) ? ColsAtCompileTime : RowsAtCompileTime,
174
175       CoeffReadCost = internal::traits<Derived>::CoeffReadCost,
176         /**< This is a rough measure of how expensive it is to read one coefficient from
177           * this expression.
178           */
179
180       InnerStrideAtCompileTime = internal::inner_stride_at_compile_time<Derived>::ret,
181       OuterStrideAtCompileTime = internal::outer_stride_at_compile_time<Derived>::ret
182     };
183
184     enum { ThisConstantIsPrivateInPlainObjectBase };
185
186     /** \returns the number of nonzero coefficients which is in practice the number
187       * of stored coefficients. */
188     inline Index nonZeros() const { return size(); }
189     /** \returns true if either the number of rows or the number of columns is equal to 1.
190       * In other words, this function returns
191       * \code rows()==1 || cols()==1 \endcode
192       * \sa rows(), cols(), IsVectorAtCompileTime. */
193
194     /** \returns the outer size.
195       *
196       * \note For a vector, this returns just 1. For a matrix (non-vector), this is the major dimension
197       * with respect to the \ref TopicStorageOrders "storage order", i.e., the number of columns for a
198       * column-major matrix, and the number of rows for a row-major matrix. */
199     Index outerSize() const
200     {
201       return IsVectorAtCompileTime ? 1
202            : int(IsRowMajor) ? this->rows() : this->cols();
203     }
204
205     /** \returns the inner size.
206       *
207       * \note For a vector, this is just the size. For a matrix (non-vector), this is the minor dimension
208       * with respect to the \ref TopicStorageOrders "storage order", i.e., the number of rows for a 
209       * column-major matrix, and the number of columns for a row-major matrix. */
210     Index innerSize() const
211     {
212       return IsVectorAtCompileTime ? this->size()
213            : int(IsRowMajor) ? this->cols() : this->rows();
214     }
215
216     /** Only plain matrices/arrays, not expressions, may be resized; therefore the only useful resize methods are
217       * Matrix::resize() and Array::resize(). The present method only asserts that the new size equals the old size, and does
218       * nothing else.
219       */
220     void resize(Index size)
221     {
222       EIGEN_ONLY_USED_FOR_DEBUG(size);
223       eigen_assert(size == this->size()
224                 && "DenseBase::resize() does not actually allow to resize.");
225     }
226     /** Only plain matrices/arrays, not expressions, may be resized; therefore the only useful resize methods are
227       * Matrix::resize() and Array::resize(). The present method only asserts that the new size equals the old size, and does
228       * nothing else.
229       */
230     void resize(Index rows, Index cols)
231     {
232       EIGEN_ONLY_USED_FOR_DEBUG(rows);
233       EIGEN_ONLY_USED_FOR_DEBUG(cols);
234       eigen_assert(rows == this->rows() && cols == this->cols()
235                 && "DenseBase::resize() does not actually allow to resize.");
236     }
237
238 #ifndef EIGEN_PARSED_BY_DOXYGEN
239
240     /** \internal Represents a matrix with all coefficients equal to one another*/
241     typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,Derived> ConstantReturnType;
242     /** \internal Represents a vector with linearly spaced coefficients that allows sequential access only. */
243     typedef CwiseNullaryOp<internal::linspaced_op<Scalar,false>,Derived> SequentialLinSpacedReturnType;
244     /** \internal Represents a vector with linearly spaced coefficients that allows random access. */
245     typedef CwiseNullaryOp<internal::linspaced_op<Scalar,true>,Derived> RandomAccessLinSpacedReturnType;
246     /** \internal the return type of MatrixBase::eigenvalues() */
247     typedef Matrix<typename NumTraits<typename internal::traits<Derived>::Scalar>::Real, internal::traits<Derived>::ColsAtCompileTime, 1> EigenvaluesReturnType;
248
249 #endif // not EIGEN_PARSED_BY_DOXYGEN
250
251     /** Copies \a other into *this. \returns a reference to *this. */
252     template<typename OtherDerived>
253     Derived& operator=(const DenseBase<OtherDerived>& other);
254
255     /** Special case of the template operator=, in order to prevent the compiler
256       * from generating a default operator= (issue hit with g++ 4.1)
257       */
258     Derived& operator=(const DenseBase& other);
259
260     template<typename OtherDerived>
261     Derived& operator=(const EigenBase<OtherDerived> &other);
262
263     template<typename OtherDerived>
264     Derived& operator+=(const EigenBase<OtherDerived> &other);
265
266     template<typename OtherDerived>
267     Derived& operator-=(const EigenBase<OtherDerived> &other);
268
269     template<typename OtherDerived>
270     Derived& operator=(const ReturnByValue<OtherDerived>& func);
271
272 #ifndef EIGEN_PARSED_BY_DOXYGEN
273     /** Copies \a other into *this without evaluating other. \returns a reference to *this. */
274     template<typename OtherDerived>
275     Derived& lazyAssign(const DenseBase<OtherDerived>& other);
276 #endif // not EIGEN_PARSED_BY_DOXYGEN
277
278     CommaInitializer<Derived> operator<< (const Scalar& s);
279
280     template<unsigned int Added,unsigned int Removed>
281     const Flagged<Derived, Added, Removed> flagged() const;
282
283     template<typename OtherDerived>
284     CommaInitializer<Derived> operator<< (const DenseBase<OtherDerived>& other);
285
286     Eigen::Transpose<Derived> transpose();
287     typedef const Transpose<const Derived> ConstTransposeReturnType;
288     ConstTransposeReturnType transpose() const;
289     void transposeInPlace();
290 #ifndef EIGEN_NO_DEBUG
291   protected:
292     template<typename OtherDerived>
293     void checkTransposeAliasing(const OtherDerived& other) const;
294   public:
295 #endif
296
297     typedef VectorBlock<Derived> SegmentReturnType;
298     typedef const VectorBlock<const Derived> ConstSegmentReturnType;
299     template<int Size> struct FixedSegmentReturnType { typedef VectorBlock<Derived, Size> Type; };
300     template<int Size> struct ConstFixedSegmentReturnType { typedef const VectorBlock<const Derived, Size> Type; };
301     
302     // Note: The "DenseBase::" prefixes are added to help MSVC9 to match these declarations with the later implementations.
303     SegmentReturnType segment(Index start, Index size);
304     typename DenseBase::ConstSegmentReturnType segment(Index start, Index size) const;
305
306     SegmentReturnType head(Index size);
307     typename DenseBase::ConstSegmentReturnType head(Index size) const;
308
309     SegmentReturnType tail(Index size);
310     typename DenseBase::ConstSegmentReturnType tail(Index size) const;
311
312     template<int Size> typename FixedSegmentReturnType<Size>::Type head();
313     template<int Size> typename ConstFixedSegmentReturnType<Size>::Type head() const;
314
315     template<int Size> typename FixedSegmentReturnType<Size>::Type tail();
316     template<int Size> typename ConstFixedSegmentReturnType<Size>::Type tail() const;
317
318     template<int Size> typename FixedSegmentReturnType<Size>::Type segment(Index start);
319     template<int Size> typename ConstFixedSegmentReturnType<Size>::Type segment(Index start) const;
320
321     static const ConstantReturnType
322     Constant(Index rows, Index cols, const Scalar& value);
323     static const ConstantReturnType
324     Constant(Index size, const Scalar& value);
325     static const ConstantReturnType
326     Constant(const Scalar& value);
327
328     static const SequentialLinSpacedReturnType
329     LinSpaced(Sequential_t, Index size, const Scalar& low, const Scalar& high);
330     static const RandomAccessLinSpacedReturnType
331     LinSpaced(Index size, const Scalar& low, const Scalar& high);
332     static const SequentialLinSpacedReturnType
333     LinSpaced(Sequential_t, const Scalar& low, const Scalar& high);
334     static const RandomAccessLinSpacedReturnType
335     LinSpaced(const Scalar& low, const Scalar& high);
336
337     template<typename CustomNullaryOp>
338     static const CwiseNullaryOp<CustomNullaryOp, Derived>
339     NullaryExpr(Index rows, Index cols, const CustomNullaryOp& func);
340     template<typename CustomNullaryOp>
341     static const CwiseNullaryOp<CustomNullaryOp, Derived>
342     NullaryExpr(Index size, const CustomNullaryOp& func);
343     template<typename CustomNullaryOp>
344     static const CwiseNullaryOp<CustomNullaryOp, Derived>
345     NullaryExpr(const CustomNullaryOp& func);
346
347     static const ConstantReturnType Zero(Index rows, Index cols);
348     static const ConstantReturnType Zero(Index size);
349     static const ConstantReturnType Zero();
350     static const ConstantReturnType Ones(Index rows, Index cols);
351     static const ConstantReturnType Ones(Index size);
352     static const ConstantReturnType Ones();
353
354     void fill(const Scalar& value);
355     Derived& setConstant(const Scalar& value);
356     Derived& setLinSpaced(Index size, const Scalar& low, const Scalar& high);
357     Derived& setLinSpaced(const Scalar& low, const Scalar& high);
358     Derived& setZero();
359     Derived& setOnes();
360     Derived& setRandom();
361
362     template<typename OtherDerived>
363     bool isApprox(const DenseBase<OtherDerived>& other,
364                   RealScalar prec = NumTraits<Scalar>::dummy_precision()) const;
365     bool isMuchSmallerThan(const RealScalar& other,
366                            RealScalar prec = NumTraits<Scalar>::dummy_precision()) const;
367     template<typename OtherDerived>
368     bool isMuchSmallerThan(const DenseBase<OtherDerived>& other,
369                            RealScalar prec = NumTraits<Scalar>::dummy_precision()) const;
370
371     bool isApproxToConstant(const Scalar& value, RealScalar prec = NumTraits<Scalar>::dummy_precision()) const;
372     bool isConstant(const Scalar& value, RealScalar prec = NumTraits<Scalar>::dummy_precision()) const;
373     bool isZero(RealScalar prec = NumTraits<Scalar>::dummy_precision()) const;
374     bool isOnes(RealScalar prec = NumTraits<Scalar>::dummy_precision()) const;
375
376     inline Derived& operator*=(const Scalar& other);
377     inline Derived& operator/=(const Scalar& other);
378
379     /** \returns the matrix or vector obtained by evaluating this expression.
380       *
381       * Notice that in the case of a plain matrix or vector (not an expression) this function just returns
382       * a const reference, in order to avoid a useless copy.
383       */
384     EIGEN_STRONG_INLINE const typename internal::eval<Derived>::type eval() const
385     {
386       // Even though MSVC does not honor strong inlining when the return type
387       // is a dynamic matrix, we desperately need strong inlining for fixed
388       // size types on MSVC.
389       return typename internal::eval<Derived>::type(derived());
390     }
391
392     /** swaps *this with the expression \a other.
393       *
394       */
395     template<typename OtherDerived>
396     void swap(const DenseBase<OtherDerived>& other,
397               int = OtherDerived::ThisConstantIsPrivateInPlainObjectBase)
398     {
399       SwapWrapper<Derived>(derived()).lazyAssign(other.derived());
400     }
401
402     /** swaps *this with the matrix or array \a other.
403       *
404       */
405     template<typename OtherDerived>
406     void swap(PlainObjectBase<OtherDerived>& other)
407     {
408       SwapWrapper<Derived>(derived()).lazyAssign(other.derived());
409     }
410
411
412     inline const NestByValue<Derived> nestByValue() const;
413     inline const ForceAlignedAccess<Derived> forceAlignedAccess() const;
414     inline ForceAlignedAccess<Derived> forceAlignedAccess();
415     template<bool Enable> inline const typename internal::conditional<Enable,ForceAlignedAccess<Derived>,Derived&>::type forceAlignedAccessIf() const;
416     template<bool Enable> inline typename internal::conditional<Enable,ForceAlignedAccess<Derived>,Derived&>::type forceAlignedAccessIf();
417
418     Scalar sum() const;
419     Scalar mean() const;
420     Scalar trace() const;
421
422     Scalar prod() const;
423
424     typename internal::traits<Derived>::Scalar minCoeff() const;
425     typename internal::traits<Derived>::Scalar maxCoeff() const;
426
427     template<typename IndexType>
428     typename internal::traits<Derived>::Scalar minCoeff(IndexType* row, IndexType* col) const;
429     template<typename IndexType>
430     typename internal::traits<Derived>::Scalar maxCoeff(IndexType* row, IndexType* col) const;
431     template<typename IndexType>
432     typename internal::traits<Derived>::Scalar minCoeff(IndexType* index) const;
433     template<typename IndexType>
434     typename internal::traits<Derived>::Scalar maxCoeff(IndexType* index) const;
435
436     template<typename BinaryOp>
437     typename internal::result_of<BinaryOp(typename internal::traits<Derived>::Scalar)>::type
438     redux(const BinaryOp& func) const;
439
440     template<typename Visitor>
441     void visit(Visitor& func) const;
442
443     inline const WithFormat<Derived> format(const IOFormat& fmt) const;
444
445     /** \returns the unique coefficient of a 1x1 expression */
446     CoeffReturnType value() const
447     {
448       EIGEN_STATIC_ASSERT_SIZE_1x1(Derived)
449       eigen_assert(this->rows() == 1 && this->cols() == 1);
450       return derived().coeff(0,0);
451     }
452
453 /////////// Array module ///////////
454
455     bool all(void) const;
456     bool any(void) const;
457     Index count() const;
458
459     typedef VectorwiseOp<Derived, Horizontal> RowwiseReturnType;
460     typedef const VectorwiseOp<const Derived, Horizontal> ConstRowwiseReturnType;
461     typedef VectorwiseOp<Derived, Vertical> ColwiseReturnType;
462     typedef const VectorwiseOp<const Derived, Vertical> ConstColwiseReturnType;
463
464     ConstRowwiseReturnType rowwise() const;
465     RowwiseReturnType rowwise();
466     ConstColwiseReturnType colwise() const;
467     ColwiseReturnType colwise();
468
469     static const CwiseNullaryOp<internal::scalar_random_op<Scalar>,Derived> Random(Index rows, Index cols);
470     static const CwiseNullaryOp<internal::scalar_random_op<Scalar>,Derived> Random(Index size);
471     static const CwiseNullaryOp<internal::scalar_random_op<Scalar>,Derived> Random();
472
473     template<typename ThenDerived,typename ElseDerived>
474     const Select<Derived,ThenDerived,ElseDerived>
475     select(const DenseBase<ThenDerived>& thenMatrix,
476            const DenseBase<ElseDerived>& elseMatrix) const;
477
478     template<typename ThenDerived>
479     inline const Select<Derived,ThenDerived, typename ThenDerived::ConstantReturnType>
480     select(const DenseBase<ThenDerived>& thenMatrix, typename ThenDerived::Scalar elseScalar) const;
481
482     template<typename ElseDerived>
483     inline const Select<Derived, typename ElseDerived::ConstantReturnType, ElseDerived >
484     select(typename ElseDerived::Scalar thenScalar, const DenseBase<ElseDerived>& elseMatrix) const;
485
486     template<int p> RealScalar lpNorm() const;
487
488     template<int RowFactor, int ColFactor>
489     const Replicate<Derived,RowFactor,ColFactor> replicate() const;
490     const Replicate<Derived,Dynamic,Dynamic> replicate(Index rowFacor,Index colFactor) const;
491
492     typedef Reverse<Derived, BothDirections> ReverseReturnType;
493     typedef const Reverse<const Derived, BothDirections> ConstReverseReturnType;
494     ReverseReturnType reverse();
495     ConstReverseReturnType reverse() const;
496     void reverseInPlace();
497
498 #define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::DenseBase
499 #   include "../plugins/BlockMethods.h"
500 #   ifdef EIGEN_DENSEBASE_PLUGIN
501 #     include EIGEN_DENSEBASE_PLUGIN
502 #   endif
503 #undef EIGEN_CURRENT_STORAGE_BASE_CLASS
504
505 #ifdef EIGEN2_SUPPORT
506
507     Block<Derived> corner(CornerType type, Index cRows, Index cCols);
508     const Block<Derived> corner(CornerType type, Index cRows, Index cCols) const;
509     template<int CRows, int CCols>
510     Block<Derived, CRows, CCols> corner(CornerType type);
511     template<int CRows, int CCols>
512     const Block<Derived, CRows, CCols> corner(CornerType type) const;
513
514 #endif // EIGEN2_SUPPORT
515
516
517     // disable the use of evalTo for dense objects with a nice compilation error
518     template<typename Dest> inline void evalTo(Dest& ) const
519     {
520       EIGEN_STATIC_ASSERT((internal::is_same<Dest,void>::value),THE_EVAL_EVALTO_FUNCTION_SHOULD_NEVER_BE_CALLED_FOR_DENSE_OBJECTS);
521     }
522
523   protected:
524     /** Default constructor. Do nothing. */
525     DenseBase()
526     {
527       /* Just checks for self-consistency of the flags.
528        * Only do it when debugging Eigen, as this borders on paranoiac and could slow compilation down
529        */
530 #ifdef EIGEN_INTERNAL_DEBUGGING
531       EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, int(IsRowMajor))
532                         && EIGEN_IMPLIES(MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1, int(!IsRowMajor))),
533                           INVALID_STORAGE_ORDER_FOR_THIS_VECTOR_EXPRESSION)
534 #endif
535     }
536
537   private:
538     explicit DenseBase(int);
539     DenseBase(int,int);
540     template<typename OtherDerived> explicit DenseBase(const DenseBase<OtherDerived>&);
541 };
542
543 #endif // EIGEN_DENSEBASE_H