Free cookie consent management tool by TermsFeed Policy Generator

source: branches/HeuristicLab.Problems.GaussianProcessTuning/HeuristicLab.Eigen/Eigen/src/Core/DenseBase.h @ 10617

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

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