PlainObjectBase.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) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
5 // Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
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_DENSESTORAGEBASE_H
12 #define EIGEN_DENSESTORAGEBASE_H
13 
14 #if defined(EIGEN_INITIALIZE_MATRICES_BY_ZERO)
15 # define EIGEN_INITIALIZE_COEFFS
16 # define EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED for(int i=0;i<base().size();++i) coeffRef(i)=Scalar(0);
17 #elif defined(EIGEN_INITIALIZE_MATRICES_BY_NAN)
18 # define EIGEN_INITIALIZE_COEFFS
19 # define EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED for(int i=0;i<base().size();++i) coeffRef(i)=std::numeric_limits<Scalar>::quiet_NaN();
20 #else
21 # undef EIGEN_INITIALIZE_COEFFS
22 # define EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
23 #endif
24 
25 namespace Eigen {
26 
27 namespace internal {
28 
29 template<int MaxSizeAtCompileTime> struct check_rows_cols_for_overflow {
30  template<typename Index>
31  EIGEN_DEVICE_FUNC
33  {
34  }
35 };
36 
38  template<typename Index>
39  EIGEN_DEVICE_FUNC
41  {
42  // http://hg.mozilla.org/mozilla-central/file/6c8a909977d3/xpcom/ds/CheckedInt.h#l242
43  // we assume Index is signed
44  Index max_index = (std::size_t(1) << (8 * sizeof(Index) - 1)) - 1; // assume Index is signed
45  bool error = (rows == 0 || cols == 0) ? false
46  : (rows > max_index / cols);
47  if (error)
49  }
50 };
51 
52 template <typename Derived,
53  typename OtherDerived = Derived,
54  bool IsVector = bool(Derived::IsVectorAtCompileTime) && bool(OtherDerived::IsVectorAtCompileTime)>
56 
57 template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers> struct matrix_swap_impl;
58 
59 } // end namespace internal
60 
61 #ifdef EIGEN_PARSED_BY_DOXYGEN
62 namespace doxygen {
63 
64 // This is a workaround to doxygen not being able to understand the inheritance logic
65 // when it is hidden by the dense_xpr_base helper struct.
66 // Moreover, doxygen fails to include members that are not documented in the declaration body of
67 // MatrixBase if we inherits MatrixBase<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >,
68 // this is why we simply inherits MatrixBase, though this does not make sense.
69 
71 template<typename Derived> struct dense_xpr_base_dispatcher;
73 template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
74 struct dense_xpr_base_dispatcher<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
75  : public MatrixBase {};
77 template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
78 struct dense_xpr_base_dispatcher<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
79  : public ArrayBase {};
80 
81 } // namespace doxygen
82 
94 template<typename Derived>
95 class PlainObjectBase : public doxygen::dense_xpr_base_dispatcher<Derived>
96 #else
97 template<typename Derived>
99 #endif
100 {
101  public:
104 
107 
110  typedef Derived DenseType;
111 
112  using Base::RowsAtCompileTime;
113  using Base::ColsAtCompileTime;
114  using Base::SizeAtCompileTime;
115  using Base::MaxRowsAtCompileTime;
116  using Base::MaxColsAtCompileTime;
117  using Base::MaxSizeAtCompileTime;
118  using Base::IsVectorAtCompileTime;
119  using Base::Flags;
120 
121  template<typename PlainObjectType, int MapOptions, typename StrideType> friend class Eigen::Map;
122  friend class Eigen::Map<Derived, Unaligned>;
124  friend class Eigen::Map<const Derived, Unaligned>;
126 #if EIGEN_MAX_ALIGN_BYTES>0
127  // for EIGEN_MAX_ALIGN_BYTES==0, AlignedMax==Unaligned, and many compilers generate warnings for friend-ing a class twice.
128  friend class Eigen::Map<Derived, AlignedMax>;
129  friend class Eigen::Map<const Derived, AlignedMax>;
130 #endif
133  template<typename StrideType> struct StridedMapType { typedef Eigen::Map<Derived, Unaligned, StrideType> type; };
134  template<typename StrideType> struct StridedConstMapType { typedef Eigen::Map<const Derived, Unaligned, StrideType> type; };
135  template<typename StrideType> struct StridedAlignedMapType { typedef Eigen::Map<Derived, AlignedMax, StrideType> type; };
136  template<typename StrideType> struct StridedConstAlignedMapType { typedef Eigen::Map<const Derived, AlignedMax, StrideType> type; };
137 
138  protected:
140 
141  public:
142  enum { NeedsToAlign = (SizeAtCompileTime != Dynamic) && (internal::traits<Derived>::Alignment>0) };
144 
145  EIGEN_DEVICE_FUNC
146  Base& base() { return *static_cast<Base*>(this); }
147  EIGEN_DEVICE_FUNC
148  const Base& base() const { return *static_cast<const Base*>(this); }
149 
150  EIGEN_DEVICE_FUNC
151  EIGEN_STRONG_INLINE Index rows() const { return m_storage.rows(); }
152  EIGEN_DEVICE_FUNC
153  EIGEN_STRONG_INLINE Index cols() const { return m_storage.cols(); }
154 
159  EIGEN_DEVICE_FUNC
160  EIGEN_STRONG_INLINE const Scalar& coeff(Index rowId, Index colId) const
161  {
162  if(Flags & RowMajorBit)
163  return m_storage.data()[colId + rowId * m_storage.cols()];
164  else // column-major
165  return m_storage.data()[rowId + colId * m_storage.rows()];
166  }
167 
172  EIGEN_DEVICE_FUNC
173  EIGEN_STRONG_INLINE const Scalar& coeff(Index index) const
174  {
175  return m_storage.data()[index];
176  }
177 
182  EIGEN_DEVICE_FUNC
183  EIGEN_STRONG_INLINE Scalar& coeffRef(Index rowId, Index colId)
184  {
185  if(Flags & RowMajorBit)
186  return m_storage.data()[colId + rowId * m_storage.cols()];
187  else // column-major
188  return m_storage.data()[rowId + colId * m_storage.rows()];
189  }
190 
195  EIGEN_DEVICE_FUNC
197  {
198  return m_storage.data()[index];
199  }
200 
203  EIGEN_DEVICE_FUNC
204  EIGEN_STRONG_INLINE const Scalar& coeffRef(Index rowId, Index colId) const
205  {
206  if(Flags & RowMajorBit)
207  return m_storage.data()[colId + rowId * m_storage.cols()];
208  else // column-major
209  return m_storage.data()[rowId + colId * m_storage.rows()];
210  }
211 
214  EIGEN_DEVICE_FUNC
215  EIGEN_STRONG_INLINE const Scalar& coeffRef(Index index) const
216  {
217  return m_storage.data()[index];
218  }
219 
221  template<int LoadMode>
222  EIGEN_STRONG_INLINE PacketScalar packet(Index rowId, Index colId) const
223  {
224  return internal::ploadt<PacketScalar, LoadMode>
225  (m_storage.data() + (Flags & RowMajorBit
226  ? colId + rowId * m_storage.cols()
227  : rowId + colId * m_storage.rows()));
228  }
229 
231  template<int LoadMode>
232  EIGEN_STRONG_INLINE PacketScalar packet(Index index) const
233  {
234  return internal::ploadt<PacketScalar, LoadMode>(m_storage.data() + index);
235  }
236 
238  template<int StoreMode>
239  EIGEN_STRONG_INLINE void writePacket(Index rowId, Index colId, const PacketScalar& val)
240  {
241  internal::pstoret<Scalar, PacketScalar, StoreMode>
242  (m_storage.data() + (Flags & RowMajorBit
243  ? colId + rowId * m_storage.cols()
244  : rowId + colId * m_storage.rows()), val);
245  }
246 
248  template<int StoreMode>
249  EIGEN_STRONG_INLINE void writePacket(Index index, const PacketScalar& val)
250  {
251  internal::pstoret<Scalar, PacketScalar, StoreMode>(m_storage.data() + index, val);
252  }
253 
255  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar *data() const
256  { return m_storage.data(); }
257 
259  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar *data()
260  { return m_storage.data(); }
261 
278  EIGEN_DEVICE_FUNC
280  {
281  eigen_assert( EIGEN_IMPLIES(RowsAtCompileTime!=Dynamic,rows==RowsAtCompileTime)
282  && EIGEN_IMPLIES(ColsAtCompileTime!=Dynamic,cols==ColsAtCompileTime)
283  && EIGEN_IMPLIES(RowsAtCompileTime==Dynamic && MaxRowsAtCompileTime!=Dynamic,rows<=MaxRowsAtCompileTime)
284  && EIGEN_IMPLIES(ColsAtCompileTime==Dynamic && MaxColsAtCompileTime!=Dynamic,cols<=MaxColsAtCompileTime)
285  && rows>=0 && cols>=0 && "Invalid sizes when resizing a matrix or array.");
287  #ifdef EIGEN_INITIALIZE_COEFFS
288  Index size = rows*cols;
289  bool size_changed = size != this->size();
290  m_storage.resize(size, rows, cols);
292  #else
293  m_storage.resize(rows*cols, rows, cols);
294  #endif
295  }
296 
308  EIGEN_DEVICE_FUNC
309  inline void resize(Index size)
310  {
312  eigen_assert(((SizeAtCompileTime == Dynamic && (MaxSizeAtCompileTime==Dynamic || size<=MaxSizeAtCompileTime)) || SizeAtCompileTime == size) && size>=0);
313  #ifdef EIGEN_INITIALIZE_COEFFS
314  bool size_changed = size != this->size();
315  #endif
316  if(RowsAtCompileTime == 1)
317  m_storage.resize(size, 1, size);
318  else
319  m_storage.resize(size, size, 1);
320  #ifdef EIGEN_INITIALIZE_COEFFS
322  #endif
323  }
324 
333  EIGEN_DEVICE_FUNC
334  inline void resize(NoChange_t, Index cols)
335  {
336  resize(rows(), cols);
337  }
338 
347  EIGEN_DEVICE_FUNC
348  inline void resize(Index rows, NoChange_t)
349  {
350  resize(rows, cols());
351  }
352 
360  template<typename OtherDerived>
361  EIGEN_DEVICE_FUNC
363  {
364  const OtherDerived& other = _other.derived();
366  const Index othersize = other.rows()*other.cols();
367  if(RowsAtCompileTime == 1)
368  {
369  eigen_assert(other.rows() == 1 || other.cols() == 1);
370  resize(1, othersize);
371  }
372  else if(ColsAtCompileTime == 1)
373  {
374  eigen_assert(other.rows() == 1 || other.cols() == 1);
375  resize(othersize, 1);
376  }
377  else resize(other.rows(), other.cols());
378  }
379 
389  EIGEN_DEVICE_FUNC
391  {
393  }
394 
402  EIGEN_DEVICE_FUNC
404  {
405  // Note: see the comment in conservativeResize(Index,Index)
406  conservativeResize(rows, cols());
407  }
408 
416  EIGEN_DEVICE_FUNC
418  {
419  // Note: see the comment in conservativeResize(Index,Index)
420  conservativeResize(rows(), cols);
421  }
422 
431  EIGEN_DEVICE_FUNC
433  {
435  }
436 
446  template<typename OtherDerived>
447  EIGEN_DEVICE_FUNC
449  {
451  }
452 
456  EIGEN_DEVICE_FUNC
458  {
459  return _set(other);
460  }
461 
463  template<typename OtherDerived>
464  EIGEN_DEVICE_FUNC
466  {
467  _resize_to_match(other);
468  return Base::lazyAssign(other.derived());
469  }
470 
471  template<typename OtherDerived>
472  EIGEN_DEVICE_FUNC
474  {
475  resize(func.rows(), func.cols());
476  return Base::operator=(func);
477  }
478 
479  // Prevent user from trying to instantiate PlainObjectBase objects
480  // by making all its constructor protected. See bug 1074.
481  protected:
482 
483  EIGEN_DEVICE_FUNC
485  {
486 // _check_template_params();
487 // EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
488  }
489 
490 #ifndef EIGEN_PARSED_BY_DOXYGEN
491  // FIXME is it still needed ?
493  EIGEN_DEVICE_FUNC
495  : m_storage(internal::constructor_without_unaligned_array_assert())
496  {
497 // _check_template_params(); EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
498  }
499 #endif
500 
501 #if EIGEN_HAS_RVALUE_REFERENCES
502  EIGEN_DEVICE_FUNC
504  : m_storage( std::move(other.m_storage) )
505  {
506  }
507 
508  EIGEN_DEVICE_FUNC
510  {
511  using std::swap;
512  swap(m_storage, other.m_storage);
513  return *this;
514  }
515 #endif
516 
518  EIGEN_DEVICE_FUNC
520  : Base(), m_storage(other.m_storage) { }
521  EIGEN_DEVICE_FUNC
523  : m_storage(size, rows, cols)
524  {
525 // _check_template_params();
526 // EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
527  }
528 
530  template<typename OtherDerived>
531  EIGEN_DEVICE_FUNC
533  : m_storage()
534  {
535  _check_template_params();
536  resizeLike(other);
537  _set_noalias(other);
538  }
539 
541  template<typename OtherDerived>
542  EIGEN_DEVICE_FUNC
544  : m_storage()
545  {
546  _check_template_params();
547  resizeLike(other);
548  *this = other.derived();
549  }
551  template<typename OtherDerived>
552  EIGEN_DEVICE_FUNC
554  {
555  _check_template_params();
556  // FIXME this does not automatically transpose vectors if necessary
557  resize(other.rows(), other.cols());
558  other.evalTo(this->derived());
559  }
560 
561  public:
562 
566  template<typename OtherDerived>
567  EIGEN_DEVICE_FUNC
569  {
570  _resize_to_match(other);
571  Base::operator=(other.derived());
572  return this->derived();
573  }
574 
587  static inline ConstMapType Map(const Scalar* data)
588  { return ConstMapType(data); }
589  static inline MapType Map(Scalar* data)
590  { return MapType(data); }
591  static inline ConstMapType Map(const Scalar* data, Index size)
592  { return ConstMapType(data, size); }
593  static inline MapType Map(Scalar* data, Index size)
594  { return MapType(data, size); }
595  static inline ConstMapType Map(const Scalar* data, Index rows, Index cols)
596  { return ConstMapType(data, rows, cols); }
597  static inline MapType Map(Scalar* data, Index rows, Index cols)
598  { return MapType(data, rows, cols); }
599 
600  static inline ConstAlignedMapType MapAligned(const Scalar* data)
601  { return ConstAlignedMapType(data); }
602  static inline AlignedMapType MapAligned(Scalar* data)
603  { return AlignedMapType(data); }
604  static inline ConstAlignedMapType MapAligned(const Scalar* data, Index size)
605  { return ConstAlignedMapType(data, size); }
606  static inline AlignedMapType MapAligned(Scalar* data, Index size)
607  { return AlignedMapType(data, size); }
608  static inline ConstAlignedMapType MapAligned(const Scalar* data, Index rows, Index cols)
609  { return ConstAlignedMapType(data, rows, cols); }
610  static inline AlignedMapType MapAligned(Scalar* data, Index rows, Index cols)
611  { return AlignedMapType(data, rows, cols); }
612 
613  template<int Outer, int Inner>
614  static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, const Stride<Outer, Inner>& stride)
615  { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, stride); }
616  template<int Outer, int Inner>
617  static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, const Stride<Outer, Inner>& stride)
618  { return typename StridedMapType<Stride<Outer, Inner> >::type(data, stride); }
619  template<int Outer, int Inner>
620  static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, Index size, const Stride<Outer, Inner>& stride)
621  { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, size, stride); }
622  template<int Outer, int Inner>
623  static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, Index size, const Stride<Outer, Inner>& stride)
624  { return typename StridedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
625  template<int Outer, int Inner>
626  static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
627  { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
628  template<int Outer, int Inner>
629  static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
630  { return typename StridedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
631 
632  template<int Outer, int Inner>
633  static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, const Stride<Outer, Inner>& stride)
634  { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, stride); }
635  template<int Outer, int Inner>
636  static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, const Stride<Outer, Inner>& stride)
637  { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, stride); }
638  template<int Outer, int Inner>
639  static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, Index size, const Stride<Outer, Inner>& stride)
640  { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
641  template<int Outer, int Inner>
642  static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, Index size, const Stride<Outer, Inner>& stride)
643  { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
644  template<int Outer, int Inner>
645  static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
646  { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
647  template<int Outer, int Inner>
648  static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
649  { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
651 
652  using Base::setConstant;
653  EIGEN_DEVICE_FUNC Derived& setConstant(Index size, const Scalar& val);
654  EIGEN_DEVICE_FUNC Derived& setConstant(Index rows, Index cols, const Scalar& val);
655 
656  using Base::setZero;
657  EIGEN_DEVICE_FUNC Derived& setZero(Index size);
658  EIGEN_DEVICE_FUNC Derived& setZero(Index rows, Index cols);
659 
660  using Base::setOnes;
661  EIGEN_DEVICE_FUNC Derived& setOnes(Index size);
662  EIGEN_DEVICE_FUNC Derived& setOnes(Index rows, Index cols);
663 
664  using Base::setRandom;
665  Derived& setRandom(Index size);
666  Derived& setRandom(Index rows, Index cols);
667 
668  #ifdef EIGEN_PLAINOBJECTBASE_PLUGIN
669  #include EIGEN_PLAINOBJECTBASE_PLUGIN
670  #endif
671 
672  protected:
680  template<typename OtherDerived>
681  EIGEN_DEVICE_FUNC
683  {
684  #ifdef EIGEN_NO_AUTOMATIC_RESIZING
685  eigen_assert((this->size()==0 || (IsVectorAtCompileTime ? (this->size() == other.size())
686  : (rows() == other.rows() && cols() == other.cols())))
687  && "Size mismatch. Automatic resizing is disabled because EIGEN_NO_AUTOMATIC_RESIZING is defined");
689  #else
690  resizeLike(other);
691  #endif
692  }
693 
708  // aliasing is dealt once in internall::call_assignment
709  // so at this stage we have to assume aliasing... and resising has to be done later.
710  template<typename OtherDerived>
711  EIGEN_DEVICE_FUNC
713  {
714  internal::call_assignment(this->derived(), other.derived());
715  return this->derived();
716  }
717 
723  template<typename OtherDerived>
724  EIGEN_DEVICE_FUNC
726  {
727  // I don't think we need this resize call since the lazyAssign will anyways resize
728  // and lazyAssign will be called by the assign selector.
729  //_resize_to_match(other);
730  // the 'false' below means to enforce lazy evaluation. We don't use lazyAssign() because
731  // it wouldn't allow to copy a row-vector into a column-vector.
733  return this->derived();
734  }
735 
736  template<typename T0, typename T1>
737  EIGEN_DEVICE_FUNC
739  {
742  FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
743  resize(rows,cols);
744  }
745 
746  template<typename T0, typename T1>
747  EIGEN_DEVICE_FUNC
749  {
751  m_storage.data()[0] = Scalar(val0);
752  m_storage.data()[1] = Scalar(val1);
753  }
754 
755  template<typename T0, typename T1>
756  EIGEN_DEVICE_FUNC
757  EIGEN_STRONG_INLINE void _init2(const Index& val0, const Index& val1,
761  && Base::SizeAtCompileTime==2,T1>::type* = 0)
762  {
764  m_storage.data()[0] = Scalar(val0);
765  m_storage.data()[1] = Scalar(val1);
766  }
767 
768  // The argument is convertible to the Index type and we either have a non 1x1 Matrix, or a dynamic-sized Array,
769  // then the argument is meant to be the size of the object.
770  template<typename T>
771  EIGEN_DEVICE_FUNC
773  && ((!internal::is_same<typename internal::traits<Derived>::XprKind,ArrayXpr>::value || Base::SizeAtCompileTime==Dynamic)),T>::type* = 0)
774  {
775  // NOTE MSVC 2008 complains if we directly put bool(NumTraits<T>::IsInteger) as the EIGEN_STATIC_ASSERT argument.
776  const bool is_integer = NumTraits<T>::IsInteger;
777  EIGEN_UNUSED_VARIABLE(is_integer);
778  EIGEN_STATIC_ASSERT(is_integer,
779  FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
780  resize(size);
781  }
782 
783  // We have a 1x1 matrix/array => the argument is interpreted as the value of the unique coefficient (case where scalar type can be implicitely converted)
784  template<typename T>
785  EIGEN_DEVICE_FUNC
786  EIGEN_STRONG_INLINE void _init1(const Scalar& val0, typename internal::enable_if<Base::SizeAtCompileTime==1 && internal::is_convertible<T, Scalar>::value,T>::type* = 0)
787  {
789  m_storage.data()[0] = val0;
790  }
791 
792  // We have a 1x1 matrix/array => the argument is interpreted as the value of the unique coefficient (case where scalar type match the index type)
793  template<typename T>
794  EIGEN_DEVICE_FUNC
795  EIGEN_STRONG_INLINE void _init1(const Index& val0,
798  && Base::SizeAtCompileTime==1
800  {
802  m_storage.data()[0] = Scalar(val0);
803  }
804 
805  // Initialize a fixed size matrix from a pointer to raw data
806  template<typename T>
807  EIGEN_DEVICE_FUNC
808  EIGEN_STRONG_INLINE void _init1(const Scalar* data){
809  this->_set_noalias(ConstMapType(data));
810  }
811 
812  // Initialize an arbitrary matrix from a dense expression
813  template<typename T, typename OtherDerived>
814  EIGEN_DEVICE_FUNC
816  this->_set_noalias(other);
817  }
818 
819  // Initialize an arbitrary matrix from an object convertible to the Derived type.
820  template<typename T>
821  EIGEN_DEVICE_FUNC
822  EIGEN_STRONG_INLINE void _init1(const Derived& other){
823  this->_set_noalias(other);
824  }
825 
826  // Initialize an arbitrary matrix from a generic Eigen expression
827  template<typename T, typename OtherDerived>
828  EIGEN_DEVICE_FUNC
830  this->derived() = other;
831  }
832 
833  template<typename T, typename OtherDerived>
834  EIGEN_DEVICE_FUNC
836  {
837  resize(other.rows(), other.cols());
838  other.evalTo(this->derived());
839  }
840 
841  template<typename T, typename OtherDerived, int ColsAtCompileTime>
842  EIGEN_DEVICE_FUNC
844  {
845  this->derived() = r;
846  }
847 
848  // For fixed-size Array<Scalar,...>
849  template<typename T>
850  EIGEN_DEVICE_FUNC
851  EIGEN_STRONG_INLINE void _init1(const Scalar& val0,
852  typename internal::enable_if< Base::SizeAtCompileTime!=Dynamic
853  && Base::SizeAtCompileTime!=1
856  {
857  Base::setConstant(val0);
858  }
859 
860  // For fixed-size Array<Index,...>
861  template<typename T>
862  EIGEN_DEVICE_FUNC
863  EIGEN_STRONG_INLINE void _init1(const Index& val0,
866  && Base::SizeAtCompileTime!=Dynamic
867  && Base::SizeAtCompileTime!=1
870  {
871  Base::setConstant(val0);
872  }
873 
874  template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers>
876 
877  public:
878 
879 #ifndef EIGEN_PARSED_BY_DOXYGEN
880 
884  template<typename OtherDerived>
885  EIGEN_DEVICE_FUNC
887  {
888  enum { SwapPointers = internal::is_same<Derived, OtherDerived>::value && Base::SizeAtCompileTime==Dynamic };
890  }
891 
895  template<typename OtherDerived>
896  EIGEN_DEVICE_FUNC
897  void swap(DenseBase<OtherDerived> const & other)
898  { Base::swap(other.derived()); }
899 
900  EIGEN_DEVICE_FUNC
902  {
903  EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, (Options&RowMajor)==RowMajor)
904  && EIGEN_IMPLIES(MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1, (Options&RowMajor)==0)
905  && ((RowsAtCompileTime == Dynamic) || (RowsAtCompileTime >= 0))
906  && ((ColsAtCompileTime == Dynamic) || (ColsAtCompileTime >= 0))
907  && ((MaxRowsAtCompileTime == Dynamic) || (MaxRowsAtCompileTime >= 0))
908  && ((MaxColsAtCompileTime == Dynamic) || (MaxColsAtCompileTime >= 0))
909  && (MaxRowsAtCompileTime == RowsAtCompileTime || RowsAtCompileTime==Dynamic)
910  && (MaxColsAtCompileTime == ColsAtCompileTime || ColsAtCompileTime==Dynamic)
911  && (Options & (DontAlign|RowMajor)) == Options),
912  INVALID_MATRIX_TEMPLATE_PARAMETERS)
913  }
914 
915  enum { IsPlainObjectBase = 1 };
916 #endif
917 };
918 
919 namespace internal {
920 
921 template <typename Derived, typename OtherDerived, bool IsVector>
922 struct conservative_resize_like_impl
923 {
924  static void run(DenseBase<Derived>& _this, Index rows, Index cols)
925  {
926  if (_this.rows() == rows && _this.cols() == cols) return;
928 
929  if ( ( Derived::IsRowMajor && _this.cols() == cols) || // row-major and we change only the number of rows
930  (!Derived::IsRowMajor && _this.rows() == rows) ) // column-major and we change only the number of columns
931  {
933  _this.derived().m_storage.conservativeResize(rows*cols,rows,cols);
934  }
935  else
936  {
937  // The storage order does not allow us to use reallocation.
938  typename Derived::PlainObject tmp(rows,cols);
939  const Index common_rows = numext::mini(rows, _this.rows());
940  const Index common_cols = numext::mini(cols, _this.cols());
941  tmp.block(0,0,common_rows,common_cols) = _this.block(0,0,common_rows,common_cols);
942  _this.derived().swap(tmp);
943  }
944  }
945 
946  static void run(DenseBase<Derived>& _this, const DenseBase<OtherDerived>& other)
947  {
948  if (_this.rows() == other.rows() && _this.cols() == other.cols()) return;
949 
950  // Note: Here is space for improvement. Basically, for conservativeResize(Index,Index),
951  // neither RowsAtCompileTime or ColsAtCompileTime must be Dynamic. If only one of the
952  // dimensions is dynamic, one could use either conservativeResize(Index rows, NoChange_t) or
953  // conservativeResize(NoChange_t, Index cols). For these methods new static asserts like
954  // EIGEN_STATIC_ASSERT_DYNAMIC_ROWS and EIGEN_STATIC_ASSERT_DYNAMIC_COLS would be good.
957 
958  if ( ( Derived::IsRowMajor && _this.cols() == other.cols()) || // row-major and we change only the number of rows
959  (!Derived::IsRowMajor && _this.rows() == other.rows()) ) // column-major and we change only the number of columns
960  {
961  const Index new_rows = other.rows() - _this.rows();
962  const Index new_cols = other.cols() - _this.cols();
963  _this.derived().m_storage.conservativeResize(other.size(),other.rows(),other.cols());
964  if (new_rows>0)
965  _this.bottomRightCorner(new_rows, other.cols()) = other.bottomRows(new_rows);
966  else if (new_cols>0)
967  _this.bottomRightCorner(other.rows(), new_cols) = other.rightCols(new_cols);
968  }
969  else
970  {
971  // The storage order does not allow us to use reallocation.
972  typename Derived::PlainObject tmp(other);
973  const Index common_rows = numext::mini(tmp.rows(), _this.rows());
974  const Index common_cols = numext::mini(tmp.cols(), _this.cols());
975  tmp.block(0,0,common_rows,common_cols) = _this.block(0,0,common_rows,common_cols);
976  _this.derived().swap(tmp);
977  }
978  }
979 };
980 
981 // Here, the specialization for vectors inherits from the general matrix case
982 // to allow calling .conservativeResize(rows,cols) on vectors.
983 template <typename Derived, typename OtherDerived>
984 struct conservative_resize_like_impl<Derived,OtherDerived,true>
985  : conservative_resize_like_impl<Derived,OtherDerived,false>
986 {
988 
989  static void run(DenseBase<Derived>& _this, Index size)
990  {
991  const Index new_rows = Derived::RowsAtCompileTime==1 ? 1 : size;
992  const Index new_cols = Derived::RowsAtCompileTime==1 ? size : 1;
993  _this.derived().m_storage.conservativeResize(size,new_rows,new_cols);
994  }
995 
996  static void run(DenseBase<Derived>& _this, const DenseBase<OtherDerived>& other)
997  {
998  if (_this.rows() == other.rows() && _this.cols() == other.cols()) return;
999 
1000  const Index num_new_elements = other.size() - _this.size();
1001 
1002  const Index new_rows = Derived::RowsAtCompileTime==1 ? 1 : other.rows();
1003  const Index new_cols = Derived::RowsAtCompileTime==1 ? other.cols() : 1;
1004  _this.derived().m_storage.conservativeResize(other.size(),new_rows,new_cols);
1005 
1006  if (num_new_elements > 0)
1007  _this.tail(num_new_elements) = other.tail(num_new_elements);
1008  }
1009 };
1010 
1011 template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers>
1012 struct matrix_swap_impl
1013 {
1014  EIGEN_DEVICE_FUNC
1015  static inline void run(MatrixTypeA& a, MatrixTypeB& b)
1016  {
1017  a.base().swap(b);
1018  }
1019 };
1020 
1021 template<typename MatrixTypeA, typename MatrixTypeB>
1022 struct matrix_swap_impl<MatrixTypeA, MatrixTypeB, true>
1023 {
1024  EIGEN_DEVICE_FUNC
1025  static inline void run(MatrixTypeA& a, MatrixTypeB& b)
1026  {
1027  static_cast<typename MatrixTypeA::Base&>(a).m_storage.swap(static_cast<typename MatrixTypeB::Base&>(b).m_storage);
1028  }
1029 };
1030 
1031 } // end namespace internal
1032 
1033 } // end namespace Eigen
1034 
1035 #endif // EIGEN_DENSESTORAGEBASE_H
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index cols() const
Eigen::Map< const Derived, Unaligned, StrideType > type
static MapType Map(Scalar *data)
#define EIGEN_ALWAYS_INLINE
Definition: Macros.h:509
SCALAR Scalar
Definition: bench_gemm.cpp:33
internal::traits< Derived >::Scalar Scalar
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_assignment_no_alias(Dst &dst, const Src &src, const Func &func)
EIGEN_DEVICE_FUNC Base & base()
#define EIGEN_STRONG_INLINE
Definition: Macros.h:494
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PlainObjectBase(const PlainObjectBase &other)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _init2(const Index &val0, const Index &val1, typename internal::enable_if< (!internal::is_same< Index, Scalar >::value)&&(internal::is_same< T0, Index >::value)&&(internal::is_same< T1, Index >::value)&&Base::SizeAtCompileTime==2, T1 >::type *=0)
const Eigen::Map< const Derived, AlignedMax > ConstAlignedMapType
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _init1(const ReturnByValue< OtherDerived > &other)
EIGEN_DEVICE_FUNC void swap(DenseBase< OtherDerived > &other)
static StridedConstAlignedMapType< Stride< Outer, Inner > >::type MapAligned(const Scalar *data, const Stride< Outer, Inner > &stride)
Scalar * b
Definition: benchVecAdd.cpp:17
static StridedAlignedMapType< Stride< Outer, Inner > >::type MapAligned(Scalar *data, Index size, const Stride< Outer, Inner > &stride)
Eigen::Map< Derived, Unaligned, StrideType > type
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void conservativeResize(NoChange_t, Index cols)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _init1(const Scalar &val0, typename internal::enable_if< Base::SizeAtCompileTime==1 &&internal::is_convertible< T, Scalar >::value, T >::type *=0)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived & _set_noalias(const DenseBase< OtherDerived > &other)
EIGEN_DEVICE_FUNC Index rows() const
Definition: ReturnByValue.h:63
EIGEN_DEVICE_FUNC RowsBlockXpr bottomRows(Index n)
Definition: DenseBase.h:489
A matrix or vector expression mapping an existing array of data.
Definition: Map.h:94
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _check_template_params()
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rows() const
EIGEN_STRONG_INLINE PacketScalar packet(Index index) const
EIGEN_DEVICE_FUNC void swap(DenseBase< OtherDerived > const &other)
static void run(DenseBase< Derived > &_this, Index rows, Index cols)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _init1(const DenseBase< OtherDerived > &other)
static EIGEN_DEVICE_FUNC void run(MatrixTypeA &a, MatrixTypeB &b)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar * data() const
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived & lazyAssign(const DenseBase< OtherDerived > &other)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _resize_to_match(const EigenBase< OtherDerived > &other)
EIGEN_DEVICE_FUNC void resize(Index, Index, Index)
Definition: DenseStorage.h:214
static ConstMapType Map(const Scalar *data, Index size)
EIGEN_DEVICE_FUNC void swap(const DenseBase< OtherDerived > &other)
Definition: DenseBase.h:414
Namespace containing all symbols from the Eigen library.
Definition: jet.h:637
Holds strides information for Map.
Definition: Stride.h:44
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived & operator=(const EigenBase< OtherDerived > &other)
Copies the generic expression other into *this.
EIGEN_DEVICE_FUNC void evalTo(Dest &dst) const
Definition: ReturnByValue.h:61
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void conservativeResize(Index size)
Holds information about the various numeric (i.e. scalar) types allowed by Eigen. ...
Definition: NumTraits.h:150
#define EIGEN_STATIC_ASSERT(CONDITION, MSG)
Definition: StaticAssert.h:124
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void conservativeResize(Index rows, NoChange_t)
static EIGEN_DEVICE_FUNC Index rows(void)
Definition: DenseStorage.h:211
static AlignedMapType MapAligned(Scalar *data)
const unsigned int RowMajorBit
Definition: Constants.h:61
Base class for all dense matrices, vectors, and arrays.
Definition: DenseBase.h:41
static ConstAlignedMapType MapAligned(const Scalar *data, Index size)
#define EIGEN_IMPLIES(a, b)
Definition: Macros.h:902
Eigen::Map< Derived, AlignedMax, StrideType > type
static MapType Map(Scalar *data, Index rows, Index cols)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _init1(const Index &val0, typename internal::enable_if< (!internal::is_same< Index, Scalar >::value)&&(internal::is_same< Index, T >::value)&&Base::SizeAtCompileTime!=Dynamic &&Base::SizeAtCompileTime!=1 &&internal::is_convertible< T, Scalar >::value &&internal::is_same< typename internal::traits< Derived >::XprKind, ArrayXpr >::value, T * >::type *=0)
EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL EIGEN_DEVICE_FUNC BlockXpr bottomRightCorner(Index cRows, Index cCols)
Definition: DenseBase.h:264
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resizeLike(const EigenBase< OtherDerived > &_other)
static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void run(Index rows, Index cols)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _init1(const RotationBase< OtherDerived, ColsAtCompileTime > &r)
EIGEN_DEVICE_FUNC const Base & base() const
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar & coeffRef(Index rowId, Index colId)
Array33i a
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived & operator=(const PlainObjectBase &other)
internal::dense_xpr_base< Derived >::type Base
#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign)
Definition: Memory.h:687
Scalar Scalar int size
Definition: benchVecAdd.cpp:17
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar & coeffRef(Index index)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _init1(const Index &val0, typename internal::enable_if< (!internal::is_same< Index, Scalar >::value)&&(internal::is_same< Index, T >::value)&&Base::SizeAtCompileTime==1 &&internal::is_convertible< T, Scalar >::value, T * >::type *=0)
EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL EIGEN_DEVICE_FUNC BlockXpr block(Index startRow, Index startCol, Index blockRows, Index blockCols)
Definition: DenseBase.h:65
EIGEN_STRONG_INLINE void writePacket(Index index, const PacketScalar &val)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void conservativeResize(Index rows, Index cols)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _init2(const T0 &val0, const T1 &val1, typename internal::enable_if< Base::SizeAtCompileTime==2, T0 >::type *=0)
static ConstMapType Map(const Scalar *data, Index rows, Index cols)
int EIGEN_BLAS_FUNC() swap(int *n, RealScalar *px, int *incx, RealScalar *py, int *incy)
Definition: level1_impl.h:152
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resize(Index rows, Index cols)
A setRandom()
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _init1(const Derived &other)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived & _set(const DenseBase< OtherDerived > &other)
Copies the value of the expression other into *this with automatic resizing.
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar & coeffRef(Index rowId, Index colId) const
#define EIGEN_NOEXCEPT
Definition: Macros.h:989
static StridedConstMapType< Stride< Outer, Inner > >::type Map(const Scalar *data, const Stride< Outer, Inner > &stride)
static AlignedMapType MapAligned(Scalar *data, Index size)
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:33
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar & coeff(Index index) const
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _init1(const Scalar *data)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _init1(const EigenBase< OtherDerived > &other)
static StridedConstMapType< Stride< Outer, Inner > >::type Map(const Scalar *data, Index rows, Index cols, const Stride< Outer, Inner > &stride)
#define eigen_assert(x)
Definition: Macros.h:579
static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void run(Index, Index)
v setOnes(3)
int data[]
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _init1(Index size, typename internal::enable_if< (Base::SizeAtCompileTime!=1||!internal::is_convertible< T, Scalar >::value)&&((!internal::is_same< typename internal::traits< Derived >::XprKind, ArrayXpr >::value||Base::SizeAtCompileTime==Dynamic)), T >::type *=0)
Eigen::Map< Derived, AlignedMax > AlignedMapType
Common base class for compact rotation representations.
static AlignedMapType MapAligned(Scalar *data, Index rows, Index cols)
EIGEN_DEVICE_FUNC void resize(Index size)
static StridedAlignedMapType< Stride< Outer, Inner > >::type MapAligned(Scalar *data, Index rows, Index cols, const Stride< Outer, Inner > &stride)
Base class for all 1D and 2D array, and related expressions.
Definition: ArrayBase.h:39
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PlainObjectBase(const EigenBase< OtherDerived > &other)
internal::traits< Derived >::StorageKind StorageKind
static void run(DenseBase< Derived > &_this, const DenseBase< OtherDerived > &other)
EIGEN_DEVICE_FUNC Index cols() const
Definition: EigenBase.h:62
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T mini(const T &x, const T &y)
static StridedAlignedMapType< Stride< Outer, Inner > >::type MapAligned(Scalar *data, const Stride< Outer, Inner > &stride)
DenseStorage< Scalar, Base::MaxSizeAtCompileTime, Base::RowsAtCompileTime, Base::ColsAtCompileTime, Options > m_storage
EIGEN_DEVICE_FUNC void resize(NoChange_t, Index cols)
NoChange_t
Definition: Constants.h:350
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void conservativeResizeLike(const DenseBase< OtherDerived > &other)
static ConstAlignedMapType MapAligned(const Scalar *data, Index rows, Index cols)
static StridedMapType< Stride< Outer, Inner > >::type Map(Scalar *data, const Stride< Outer, Inner > &stride)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar & coeffRef(Index index) const
EIGEN_DEVICE_FUNC void resize(Index rows, NoChange_t)
EIGEN_DEVICE_FUNC void swap(DenseStorage &other)
Definition: DenseStorage.h:210
v setConstant(3, 5)
EIGEN_DEVICE_FUNC SegmentReturnType tail(Index n)
Definition: DenseBase.h:950
static StridedMapType< Stride< Outer, Inner > >::type Map(Scalar *data, Index size, const Stride< Outer, Inner > &stride)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PlainObjectBase()
static StridedMapType< Stride< Outer, Inner > >::type Map(Scalar *data, Index rows, Index cols, const Stride< Outer, Inner > &stride)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar * data()
Map< MatrixType > MapType
static StridedConstMapType< Stride< Outer, Inner > >::type Map(const Scalar *data, Index size, const Stride< Outer, Inner > &stride)
Eigen::Map< const Derived, AlignedMax, StrideType > type
EIGEN_DEVICE_FUNC PlainObjectBase(internal::constructor_without_unaligned_array_assert)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PlainObjectBase(Index size, Index rows, Index cols)
const Eigen::Map< const Derived, Unaligned > ConstMapType
General-purpose arrays with easy API for coefficient-wise operations.
Definition: Array.h:45
static ConstMapType Map(const Scalar *data)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PlainObjectBase(const DenseBase< OtherDerived > &other)
EIGEN_DEVICE_FUNC Index rows() const
Definition: EigenBase.h:59
static StridedConstAlignedMapType< Stride< Outer, Inner > >::type MapAligned(const Scalar *data, Index rows, Index cols, const Stride< Outer, Inner > &stride)
static MapType Map(Scalar *data, Index size)
#define EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
static double error
Definition: testRot3.cpp:39
EIGEN_DEVICE_FUNC Index cols() const
Definition: ReturnByValue.h:64
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PlainObjectBase(const ReturnByValue< OtherDerived > &other)
Copy constructor with in-place evaluation.
const int Dynamic
Definition: Constants.h:21
#define EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(TYPE)
Definition: StaticAssert.h:149
EIGEN_DEVICE_FUNC void throw_std_bad_alloc()
Definition: Memory.h:67
EIGEN_STRONG_INLINE void writePacket(Index rowId, Index colId, const PacketScalar &val)
EIGEN_DEVICE_FUNC const T * data() const
Definition: DenseStorage.h:215
Pose2 T1(M_PI/4.0, Point2(sqrt(0.5), sqrt(0.5)))
static EIGEN_DEVICE_FUNC Index cols(void)
Definition: DenseStorage.h:212
The matrix class, also used for vectors and row-vectors.
v resize(3)
#define EIGEN_STATIC_ASSERT_VECTOR_ONLY(TYPE)
Definition: StaticAssert.h:139
NumTraits< Scalar >::Real RealScalar
Eigen::Map< Derived, Unaligned > MapType
EIGEN_DEVICE_FUNC Derived & derived()
Definition: EigenBase.h:45
Base class for all dense matrices, vectors, and expressions.
Definition: MatrixBase.h:48
static EIGEN_DEVICE_FUNC void run(MatrixTypeA &a, MatrixTypeB &b)
EIGEN_DEVICE_FUNC ColsBlockXpr rightCols(Index n)
Definition: DenseBase.h:659
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived & operator=(const ReturnByValue< OtherDerived > &func)
void swap(mpfr::mpreal &x, mpfr::mpreal &y)
Definition: mpreal.h:2986
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar & coeff(Index rowId, Index colId) const
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_assignment(Dst &dst, const Src &src)
static void run(DenseBase< Derived > &_this, const DenseBase< OtherDerived > &other)
EIGEN_DEVICE_FUNC Index size() const
Definition: EigenBase.h:66
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _init1(const Scalar &val0, typename internal::enable_if< Base::SizeAtCompileTime!=Dynamic &&Base::SizeAtCompileTime!=1 &&internal::is_convertible< T, Scalar >::value &&internal::is_same< typename internal::traits< Derived >::XprKind, ArrayXpr >::value, T >::type *=0)
#define EIGEN_UNUSED_VARIABLE(var)
Definition: Macros.h:618
static StridedConstAlignedMapType< Stride< Outer, Inner > >::type MapAligned(const Scalar *data, Index size, const Stride< Outer, Inner > &stride)
Definition: pytypes.h:897
static ConstAlignedMapType MapAligned(const Scalar *data)
#define EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(TYPE, SIZE)
Definition: StaticAssert.h:154
void swap(scoped_array< T > &a, scoped_array< T > &b)
Definition: Memory.h:602
#define EIGEN_ONLY_USED_FOR_DEBUG(x)
Definition: Macros.h:591
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _init2(Index rows, Index cols, typename internal::enable_if< Base::SizeAtCompileTime!=2, T0 >::type *=0)
EIGEN_STRONG_INLINE PacketScalar packet(Index rowId, Index colId) const
v setZero(3)
internal::packet_traits< Scalar >::type PacketScalar


gtsam
Author(s):
autogenerated on Sat May 8 2021 02:43:27