• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
14 namespace Eigen {
15 
16 namespace internal {
17 
18 // The index type defined by EIGEN_DEFAULT_DENSE_INDEX_TYPE must be a signed type.
19 // This dummy function simply aims at checking that at compile time.
check_DenseIndex_is_signed()20 static inline void check_DenseIndex_is_signed() {
21   EIGEN_STATIC_ASSERT(NumTraits<DenseIndex>::IsSigned,THE_INDEX_TYPE_MUST_BE_A_SIGNED_TYPE);
22 }
23 
24 } // end namespace internal
25 
26 /** \class DenseBase
27   * \ingroup Core_Module
28   *
29   * \brief Base class for all dense matrices, vectors, and arrays
30   *
31   * This class is the base that is inherited by all dense objects (matrix, vector, arrays,
32   * and related expression types). The common Eigen API for dense objects is contained in this class.
33   *
34   * \tparam Derived is the derived type, e.g., a matrix type or an expression.
35   *
36   * This class can be extended with the help of the plugin mechanism described on the page
37   * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_DENSEBASE_PLUGIN.
38   *
39   * \sa \blank \ref TopicClassHierarchy
40   */
41 template<typename Derived> class DenseBase
42 #ifndef EIGEN_PARSED_BY_DOXYGEN
43   : public DenseCoeffsBase<Derived>
44 #else
45   : public DenseCoeffsBase<Derived,DirectWriteAccessors>
46 #endif // not EIGEN_PARSED_BY_DOXYGEN
47 {
48   public:
49 
50     /** Inner iterator type to iterate over the coefficients of a row or column.
51       * \sa class InnerIterator
52       */
53     typedef Eigen::InnerIterator<Derived> InnerIterator;
54 
55     typedef typename internal::traits<Derived>::StorageKind StorageKind;
56 
57     /**
58       * \brief The type used to store indices
59       * \details This typedef is relevant for types that store multiple indices such as
60       *          PermutationMatrix or Transpositions, otherwise it defaults to Eigen::Index
61       * \sa \blank \ref TopicPreprocessorDirectives, Eigen::Index, SparseMatrixBase.
62      */
63     typedef typename internal::traits<Derived>::StorageIndex StorageIndex;
64 
65     /** The numeric type of the expression' coefficients, e.g. float, double, int or std::complex<float>, etc. */
66     typedef typename internal::traits<Derived>::Scalar Scalar;
67 
68     /** The numeric type of the expression' coefficients, e.g. float, double, int or std::complex<float>, etc.
69       *
70       * It is an alias for the Scalar type */
71     typedef Scalar value_type;
72 
73     typedef typename NumTraits<Scalar>::Real RealScalar;
74     typedef DenseCoeffsBase<Derived> Base;
75 
76     using Base::derived;
77     using Base::const_cast_derived;
78     using Base::rows;
79     using Base::cols;
80     using Base::size;
81     using Base::rowIndexByOuterInner;
82     using Base::colIndexByOuterInner;
83     using Base::coeff;
84     using Base::coeffByOuterInner;
85     using Base::operator();
86     using Base::operator[];
87     using Base::x;
88     using Base::y;
89     using Base::z;
90     using Base::w;
91     using Base::stride;
92     using Base::innerStride;
93     using Base::outerStride;
94     using Base::rowStride;
95     using Base::colStride;
96     typedef typename Base::CoeffReturnType CoeffReturnType;
97 
98     enum {
99 
100       RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
101         /**< The number of rows at compile-time. This is just a copy of the value provided
102           * by the \a Derived type. If a value is not known at compile-time,
103           * it is set to the \a Dynamic constant.
104           * \sa MatrixBase::rows(), MatrixBase::cols(), ColsAtCompileTime, SizeAtCompileTime */
105 
106       ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
107         /**< The number of columns at compile-time. This is just a copy of the value provided
108           * by the \a Derived type. If a value is not known at compile-time,
109           * it is set to the \a Dynamic constant.
110           * \sa MatrixBase::rows(), MatrixBase::cols(), RowsAtCompileTime, SizeAtCompileTime */
111 
112 
113       SizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::RowsAtCompileTime,
114                                                    internal::traits<Derived>::ColsAtCompileTime>::ret),
115         /**< This is equal to the number of coefficients, i.e. the number of
116           * rows times the number of columns, or to \a Dynamic if this is not
117           * known at compile-time. \sa RowsAtCompileTime, ColsAtCompileTime */
118 
119       MaxRowsAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime,
120         /**< This value is equal to the maximum possible number of rows that this expression
121           * might have. If this expression might have an arbitrarily high number of rows,
122           * this value is set to \a Dynamic.
123           *
124           * This value is useful to know when evaluating an expression, in order to determine
125           * whether it is possible to avoid doing a dynamic memory allocation.
126           *
127           * \sa RowsAtCompileTime, MaxColsAtCompileTime, MaxSizeAtCompileTime
128           */
129 
130       MaxColsAtCompileTime = internal::traits<Derived>::MaxColsAtCompileTime,
131         /**< This value is equal to the maximum possible number of columns that this expression
132           * might have. If this expression might have an arbitrarily high number of columns,
133           * this value is set to \a Dynamic.
134           *
135           * This value is useful to know when evaluating an expression, in order to determine
136           * whether it is possible to avoid doing a dynamic memory allocation.
137           *
138           * \sa ColsAtCompileTime, MaxRowsAtCompileTime, MaxSizeAtCompileTime
139           */
140 
141       MaxSizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::MaxRowsAtCompileTime,
142                                                       internal::traits<Derived>::MaxColsAtCompileTime>::ret),
143         /**< This value is equal to the maximum possible number of coefficients that this expression
144           * might have. If this expression might have an arbitrarily high number of coefficients,
145           * this value is set to \a Dynamic.
146           *
147           * This value is useful to know when evaluating an expression, in order to determine
148           * whether it is possible to avoid doing a dynamic memory allocation.
149           *
150           * \sa SizeAtCompileTime, MaxRowsAtCompileTime, MaxColsAtCompileTime
151           */
152 
153       IsVectorAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime == 1
154                            || internal::traits<Derived>::MaxColsAtCompileTime == 1,
155         /**< This is set to true if either the number of rows or the number of
156           * columns is known at compile-time to be equal to 1. Indeed, in that case,
157           * we are dealing with a column-vector (if there is only one column) or with
158           * a row-vector (if there is only one row). */
159 
160       Flags = internal::traits<Derived>::Flags,
161         /**< This stores expression \ref flags flags which may or may not be inherited by new expressions
162           * constructed from this one. See the \ref flags "list of flags".
163           */
164 
165       IsRowMajor = int(Flags) & RowMajorBit, /**< True if this expression has row-major storage order. */
166 
167       InnerSizeAtCompileTime = int(IsVectorAtCompileTime) ? int(SizeAtCompileTime)
168                              : int(IsRowMajor) ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
169 
170       InnerStrideAtCompileTime = internal::inner_stride_at_compile_time<Derived>::ret,
171       OuterStrideAtCompileTime = internal::outer_stride_at_compile_time<Derived>::ret
172     };
173 
174     typedef typename internal::find_best_packet<Scalar,SizeAtCompileTime>::type PacketScalar;
175 
176     enum { IsPlainObjectBase = 0 };
177 
178     /** The plain matrix type corresponding to this expression.
179       * \sa PlainObject */
180     typedef Matrix<typename internal::traits<Derived>::Scalar,
181                 internal::traits<Derived>::RowsAtCompileTime,
182                 internal::traits<Derived>::ColsAtCompileTime,
183                 AutoAlign | (internal::traits<Derived>::Flags&RowMajorBit ? RowMajor : ColMajor),
184                 internal::traits<Derived>::MaxRowsAtCompileTime,
185                 internal::traits<Derived>::MaxColsAtCompileTime
186           > PlainMatrix;
187 
188     /** The plain array type corresponding to this expression.
189       * \sa PlainObject */
190     typedef Array<typename internal::traits<Derived>::Scalar,
191                 internal::traits<Derived>::RowsAtCompileTime,
192                 internal::traits<Derived>::ColsAtCompileTime,
193                 AutoAlign | (internal::traits<Derived>::Flags&RowMajorBit ? RowMajor : ColMajor),
194                 internal::traits<Derived>::MaxRowsAtCompileTime,
195                 internal::traits<Derived>::MaxColsAtCompileTime
196           > PlainArray;
197 
198     /** \brief The plain matrix or array type corresponding to this expression.
199       *
200       * This is not necessarily exactly the return type of eval(). In the case of plain matrices,
201       * the return type of eval() is a const reference to a matrix, not a matrix! It is however guaranteed
202       * that the return type of eval() is either PlainObject or const PlainObject&.
203       */
204     typedef typename internal::conditional<internal::is_same<typename internal::traits<Derived>::XprKind,MatrixXpr >::value,
205                                  PlainMatrix, PlainArray>::type PlainObject;
206 
207     /** \returns the number of nonzero coefficients which is in practice the number
208       * of stored coefficients. */
209     EIGEN_DEVICE_FUNC
nonZeros()210     inline Index nonZeros() const { return size(); }
211 
212     /** \returns the outer size.
213       *
214       * \note For a vector, this returns just 1. For a matrix (non-vector), this is the major dimension
215       * with respect to the \ref TopicStorageOrders "storage order", i.e., the number of columns for a
216       * column-major matrix, and the number of rows for a row-major matrix. */
217     EIGEN_DEVICE_FUNC
outerSize()218     Index outerSize() const
219     {
220       return IsVectorAtCompileTime ? 1
221            : int(IsRowMajor) ? this->rows() : this->cols();
222     }
223 
224     /** \returns the inner size.
225       *
226       * \note For a vector, this is just the size. For a matrix (non-vector), this is the minor dimension
227       * with respect to the \ref TopicStorageOrders "storage order", i.e., the number of rows for a
228       * column-major matrix, and the number of columns for a row-major matrix. */
229     EIGEN_DEVICE_FUNC
innerSize()230     Index innerSize() const
231     {
232       return IsVectorAtCompileTime ? this->size()
233            : int(IsRowMajor) ? this->cols() : this->rows();
234     }
235 
236     /** Only plain matrices/arrays, not expressions, may be resized; therefore the only useful resize methods are
237       * Matrix::resize() and Array::resize(). The present method only asserts that the new size equals the old size, and does
238       * nothing else.
239       */
240     EIGEN_DEVICE_FUNC
resize(Index newSize)241     void resize(Index newSize)
242     {
243       EIGEN_ONLY_USED_FOR_DEBUG(newSize);
244       eigen_assert(newSize == this->size()
245                 && "DenseBase::resize() does not actually allow to resize.");
246     }
247     /** Only plain matrices/arrays, not expressions, may be resized; therefore the only useful resize methods are
248       * Matrix::resize() and Array::resize(). The present method only asserts that the new size equals the old size, and does
249       * nothing else.
250       */
251     EIGEN_DEVICE_FUNC
resize(Index rows,Index cols)252     void resize(Index rows, Index cols)
253     {
254       EIGEN_ONLY_USED_FOR_DEBUG(rows);
255       EIGEN_ONLY_USED_FOR_DEBUG(cols);
256       eigen_assert(rows == this->rows() && cols == this->cols()
257                 && "DenseBase::resize() does not actually allow to resize.");
258     }
259 
260 #ifndef EIGEN_PARSED_BY_DOXYGEN
261     /** \internal Represents a matrix with all coefficients equal to one another*/
262     typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,PlainObject> ConstantReturnType;
263     /** \internal \deprecated Represents a vector with linearly spaced coefficients that allows sequential access only. */
264     typedef CwiseNullaryOp<internal::linspaced_op<Scalar,PacketScalar>,PlainObject> SequentialLinSpacedReturnType;
265     /** \internal Represents a vector with linearly spaced coefficients that allows random access. */
266     typedef CwiseNullaryOp<internal::linspaced_op<Scalar,PacketScalar>,PlainObject> RandomAccessLinSpacedReturnType;
267     /** \internal the return type of MatrixBase::eigenvalues() */
268     typedef Matrix<typename NumTraits<typename internal::traits<Derived>::Scalar>::Real, internal::traits<Derived>::ColsAtCompileTime, 1> EigenvaluesReturnType;
269 
270 #endif // not EIGEN_PARSED_BY_DOXYGEN
271 
272     /** Copies \a other into *this. \returns a reference to *this. */
273     template<typename OtherDerived>
274     EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
275     Derived& operator=(const DenseBase<OtherDerived>& other);
276 
277     /** Special case of the template operator=, in order to prevent the compiler
278       * from generating a default operator= (issue hit with g++ 4.1)
279       */
280     EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
281     Derived& operator=(const DenseBase& other);
282 
283     template<typename OtherDerived>
284     EIGEN_DEVICE_FUNC
285     Derived& operator=(const EigenBase<OtherDerived> &other);
286 
287     template<typename OtherDerived>
288     EIGEN_DEVICE_FUNC
289     Derived& operator+=(const EigenBase<OtherDerived> &other);
290 
291     template<typename OtherDerived>
292     EIGEN_DEVICE_FUNC
293     Derived& operator-=(const EigenBase<OtherDerived> &other);
294 
295     template<typename OtherDerived>
296     EIGEN_DEVICE_FUNC
297     Derived& operator=(const ReturnByValue<OtherDerived>& func);
298 
299     /** \internal
300       * Copies \a other into *this without evaluating other. \returns a reference to *this.
301       * \deprecated */
302     template<typename OtherDerived>
303     EIGEN_DEVICE_FUNC
304     Derived& lazyAssign(const DenseBase<OtherDerived>& other);
305 
306     EIGEN_DEVICE_FUNC
307     CommaInitializer<Derived> operator<< (const Scalar& s);
308 
309     /** \deprecated it now returns \c *this */
310     template<unsigned int Added,unsigned int Removed>
311     EIGEN_DEPRECATED
flagged()312     const Derived& flagged() const
313     { return derived(); }
314 
315     template<typename OtherDerived>
316     EIGEN_DEVICE_FUNC
317     CommaInitializer<Derived> operator<< (const DenseBase<OtherDerived>& other);
318 
319     typedef Transpose<Derived> TransposeReturnType;
320     EIGEN_DEVICE_FUNC
321     TransposeReturnType transpose();
322     typedef typename internal::add_const<Transpose<const Derived> >::type ConstTransposeReturnType;
323     EIGEN_DEVICE_FUNC
324     ConstTransposeReturnType transpose() const;
325     EIGEN_DEVICE_FUNC
326     void transposeInPlace();
327 
328     EIGEN_DEVICE_FUNC static const ConstantReturnType
329     Constant(Index rows, Index cols, const Scalar& value);
330     EIGEN_DEVICE_FUNC static const ConstantReturnType
331     Constant(Index size, const Scalar& value);
332     EIGEN_DEVICE_FUNC static const ConstantReturnType
333     Constant(const Scalar& value);
334 
335     EIGEN_DEVICE_FUNC static const SequentialLinSpacedReturnType
336     LinSpaced(Sequential_t, Index size, const Scalar& low, const Scalar& high);
337     EIGEN_DEVICE_FUNC static const RandomAccessLinSpacedReturnType
338     LinSpaced(Index size, const Scalar& low, const Scalar& high);
339     EIGEN_DEVICE_FUNC static const SequentialLinSpacedReturnType
340     LinSpaced(Sequential_t, const Scalar& low, const Scalar& high);
341     EIGEN_DEVICE_FUNC static const RandomAccessLinSpacedReturnType
342     LinSpaced(const Scalar& low, const Scalar& high);
343 
344     template<typename CustomNullaryOp> EIGEN_DEVICE_FUNC
345     static const CwiseNullaryOp<CustomNullaryOp, PlainObject>
346     NullaryExpr(Index rows, Index cols, const CustomNullaryOp& func);
347     template<typename CustomNullaryOp> EIGEN_DEVICE_FUNC
348     static const CwiseNullaryOp<CustomNullaryOp, PlainObject>
349     NullaryExpr(Index size, const CustomNullaryOp& func);
350     template<typename CustomNullaryOp> EIGEN_DEVICE_FUNC
351     static const CwiseNullaryOp<CustomNullaryOp, PlainObject>
352     NullaryExpr(const CustomNullaryOp& func);
353 
354     EIGEN_DEVICE_FUNC static const ConstantReturnType Zero(Index rows, Index cols);
355     EIGEN_DEVICE_FUNC static const ConstantReturnType Zero(Index size);
356     EIGEN_DEVICE_FUNC static const ConstantReturnType Zero();
357     EIGEN_DEVICE_FUNC static const ConstantReturnType Ones(Index rows, Index cols);
358     EIGEN_DEVICE_FUNC static const ConstantReturnType Ones(Index size);
359     EIGEN_DEVICE_FUNC static const ConstantReturnType Ones();
360 
361     EIGEN_DEVICE_FUNC void fill(const Scalar& value);
362     EIGEN_DEVICE_FUNC Derived& setConstant(const Scalar& value);
363     EIGEN_DEVICE_FUNC Derived& setLinSpaced(Index size, const Scalar& low, const Scalar& high);
364     EIGEN_DEVICE_FUNC Derived& setLinSpaced(const Scalar& low, const Scalar& high);
365     EIGEN_DEVICE_FUNC Derived& setZero();
366     EIGEN_DEVICE_FUNC Derived& setOnes();
367     EIGEN_DEVICE_FUNC Derived& setRandom();
368 
369     template<typename OtherDerived> EIGEN_DEVICE_FUNC
370     bool isApprox(const DenseBase<OtherDerived>& other,
371                   const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
372     EIGEN_DEVICE_FUNC
373     bool isMuchSmallerThan(const RealScalar& other,
374                            const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
375     template<typename OtherDerived> EIGEN_DEVICE_FUNC
376     bool isMuchSmallerThan(const DenseBase<OtherDerived>& other,
377                            const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
378 
379     EIGEN_DEVICE_FUNC bool isApproxToConstant(const Scalar& value, const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
380     EIGEN_DEVICE_FUNC bool isConstant(const Scalar& value, const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
381     EIGEN_DEVICE_FUNC bool isZero(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
382     EIGEN_DEVICE_FUNC bool isOnes(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
383 
384     inline bool hasNaN() const;
385     inline bool allFinite() const;
386 
387     EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
388     Derived& operator*=(const Scalar& other);
389     EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
390     Derived& operator/=(const Scalar& other);
391 
392     typedef typename internal::add_const_on_value_type<typename internal::eval<Derived>::type>::type EvalReturnType;
393     /** \returns the matrix or vector obtained by evaluating this expression.
394       *
395       * Notice that in the case of a plain matrix or vector (not an expression) this function just returns
396       * a const reference, in order to avoid a useless copy.
397       *
398       * \warning Be carefull with eval() and the auto C++ keyword, as detailed in this \link TopicPitfalls_auto_keyword page \endlink.
399       */
400     EIGEN_DEVICE_FUNC
eval()401     EIGEN_STRONG_INLINE EvalReturnType eval() const
402     {
403       // Even though MSVC does not honor strong inlining when the return type
404       // is a dynamic matrix, we desperately need strong inlining for fixed
405       // size types on MSVC.
406       return typename internal::eval<Derived>::type(derived());
407     }
408 
409     /** swaps *this with the expression \a other.
410       *
411       */
412     template<typename OtherDerived>
413     EIGEN_DEVICE_FUNC
swap(const DenseBase<OtherDerived> & other)414     void swap(const DenseBase<OtherDerived>& other)
415     {
416       EIGEN_STATIC_ASSERT(!OtherDerived::IsPlainObjectBase,THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY);
417       eigen_assert(rows()==other.rows() && cols()==other.cols());
418       call_assignment(derived(), other.const_cast_derived(), internal::swap_assign_op<Scalar>());
419     }
420 
421     /** swaps *this with the matrix or array \a other.
422       *
423       */
424     template<typename OtherDerived>
425     EIGEN_DEVICE_FUNC
swap(PlainObjectBase<OtherDerived> & other)426     void swap(PlainObjectBase<OtherDerived>& other)
427     {
428       eigen_assert(rows()==other.rows() && cols()==other.cols());
429       call_assignment(derived(), other.derived(), internal::swap_assign_op<Scalar>());
430     }
431 
432     EIGEN_DEVICE_FUNC inline const NestByValue<Derived> nestByValue() const;
433     EIGEN_DEVICE_FUNC inline const ForceAlignedAccess<Derived> forceAlignedAccess() const;
434     EIGEN_DEVICE_FUNC inline ForceAlignedAccess<Derived> forceAlignedAccess();
435     template<bool Enable> EIGEN_DEVICE_FUNC
436     inline const typename internal::conditional<Enable,ForceAlignedAccess<Derived>,Derived&>::type forceAlignedAccessIf() const;
437     template<bool Enable> EIGEN_DEVICE_FUNC
438     inline typename internal::conditional<Enable,ForceAlignedAccess<Derived>,Derived&>::type forceAlignedAccessIf();
439 
440     EIGEN_DEVICE_FUNC Scalar sum() const;
441     EIGEN_DEVICE_FUNC Scalar mean() const;
442     EIGEN_DEVICE_FUNC Scalar trace() const;
443 
444     EIGEN_DEVICE_FUNC Scalar prod() const;
445 
446     EIGEN_DEVICE_FUNC typename internal::traits<Derived>::Scalar minCoeff() const;
447     EIGEN_DEVICE_FUNC typename internal::traits<Derived>::Scalar maxCoeff() const;
448 
449     template<typename IndexType> EIGEN_DEVICE_FUNC
450     typename internal::traits<Derived>::Scalar minCoeff(IndexType* row, IndexType* col) const;
451     template<typename IndexType> EIGEN_DEVICE_FUNC
452     typename internal::traits<Derived>::Scalar maxCoeff(IndexType* row, IndexType* col) const;
453     template<typename IndexType> EIGEN_DEVICE_FUNC
454     typename internal::traits<Derived>::Scalar minCoeff(IndexType* index) const;
455     template<typename IndexType> EIGEN_DEVICE_FUNC
456     typename internal::traits<Derived>::Scalar maxCoeff(IndexType* index) const;
457 
458     template<typename BinaryOp>
459     EIGEN_DEVICE_FUNC
460     Scalar redux(const BinaryOp& func) const;
461 
462     template<typename Visitor>
463     EIGEN_DEVICE_FUNC
464     void visit(Visitor& func) const;
465 
466     /** \returns a WithFormat proxy object allowing to print a matrix the with given
467       * format \a fmt.
468       *
469       * See class IOFormat for some examples.
470       *
471       * \sa class IOFormat, class WithFormat
472       */
format(const IOFormat & fmt)473     inline const WithFormat<Derived> format(const IOFormat& fmt) const
474     {
475       return WithFormat<Derived>(derived(), fmt);
476     }
477 
478     /** \returns the unique coefficient of a 1x1 expression */
479     EIGEN_DEVICE_FUNC
value()480     CoeffReturnType value() const
481     {
482       EIGEN_STATIC_ASSERT_SIZE_1x1(Derived)
483       eigen_assert(this->rows() == 1 && this->cols() == 1);
484       return derived().coeff(0,0);
485     }
486 
487     EIGEN_DEVICE_FUNC bool all() const;
488     EIGEN_DEVICE_FUNC bool any() const;
489     EIGEN_DEVICE_FUNC Index count() const;
490 
491     typedef VectorwiseOp<Derived, Horizontal> RowwiseReturnType;
492     typedef const VectorwiseOp<const Derived, Horizontal> ConstRowwiseReturnType;
493     typedef VectorwiseOp<Derived, Vertical> ColwiseReturnType;
494     typedef const VectorwiseOp<const Derived, Vertical> ConstColwiseReturnType;
495 
496     /** \returns a VectorwiseOp wrapper of *this providing additional partial reduction operations
497     *
498     * Example: \include MatrixBase_rowwise.cpp
499     * Output: \verbinclude MatrixBase_rowwise.out
500     *
501     * \sa colwise(), class VectorwiseOp, \ref TutorialReductionsVisitorsBroadcasting
502     */
503     //Code moved here due to a CUDA compiler bug
rowwise()504     EIGEN_DEVICE_FUNC inline ConstRowwiseReturnType rowwise() const {
505       return ConstRowwiseReturnType(derived());
506     }
507     EIGEN_DEVICE_FUNC RowwiseReturnType rowwise();
508 
509     /** \returns a VectorwiseOp wrapper of *this providing additional partial reduction operations
510     *
511     * Example: \include MatrixBase_colwise.cpp
512     * Output: \verbinclude MatrixBase_colwise.out
513     *
514     * \sa rowwise(), class VectorwiseOp, \ref TutorialReductionsVisitorsBroadcasting
515     */
colwise()516     EIGEN_DEVICE_FUNC inline ConstColwiseReturnType colwise() const {
517       return ConstColwiseReturnType(derived());
518     }
519     EIGEN_DEVICE_FUNC ColwiseReturnType colwise();
520 
521     typedef CwiseNullaryOp<internal::scalar_random_op<Scalar>,PlainObject> RandomReturnType;
522     static const RandomReturnType Random(Index rows, Index cols);
523     static const RandomReturnType Random(Index size);
524     static const RandomReturnType Random();
525 
526     template<typename ThenDerived,typename ElseDerived>
527     const Select<Derived,ThenDerived,ElseDerived>
528     select(const DenseBase<ThenDerived>& thenMatrix,
529            const DenseBase<ElseDerived>& elseMatrix) const;
530 
531     template<typename ThenDerived>
532     inline const Select<Derived,ThenDerived, typename ThenDerived::ConstantReturnType>
533     select(const DenseBase<ThenDerived>& thenMatrix, const typename ThenDerived::Scalar& elseScalar) const;
534 
535     template<typename ElseDerived>
536     inline const Select<Derived, typename ElseDerived::ConstantReturnType, ElseDerived >
537     select(const typename ElseDerived::Scalar& thenScalar, const DenseBase<ElseDerived>& elseMatrix) const;
538 
539     template<int p> RealScalar lpNorm() const;
540 
541     template<int RowFactor, int ColFactor>
542     EIGEN_DEVICE_FUNC
543     const Replicate<Derived,RowFactor,ColFactor> replicate() const;
544     /**
545     * \return an expression of the replication of \c *this
546     *
547     * Example: \include MatrixBase_replicate_int_int.cpp
548     * Output: \verbinclude MatrixBase_replicate_int_int.out
549     *
550     * \sa VectorwiseOp::replicate(), DenseBase::replicate<int,int>(), class Replicate
551     */
552     //Code moved here due to a CUDA compiler bug
553     EIGEN_DEVICE_FUNC
replicate(Index rowFactor,Index colFactor)554     const Replicate<Derived, Dynamic, Dynamic> replicate(Index rowFactor, Index colFactor) const
555     {
556       return Replicate<Derived, Dynamic, Dynamic>(derived(), rowFactor, colFactor);
557     }
558 
559     typedef Reverse<Derived, BothDirections> ReverseReturnType;
560     typedef const Reverse<const Derived, BothDirections> ConstReverseReturnType;
561     EIGEN_DEVICE_FUNC ReverseReturnType reverse();
562     /** This is the const version of reverse(). */
563     //Code moved here due to a CUDA compiler bug
reverse()564     EIGEN_DEVICE_FUNC ConstReverseReturnType reverse() const
565     {
566       return ConstReverseReturnType(derived());
567     }
568     EIGEN_DEVICE_FUNC void reverseInPlace();
569 
570 #define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::DenseBase
571 #define EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
572 #define EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(COND)
573 #   include "../plugins/BlockMethods.h"
574 #   ifdef EIGEN_DENSEBASE_PLUGIN
575 #     include EIGEN_DENSEBASE_PLUGIN
576 #   endif
577 #undef EIGEN_CURRENT_STORAGE_BASE_CLASS
578 #undef EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
579 #undef EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF
580 
581     // disable the use of evalTo for dense objects with a nice compilation error
582     template<typename Dest>
583     EIGEN_DEVICE_FUNC
evalTo(Dest &)584     inline void evalTo(Dest& ) const
585     {
586       EIGEN_STATIC_ASSERT((internal::is_same<Dest,void>::value),THE_EVAL_EVALTO_FUNCTION_SHOULD_NEVER_BE_CALLED_FOR_DENSE_OBJECTS);
587     }
588 
589   protected:
590     /** Default constructor. Do nothing. */
DenseBase()591     EIGEN_DEVICE_FUNC DenseBase()
592     {
593       /* Just checks for self-consistency of the flags.
594        * Only do it when debugging Eigen, as this borders on paranoiac and could slow compilation down
595        */
596 #ifdef EIGEN_INTERNAL_DEBUGGING
597       EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, int(IsRowMajor))
598                         && EIGEN_IMPLIES(MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1, int(!IsRowMajor))),
599                           INVALID_STORAGE_ORDER_FOR_THIS_VECTOR_EXPRESSION)
600 #endif
601     }
602 
603   private:
604     EIGEN_DEVICE_FUNC explicit DenseBase(int);
605     EIGEN_DEVICE_FUNC DenseBase(int,int);
606     template<typename OtherDerived> EIGEN_DEVICE_FUNC explicit DenseBase(const DenseBase<OtherDerived>&);
607 };
608 
609 } // end namespace Eigen
610 
611 #endif // EIGEN_DENSEBASE_H
612