DenseBase.h
Go to the documentation of this file.
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.
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 
41 template<typename Derived> class DenseBase
42 #ifndef EIGEN_PARSED_BY_DOXYGEN
43  : public internal::special_scalar_op_base<Derived,typename internal::traits<Derived>::Scalar,
44  typename NumTraits<typename internal::traits<Derived>::Scalar>::Real>
45 #else
46  : public DenseCoeffsBase<Derived>
47 #endif // not EIGEN_PARSED_BY_DOXYGEN
48 {
49  public:
50  using internal::special_scalar_op_base<Derived,typename internal::traits<Derived>::Scalar,
51  typename NumTraits<typename internal::traits<Derived>::Scalar>::Real>::operator*;
52 
53  class InnerIterator;
54 
55  typedef typename internal::traits<Derived>::StorageKind StorageKind;
56 
61  typedef typename internal::traits<Derived>::Index Index;
62 
63  typedef typename internal::traits<Derived>::Scalar Scalar;
64  typedef typename internal::packet_traits<Scalar>::type PacketScalar;
65  typedef typename NumTraits<Scalar>::Real RealScalar;
66 
67  typedef DenseCoeffsBase<Derived> Base;
68  using Base::derived;
69  using Base::const_cast_derived;
70  using Base::rows;
71  using Base::cols;
72  using Base::size;
73  using Base::rowIndexByOuterInner;
74  using Base::colIndexByOuterInner;
75  using Base::coeff;
76  using Base::coeffByOuterInner;
77  using Base::packet;
78  using Base::packetByOuterInner;
79  using Base::writePacket;
80  using Base::writePacketByOuterInner;
81  using Base::coeffRef;
82  using Base::coeffRefByOuterInner;
83  using Base::copyCoeff;
84  using Base::copyCoeffByOuterInner;
85  using Base::copyPacket;
86  using Base::copyPacketByOuterInner;
87  using Base::operator();
88  using Base::operator[];
89  using Base::x;
90  using Base::y;
91  using Base::z;
92  using Base::w;
93  using Base::stride;
94  using Base::innerStride;
95  using Base::outerStride;
96  using Base::rowStride;
97  using Base::colStride;
98  typedef typename Base::CoeffReturnType CoeffReturnType;
99 
100  enum {
101 
102  RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
108  ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
115  SizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::RowsAtCompileTime,
116  internal::traits<Derived>::ColsAtCompileTime>::ret),
121  MaxRowsAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime,
132  MaxColsAtCompileTime = internal::traits<Derived>::MaxColsAtCompileTime,
143  MaxSizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::MaxRowsAtCompileTime,
144  internal::traits<Derived>::MaxColsAtCompileTime>::ret),
155  IsVectorAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime == 1
156  || internal::traits<Derived>::MaxColsAtCompileTime == 1,
162  Flags = internal::traits<Derived>::Flags,
167  IsRowMajor = int(Flags) & RowMajorBit,
169  InnerSizeAtCompileTime = int(IsVectorAtCompileTime) ? int(SizeAtCompileTime)
170  : int(IsRowMajor) ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
171 
172  CoeffReadCost = internal::traits<Derived>::CoeffReadCost,
177  InnerStrideAtCompileTime = internal::inner_stride_at_compile_time<Derived>::ret,
178  OuterStrideAtCompileTime = internal::outer_stride_at_compile_time<Derived>::ret
179  };
180 
181  enum { ThisConstantIsPrivateInPlainObjectBase };
182 
185  inline Index nonZeros() const { return size(); }
196  Index outerSize() const
197  {
198  return IsVectorAtCompileTime ? 1
199  : int(IsRowMajor) ? this->rows() : this->cols();
200  }
201 
207  Index innerSize() const
208  {
209  return IsVectorAtCompileTime ? this->size()
210  : int(IsRowMajor) ? this->cols() : this->rows();
211  }
212 
217  void resize(Index newSize)
218  {
219  EIGEN_ONLY_USED_FOR_DEBUG(newSize);
220  eigen_assert(newSize == this->size()
221  && "DenseBase::resize() does not actually allow to resize.");
222  }
227  void resize(Index nbRows, Index nbCols)
228  {
229  EIGEN_ONLY_USED_FOR_DEBUG(nbRows);
230  EIGEN_ONLY_USED_FOR_DEBUG(nbCols);
231  eigen_assert(nbRows == this->rows() && nbCols == this->cols()
232  && "DenseBase::resize() does not actually allow to resize.");
233  }
234 
235 #ifndef EIGEN_PARSED_BY_DOXYGEN
236 
238  typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,Derived> ConstantReturnType;
240  typedef CwiseNullaryOp<internal::linspaced_op<Scalar,false>,Derived> SequentialLinSpacedReturnType;
242  typedef CwiseNullaryOp<internal::linspaced_op<Scalar,true>,Derived> RandomAccessLinSpacedReturnType;
244  typedef Matrix<typename NumTraits<typename internal::traits<Derived>::Scalar>::Real, internal::traits<Derived>::ColsAtCompileTime, 1> EigenvaluesReturnType;
245 
246 #endif // not EIGEN_PARSED_BY_DOXYGEN
247 
249  template<typename OtherDerived>
250  Derived& operator=(const DenseBase<OtherDerived>& other);
251 
255  Derived& operator=(const DenseBase& other);
256 
257  template<typename OtherDerived>
258  Derived& operator=(const EigenBase<OtherDerived> &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 ReturnByValue<OtherDerived>& func);
268 
269 #ifndef EIGEN_PARSED_BY_DOXYGEN
270 
271  template<typename OtherDerived>
272  Derived& lazyAssign(const DenseBase<OtherDerived>& other);
273 #endif // not EIGEN_PARSED_BY_DOXYGEN
274 
275  CommaInitializer<Derived> operator<< (const Scalar& s);
276 
277  template<unsigned int Added,unsigned int Removed>
278  const Flagged<Derived, Added, Removed> flagged() const;
279 
280  template<typename OtherDerived>
281  CommaInitializer<Derived> operator<< (const DenseBase<OtherDerived>& other);
282 
283  Eigen::Transpose<Derived> transpose();
284  typedef typename internal::add_const<Transpose<const Derived> >::type ConstTransposeReturnType;
285  ConstTransposeReturnType transpose() const;
286  void transposeInPlace();
287 #ifndef EIGEN_NO_DEBUG
288  protected:
289  template<typename OtherDerived>
290  void checkTransposeAliasing(const OtherDerived& other) const;
291  public:
292 #endif
293 
294 
295  static const ConstantReturnType
296  Constant(Index rows, Index cols, const Scalar& value);
297  static const ConstantReturnType
298  Constant(Index size, const Scalar& value);
299  static const ConstantReturnType
300  Constant(const Scalar& value);
301 
302  static const SequentialLinSpacedReturnType
303  LinSpaced(Sequential_t, Index size, const Scalar& low, const Scalar& high);
304  static const RandomAccessLinSpacedReturnType
305  LinSpaced(Index size, const Scalar& low, const Scalar& high);
306  static const SequentialLinSpacedReturnType
307  LinSpaced(Sequential_t, const Scalar& low, const Scalar& high);
308  static const RandomAccessLinSpacedReturnType
309  LinSpaced(const Scalar& low, const Scalar& high);
310 
311  template<typename CustomNullaryOp>
312  static const CwiseNullaryOp<CustomNullaryOp, Derived>
313  NullaryExpr(Index rows, Index cols, const CustomNullaryOp& func);
314  template<typename CustomNullaryOp>
315  static const CwiseNullaryOp<CustomNullaryOp, Derived>
316  NullaryExpr(Index size, const CustomNullaryOp& func);
317  template<typename CustomNullaryOp>
318  static const CwiseNullaryOp<CustomNullaryOp, Derived>
319  NullaryExpr(const CustomNullaryOp& func);
320 
321  static const ConstantReturnType Zero(Index rows, Index cols);
322  static const ConstantReturnType Zero(Index size);
323  static const ConstantReturnType Zero();
324  static const ConstantReturnType Ones(Index rows, Index cols);
325  static const ConstantReturnType Ones(Index size);
326  static const ConstantReturnType Ones();
327 
328  void fill(const Scalar& value);
329  Derived& setConstant(const Scalar& value);
330  Derived& setLinSpaced(Index size, const Scalar& low, const Scalar& high);
331  Derived& setLinSpaced(const Scalar& low, const Scalar& high);
332  Derived& setZero();
333  Derived& setOnes();
334  Derived& setRandom();
335 
336  template<typename OtherDerived>
337  bool isApprox(const DenseBase<OtherDerived>& other,
338  const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
339  bool isMuchSmallerThan(const RealScalar& other,
340  const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
341  template<typename OtherDerived>
342  bool isMuchSmallerThan(const DenseBase<OtherDerived>& other,
343  const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
344 
345  bool isApproxToConstant(const Scalar& value, const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
346  bool isConstant(const Scalar& value, const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
347  bool isZero(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
348  bool isOnes(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
349 
350  inline bool hasNaN() const;
351  inline bool allFinite() const;
352 
353  inline Derived& operator*=(const Scalar& other);
354  inline Derived& operator/=(const Scalar& other);
355 
356  typedef typename internal::add_const_on_value_type<typename internal::eval<Derived>::type>::type EvalReturnType;
362  EIGEN_STRONG_INLINE EvalReturnType eval() const
363  {
364  // Even though MSVC does not honor strong inlining when the return type
365  // is a dynamic matrix, we desperately need strong inlining for fixed
366  // size types on MSVC.
367  return typename internal::eval<Derived>::type(derived());
368  }
369 
373  template<typename OtherDerived>
374  void swap(const DenseBase<OtherDerived>& other,
375  int = OtherDerived::ThisConstantIsPrivateInPlainObjectBase)
376  {
377  SwapWrapper<Derived>(derived()).lazyAssign(other.derived());
378  }
379 
383  template<typename OtherDerived>
384  void swap(PlainObjectBase<OtherDerived>& other)
385  {
386  SwapWrapper<Derived>(derived()).lazyAssign(other.derived());
387  }
388 
389 
390  inline const NestByValue<Derived> nestByValue() const;
391  inline const ForceAlignedAccess<Derived> forceAlignedAccess() const;
392  inline ForceAlignedAccess<Derived> forceAlignedAccess();
393  template<bool Enable> inline const typename internal::conditional<Enable,ForceAlignedAccess<Derived>,Derived&>::type forceAlignedAccessIf() const;
394  template<bool Enable> inline typename internal::conditional<Enable,ForceAlignedAccess<Derived>,Derived&>::type forceAlignedAccessIf();
395 
396  Scalar sum() const;
397  Scalar mean() const;
398  Scalar trace() const;
399 
400  Scalar prod() const;
401 
402  typename internal::traits<Derived>::Scalar minCoeff() const;
403  typename internal::traits<Derived>::Scalar maxCoeff() const;
404 
405  template<typename IndexType>
406  typename internal::traits<Derived>::Scalar minCoeff(IndexType* row, IndexType* col) const;
407  template<typename IndexType>
408  typename internal::traits<Derived>::Scalar maxCoeff(IndexType* row, IndexType* col) const;
409  template<typename IndexType>
410  typename internal::traits<Derived>::Scalar minCoeff(IndexType* index) const;
411  template<typename IndexType>
412  typename internal::traits<Derived>::Scalar maxCoeff(IndexType* index) const;
413 
414  template<typename BinaryOp>
415  typename internal::result_of<BinaryOp(typename internal::traits<Derived>::Scalar)>::type
416  redux(const BinaryOp& func) const;
417 
418  template<typename Visitor>
419  void visit(Visitor& func) const;
420 
421  inline const WithFormat<Derived> format(const IOFormat& fmt) const;
422 
424  CoeffReturnType value() const
425  {
426  EIGEN_STATIC_ASSERT_SIZE_1x1(Derived)
427  eigen_assert(this->rows() == 1 && this->cols() == 1);
428  return derived().coeff(0,0);
429  }
430 
431  bool all(void) const;
432  bool any(void) const;
433  Index count() const;
434 
435  typedef VectorwiseOp<Derived, Horizontal> RowwiseReturnType;
436  typedef const VectorwiseOp<const Derived, Horizontal> ConstRowwiseReturnType;
437  typedef VectorwiseOp<Derived, Vertical> ColwiseReturnType;
438  typedef const VectorwiseOp<const Derived, Vertical> ConstColwiseReturnType;
439 
440  ConstRowwiseReturnType rowwise() const;
441  RowwiseReturnType rowwise();
442  ConstColwiseReturnType colwise() const;
443  ColwiseReturnType colwise();
444 
445  static const CwiseNullaryOp<internal::scalar_random_op<Scalar>,Derived> Random(Index rows, Index cols);
446  static const CwiseNullaryOp<internal::scalar_random_op<Scalar>,Derived> Random(Index size);
447  static const CwiseNullaryOp<internal::scalar_random_op<Scalar>,Derived> Random();
448 
449  template<typename ThenDerived,typename ElseDerived>
450  const Select<Derived,ThenDerived,ElseDerived>
451  select(const DenseBase<ThenDerived>& thenMatrix,
452  const DenseBase<ElseDerived>& elseMatrix) const;
453 
454  template<typename ThenDerived>
455  inline const Select<Derived,ThenDerived, typename ThenDerived::ConstantReturnType>
456  select(const DenseBase<ThenDerived>& thenMatrix, const typename ThenDerived::Scalar& elseScalar) const;
457 
458  template<typename ElseDerived>
459  inline const Select<Derived, typename ElseDerived::ConstantReturnType, ElseDerived >
460  select(const typename ElseDerived::Scalar& thenScalar, const DenseBase<ElseDerived>& elseMatrix) const;
461 
462  template<int p> RealScalar lpNorm() const;
463 
464  template<int RowFactor, int ColFactor>
465  const Replicate<Derived,RowFactor,ColFactor> replicate() const;
466  const Replicate<Derived,Dynamic,Dynamic> replicate(Index rowFacor,Index colFactor) const;
467 
468  typedef Reverse<Derived, BothDirections> ReverseReturnType;
469  typedef const Reverse<const Derived, BothDirections> ConstReverseReturnType;
470  ReverseReturnType reverse();
471  ConstReverseReturnType reverse() const;
472  void reverseInPlace();
473 
474 #define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::DenseBase
475 # include "../plugins/BlockMethods.h"
476 # ifdef EIGEN_DENSEBASE_PLUGIN
477 # include EIGEN_DENSEBASE_PLUGIN
478 # endif
479 #undef EIGEN_CURRENT_STORAGE_BASE_CLASS
480 
481 #ifdef EIGEN2_SUPPORT
482 
483  Block<Derived> corner(CornerType type, Index cRows, Index cCols);
484  const Block<Derived> corner(CornerType type, Index cRows, Index cCols) const;
485  template<int CRows, int CCols>
486  Block<Derived, CRows, CCols> corner(CornerType type);
487  template<int CRows, int CCols>
488  const Block<Derived, CRows, CCols> corner(CornerType type) const;
489 
490 #endif // EIGEN2_SUPPORT
491 
492 
493  // disable the use of evalTo for dense objects with a nice compilation error
494  template<typename Dest> inline void evalTo(Dest& ) const
495  {
496  EIGEN_STATIC_ASSERT((internal::is_same<Dest,void>::value),THE_EVAL_EVALTO_FUNCTION_SHOULD_NEVER_BE_CALLED_FOR_DENSE_OBJECTS);
497  }
498 
499  protected:
501  DenseBase()
502  {
503  /* Just checks for self-consistency of the flags.
504  * Only do it when debugging Eigen, as this borders on paranoiac and could slow compilation down
505  */
506 #ifdef EIGEN_INTERNAL_DEBUGGING
507  EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, int(IsRowMajor))
508  && EIGEN_IMPLIES(MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1, int(!IsRowMajor))),
509  INVALID_STORAGE_ORDER_FOR_THIS_VECTOR_EXPRESSION)
510 #endif
511  }
512 
513  private:
514  explicit DenseBase(int);
515  DenseBase(int,int);
516  template<typename OtherDerived> explicit DenseBase(const DenseBase<OtherDerived>&);
517 };
518 
519 } // end namespace Eigen
520 
521 #endif // EIGEN_DENSEBASE_H
Eigen::CwiseNullaryOp
Generic expression of a matrix where all coefficients are defined by a functor.
Definition: CwiseNullaryOp.h:49
EIGEN_STATIC_ASSERT_SIZE_1x1
#define EIGEN_STATIC_ASSERT_SIZE_1x1(TYPE)
Definition: StaticAssert.h:186
Eigen::DenseBase::RandomAccessLinSpacedReturnType
CwiseNullaryOp< internal::linspaced_op< Scalar, true >, Derived > RandomAccessLinSpacedReturnType
Definition: DenseBase.h:242
Eigen::ForceAlignedAccess
Enforce aligned packet loads and stores regardless of what is requested.
Definition: ForceAlignedAccess.h:34
Eigen::DenseBase::PacketScalar
internal::packet_traits< Scalar >::type PacketScalar
Definition: DenseBase.h:64
EIGEN_STRONG_INLINE
#define EIGEN_STRONG_INLINE
Definition: Core/util/Macros.h:124
Eigen::DenseBase::Scalar
internal::traits< Derived >::Scalar Scalar
Definition: DenseBase.h:63
Eigen::CornerType
CornerType
Definition: eigen3/Eigen/src/Core/util/Constants.h:201
EIGEN_ONLY_USED_FOR_DEBUG
#define EIGEN_ONLY_USED_FOR_DEBUG(x)
Definition: Core/util/Macros.h:219
Eigen::DenseBase::CoeffReturnType
Base::CoeffReturnType CoeffReturnType
Definition: DenseBase.h:98
Eigen::Flagged
Expression with modified flags.
Definition: Flagged.h:39
isZero
BooleanType isZero(real_t x, real_t TOL=ZERO)
Eigen::DenseBase::Index
internal::traits< Derived >::Index Index
The type of indices.
Definition: DenseBase.h:61
Eigen::internal::is_same
Definition: Core/util/Meta.h:34
Eigen::DenseBase::StorageKind
internal::traits< Derived >::StorageKind StorageKind
Definition: DenseBase.h:53
Eigen::Transpose
Expression of the transpose of a matrix.
Definition: Transpose.h:57
Eigen::internal::check_DenseIndex_is_signed
static void check_DenseIndex_is_signed()
Definition: DenseBase.h:20
Eigen::DenseBase::ConstTransposeReturnType
internal::add_const< Transpose< const Derived > >::type ConstTransposeReturnType
Definition: DenseBase.h:284
Eigen::DenseBase::Base
DenseCoeffsBase< Derived > Base
Definition: DenseBase.h:67
Eigen::DenseBase::ConstRowwiseReturnType
const VectorwiseOp< const Derived, Horizontal > ConstRowwiseReturnType
Definition: DenseBase.h:436
Eigen
iterative scaling algorithm to equilibrate rows and column norms in matrices
Definition: matrix.hpp:471
Eigen::DenseBase::SequentialLinSpacedReturnType
CwiseNullaryOp< internal::linspaced_op< Scalar, false >, Derived > SequentialLinSpacedReturnType
Definition: DenseBase.h:240
Eigen::NumTraits
Holds information about the various numeric (i.e. scalar) types allowed by Eigen. ...
Definition: NumTraits.h:88
EIGEN_STATIC_ASSERT
#define EIGEN_STATIC_ASSERT(CONDITION, MSG)
Definition: StaticAssert.h:111
Eigen::VectorwiseOp
Pseudo expression providing partial reduction operations.
Definition: ForwardDeclarations.h:212
Eigen::DenseBase::RowwiseReturnType
VectorwiseOp< Derived, Horizontal > RowwiseReturnType
Definition: DenseBase.h:435
Eigen::internal::isMuchSmallerThan
bool isMuchSmallerThan(const Scalar &x, const OtherScalar &y, typename NumTraits< Scalar >::Real precision=NumTraits< Scalar >::dummy_precision())
Definition: Eigen/src/Core/MathFunctions.h:709
Eigen::internal::packet_traits::type
T type
Definition: GenericPacketMath.h:73
Eigen::RowMajorBit
const unsigned int RowMajorBit
Definition: eigen3/Eigen/src/Core/util/Constants.h:53
Eigen::DenseBase
Base class for all dense matrices, vectors, and arrays.
Definition: DenseBase.h:41
Eigen::DenseBase::ConstReverseReturnType
const Reverse< const Derived, BothDirections > ConstReverseReturnType
Definition: DenseBase.h:469
Eigen::DenseBase::resize
void resize(Index newSize)
Definition: DenseBase.h:217
Eigen::CommaInitializer
Helper class used by the comma initializer operator.
Definition: CommaInitializer.h:28
Eigen::DenseBase::innerSize
Index innerSize() const
Definition: DenseBase.h:207
Eigen::DenseBase::EvalReturnType
internal::add_const_on_value_type< typename internal::eval< Derived >::type >::type EvalReturnType
Definition: DenseBase.h:356
operator-=
ExportArithmeticStatement operator-=(const ExportVariable &arg1, const ExportVariable &arg2)
Definition: export_variable.cpp:284
Eigen::DenseBase::ReverseReturnType
Reverse< Derived, BothDirections > ReverseReturnType
Definition: DenseBase.h:468
Eigen::DenseBase::outerSize
Index outerSize() const
Definition: DenseBase.h:196
Eigen::internal::special_scalar_op_base
Definition: XprHelper.h:371
Eigen::internal::result_of
Definition: Core/util/Meta.h:113
Eigen::DenseBase::value
CoeffReturnType value() const
Definition: DenseBase.h:424
Eigen::internal::isApprox
bool isApprox(const Scalar &x, const Scalar &y, typename NumTraits< Scalar >::Real precision=NumTraits< Scalar >::dummy_precision())
Definition: Eigen/src/Core/MathFunctions.h:716
Eigen::PlainObjectBase
Dense storage base class for matrices and arrays.
Definition: PlainObjectBase.h:85
Eigen::Replicate
Expression of the multiple replication of a matrix or vector.
Definition: Replicate.h:62
Eigen::DenseBase::resize
void resize(Index nbRows, Index nbCols)
Definition: DenseBase.h:227
operator+=
ExportArithmeticStatement operator+=(const ExportVariable &arg1, const ExportVariable &arg2)
Definition: export_variable.cpp:273
Eigen::NestByValue
Expression which must be nested by value.
Definition: NestByValue.h:35
operator<<
ExportStatementBlock & operator<<(ExportStatementBlock &_block, const ExportStatement &_statement)
Definition: export_statement_block.cpp:294
Eigen::DenseBase::RealScalar
NumTraits< Scalar >::Real RealScalar
Definition: DenseBase.h:65
Eigen::Block
Expression of a fixed-size or dynamic-size block.
Definition: Core/Block.h:102
row
RowXpr row(Index i)
Definition: BlockMethods.h:725
Eigen::internal::add_const_on_value_type
Definition: Core/util/Meta.h:77
Eigen::DenseBase::ConstantReturnType
CwiseNullaryOp< internal::scalar_constant_op< Scalar >, Derived > ConstantReturnType
Definition: DenseBase.h:238
Eigen::DenseBase::EigenvaluesReturnType
Matrix< typename NumTraits< typename internal::traits< Derived >::Scalar >::Real, internal::traits< Derived >::ColsAtCompileTime, 1 > EigenvaluesReturnType
Definition: DenseBase.h:244
Eigen::DenseBase::ColwiseReturnType
VectorwiseOp< Derived, Vertical > ColwiseReturnType
Definition: DenseBase.h:437
Eigen::DenseBase::eval
EIGEN_STRONG_INLINE EvalReturnType eval() const
Definition: DenseBase.h:362
Eigen::internal::add_const
Definition: Core/util/Meta.h:71
Eigen::DenseBase::swap
void swap(const DenseBase< OtherDerived > &other, int=OtherDerived::ThisConstantIsPrivateInPlainObjectBase)
Definition: DenseBase.h:374
Eigen::DenseBase::ConstColwiseReturnType
const VectorwiseOp< const Derived, Vertical > ConstColwiseReturnType
Definition: DenseBase.h:438
EIGEN_IMPLIES
#define EIGEN_IMPLIES(a, b)
Definition: Core/util/Macros.h:397
col
ColXpr col(Index i)
Definition: BlockMethods.h:708
Eigen::Matrix
The matrix class, also used for vectors and row-vectors.
Definition: Matrix.h:127
eigen_assert
#define eigen_assert(x)
Definition: Core/util/Macros.h:207
Eigen::WithFormat
Pseudo expression providing matrix output with given format.
Definition: IO.h:90
Eigen::Reverse
Expression of the reverse of a vector or matrix.
Definition: Reverse.h:70
Eigen::DenseBase::evalTo
void evalTo(Dest &) const
Definition: DenseBase.h:494
Eigen::IOFormat
Stores a set of parameters controlling the way matrices are printed.
Definition: IO.h:50
Eigen::internal::size_at_compile_time
Definition: XprHelper.h:161
Eigen::DenseBase::swap
void swap(PlainObjectBase< OtherDerived > &other)
Definition: DenseBase.h:384
Eigen::Select
Expression of a coefficient wise version of the C++ ternary operator ?:
Definition: Select.h:55

acado
Author(s): Milan Vukov, Rien Quirynen
autogenerated on Mon Jun 10 2019 12:34:32