Eigen  3.2.93
PlainObjectBase.h
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
32  static EIGEN_ALWAYS_INLINE void run(Index, Index)
33  {
34  }
35 };
36 
37 template<> struct check_rows_cols_for_overflow<Dynamic> {
38  template<typename Index>
39  EIGEN_DEVICE_FUNC
40  static EIGEN_ALWAYS_INLINE void run(Index rows, Index cols)
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 = (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)
48  throw_std_bad_alloc();
49  }
50 };
51 
52 template <typename Derived,
53  typename OtherDerived = Derived,
54  bool IsVector = bool(Derived::IsVectorAtCompileTime) && bool(OtherDerived::IsVectorAtCompileTime)>
55 struct conservative_resize_like_impl;
56 
57 template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers> struct matrix_swap_impl;
58 
59 } // end namespace internal
60 
70 #ifdef EIGEN_PARSED_BY_DOXYGEN
71 namespace doxygen {
72 
73 // this is a workaround to doxygen not being able to understand the inheritance logic
74 // when it is hidden by the dense_xpr_base helper struct.
76 template<typename Derived> struct dense_xpr_base_dispatcher;
78 template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
79 struct dense_xpr_base_dispatcher<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
80  : public MatrixBase<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > {};
82 template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
83 struct dense_xpr_base_dispatcher<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
84  : public ArrayBase<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > {};
85 
86 } // namespace doxygen
87 
88 template<typename Derived>
90 #else
91 template<typename Derived>
92 class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
93 #endif
94 {
95  public:
96  enum { Options = internal::traits<Derived>::Options };
97  typedef typename internal::dense_xpr_base<Derived>::type Base;
98 
99  typedef typename internal::traits<Derived>::StorageKind StorageKind;
100  typedef typename internal::traits<Derived>::Scalar Scalar;
101 
102  typedef typename internal::packet_traits<Scalar>::type PacketScalar;
103  typedef typename NumTraits<Scalar>::Real RealScalar;
104  typedef Derived DenseType;
105 
106  using Base::RowsAtCompileTime;
107  using Base::ColsAtCompileTime;
108  using Base::SizeAtCompileTime;
109  using Base::MaxRowsAtCompileTime;
110  using Base::MaxColsAtCompileTime;
111  using Base::MaxSizeAtCompileTime;
112  using Base::IsVectorAtCompileTime;
113  using Base::Flags;
114 
115  template<typename PlainObjectType, int MapOptions, typename StrideType> friend class Eigen::Map;
116  friend class Eigen::Map<Derived, Unaligned>;
118  friend class Eigen::Map<const Derived, Unaligned>;
120 #if EIGEN_MAX_ALIGN_BYTES>0
121  // for EIGEN_MAX_ALIGN_BYTES==0, AlignedMax==Unaligned, and many compilers generate warnings for friend-ing a class twice.
122  friend class Eigen::Map<Derived, AlignedMax>;
123  friend class Eigen::Map<const Derived, AlignedMax>;
124 #endif
127  template<typename StrideType> struct StridedMapType { typedef Eigen::Map<Derived, Unaligned, StrideType> type; };
128  template<typename StrideType> struct StridedConstMapType { typedef Eigen::Map<const Derived, Unaligned, StrideType> type; };
129  template<typename StrideType> struct StridedAlignedMapType { typedef Eigen::Map<Derived, AlignedMax, StrideType> type; };
130  template<typename StrideType> struct StridedConstAlignedMapType { typedef Eigen::Map<const Derived, AlignedMax, StrideType> type; };
131 
132  protected:
133  DenseStorage<Scalar, Base::MaxSizeAtCompileTime, Base::RowsAtCompileTime, Base::ColsAtCompileTime, Options> m_storage;
134 
135  public:
136  enum { NeedsToAlign = (SizeAtCompileTime != Dynamic) && (internal::traits<Derived>::Alignment>0) };
137  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign)
138 
139  EIGEN_DEVICE_FUNC
140  Base& base() { return *static_cast<Base*>(this); }
141  EIGEN_DEVICE_FUNC
142  const Base& base() const { return *static_cast<const Base*>(this); }
143 
144  EIGEN_DEVICE_FUNC
145  EIGEN_STRONG_INLINE Index rows() const { return m_storage.rows(); }
146  EIGEN_DEVICE_FUNC
147  EIGEN_STRONG_INLINE Index cols() const { return m_storage.cols(); }
148 
153  EIGEN_DEVICE_FUNC
154  EIGEN_STRONG_INLINE const Scalar& coeff(Index rowId, Index colId) const
155  {
156  if(Flags & RowMajorBit)
157  return m_storage.data()[colId + rowId * m_storage.cols()];
158  else // column-major
159  return m_storage.data()[rowId + colId * m_storage.rows()];
160  }
161 
166  EIGEN_DEVICE_FUNC
167  EIGEN_STRONG_INLINE const Scalar& coeff(Index index) const
168  {
169  return m_storage.data()[index];
170  }
171 
176  EIGEN_DEVICE_FUNC
177  EIGEN_STRONG_INLINE Scalar& coeffRef(Index rowId, Index colId)
178  {
179  if(Flags & RowMajorBit)
180  return m_storage.data()[colId + rowId * m_storage.cols()];
181  else // column-major
182  return m_storage.data()[rowId + colId * m_storage.rows()];
183  }
184 
189  EIGEN_DEVICE_FUNC
190  EIGEN_STRONG_INLINE Scalar& coeffRef(Index index)
191  {
192  return m_storage.data()[index];
193  }
194 
197  EIGEN_DEVICE_FUNC
198  EIGEN_STRONG_INLINE const Scalar& coeffRef(Index rowId, Index colId) const
199  {
200  if(Flags & RowMajorBit)
201  return m_storage.data()[colId + rowId * m_storage.cols()];
202  else // column-major
203  return m_storage.data()[rowId + colId * m_storage.rows()];
204  }
205 
208  EIGEN_DEVICE_FUNC
209  EIGEN_STRONG_INLINE const Scalar& coeffRef(Index index) const
210  {
211  return m_storage.data()[index];
212  }
213 
215  template<int LoadMode>
216  EIGEN_STRONG_INLINE PacketScalar packet(Index rowId, Index colId) const
217  {
218  return internal::ploadt<PacketScalar, LoadMode>
219  (m_storage.data() + (Flags & RowMajorBit
220  ? colId + rowId * m_storage.cols()
221  : rowId + colId * m_storage.rows()));
222  }
223 
225  template<int LoadMode>
226  EIGEN_STRONG_INLINE PacketScalar packet(Index index) const
227  {
228  return internal::ploadt<PacketScalar, LoadMode>(m_storage.data() + index);
229  }
230 
232  template<int StoreMode>
233  EIGEN_STRONG_INLINE void writePacket(Index rowId, Index colId, const PacketScalar& val)
234  {
235  internal::pstoret<Scalar, PacketScalar, StoreMode>
236  (m_storage.data() + (Flags & RowMajorBit
237  ? colId + rowId * m_storage.cols()
238  : rowId + colId * m_storage.rows()), val);
239  }
240 
242  template<int StoreMode>
243  EIGEN_STRONG_INLINE void writePacket(Index index, const PacketScalar& val)
244  {
245  internal::pstoret<Scalar, PacketScalar, StoreMode>(m_storage.data() + index, val);
246  }
247 
249  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar *data() const
250  { return m_storage.data(); }
251 
253  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar *data()
254  { return m_storage.data(); }
255 
272  EIGEN_DEVICE_FUNC
273  EIGEN_STRONG_INLINE void resize(Index rows, Index cols)
274  {
275  eigen_assert( EIGEN_IMPLIES(RowsAtCompileTime!=Dynamic,rows==RowsAtCompileTime)
276  && EIGEN_IMPLIES(ColsAtCompileTime!=Dynamic,cols==ColsAtCompileTime)
277  && EIGEN_IMPLIES(RowsAtCompileTime==Dynamic && MaxRowsAtCompileTime!=Dynamic,rows<=MaxRowsAtCompileTime)
278  && EIGEN_IMPLIES(ColsAtCompileTime==Dynamic && MaxColsAtCompileTime!=Dynamic,cols<=MaxColsAtCompileTime)
279  && rows>=0 && cols>=0 && "Invalid sizes when resizing a matrix or array.");
280  internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(rows, cols);
281  #ifdef EIGEN_INITIALIZE_COEFFS
282  Index size = rows*cols;
283  bool size_changed = size != this->size();
284  m_storage.resize(size, rows, cols);
285  if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
286  #else
287  m_storage.resize(rows*cols, rows, cols);
288  #endif
289  }
290 
302  EIGEN_DEVICE_FUNC
303  inline void resize(Index size)
304  {
305  EIGEN_STATIC_ASSERT_VECTOR_ONLY(PlainObjectBase)
306  eigen_assert(((SizeAtCompileTime == Dynamic && (MaxSizeAtCompileTime==Dynamic || size<=MaxSizeAtCompileTime)) || SizeAtCompileTime == size) && size>=0);
307  #ifdef EIGEN_INITIALIZE_COEFFS
308  bool size_changed = size != this->size();
309  #endif
310  if(RowsAtCompileTime == 1)
311  m_storage.resize(size, 1, size);
312  else
313  m_storage.resize(size, size, 1);
314  #ifdef EIGEN_INITIALIZE_COEFFS
315  if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
316  #endif
317  }
318 
327  EIGEN_DEVICE_FUNC
328  inline void resize(NoChange_t, Index cols)
329  {
330  resize(rows(), cols);
331  }
332 
341  EIGEN_DEVICE_FUNC
342  inline void resize(Index rows, NoChange_t)
343  {
344  resize(rows, cols());
345  }
346 
354  template<typename OtherDerived>
355  EIGEN_DEVICE_FUNC
356  EIGEN_STRONG_INLINE void resizeLike(const EigenBase<OtherDerived>& _other)
357  {
358  const OtherDerived& other = _other.derived();
359  internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(other.rows(), other.cols());
360  const Index othersize = other.rows()*other.cols();
361  if(RowsAtCompileTime == 1)
362  {
363  eigen_assert(other.rows() == 1 || other.cols() == 1);
364  resize(1, othersize);
365  }
366  else if(ColsAtCompileTime == 1)
367  {
368  eigen_assert(other.rows() == 1 || other.cols() == 1);
369  resize(othersize, 1);
370  }
371  else resize(other.rows(), other.cols());
372  }
373 
383  EIGEN_DEVICE_FUNC
384  EIGEN_STRONG_INLINE void conservativeResize(Index rows, Index cols)
385  {
386  internal::conservative_resize_like_impl<Derived>::run(*this, rows, cols);
387  }
388 
396  EIGEN_DEVICE_FUNC
397  EIGEN_STRONG_INLINE void conservativeResize(Index rows, NoChange_t)
398  {
399  // Note: see the comment in conservativeResize(Index,Index)
400  conservativeResize(rows, cols());
401  }
402 
410  EIGEN_DEVICE_FUNC
411  EIGEN_STRONG_INLINE void conservativeResize(NoChange_t, Index cols)
412  {
413  // Note: see the comment in conservativeResize(Index,Index)
414  conservativeResize(rows(), cols);
415  }
416 
425  EIGEN_DEVICE_FUNC
426  EIGEN_STRONG_INLINE void conservativeResize(Index size)
427  {
428  internal::conservative_resize_like_impl<Derived>::run(*this, size);
429  }
430 
440  template<typename OtherDerived>
441  EIGEN_DEVICE_FUNC
442  EIGEN_STRONG_INLINE void conservativeResizeLike(const DenseBase<OtherDerived>& other)
443  {
444  internal::conservative_resize_like_impl<Derived,OtherDerived>::run(*this, other);
445  }
446 
450  EIGEN_DEVICE_FUNC
451  EIGEN_STRONG_INLINE Derived& operator=(const PlainObjectBase& other)
452  {
453  return _set(other);
454  }
455 
457  template<typename OtherDerived>
458  EIGEN_DEVICE_FUNC
459  EIGEN_STRONG_INLINE Derived& lazyAssign(const DenseBase<OtherDerived>& other)
460  {
461  _resize_to_match(other);
462  return Base::lazyAssign(other.derived());
463  }
464 
465  template<typename OtherDerived>
466  EIGEN_DEVICE_FUNC
467  EIGEN_STRONG_INLINE Derived& operator=(const ReturnByValue<OtherDerived>& func)
468  {
469  resize(func.rows(), func.cols());
470  return Base::operator=(func);
471  }
472 
473  // Prevent user from trying to instantiate PlainObjectBase objects
474  // by making all its constructor protected. See bug 1074.
475  protected:
476 
477  EIGEN_DEVICE_FUNC
478  EIGEN_STRONG_INLINE PlainObjectBase() : m_storage()
479  {
480 // _check_template_params();
481 // EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
482  }
483 
484 #ifndef EIGEN_PARSED_BY_DOXYGEN
485  // FIXME is it still needed ?
487  EIGEN_DEVICE_FUNC
488  explicit PlainObjectBase(internal::constructor_without_unaligned_array_assert)
489  : m_storage(internal::constructor_without_unaligned_array_assert())
490  {
491 // _check_template_params(); EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
492  }
493 #endif
494 
495 #if EIGEN_HAS_RVALUE_REFERENCES
496  EIGEN_DEVICE_FUNC
497  PlainObjectBase(PlainObjectBase&& other) EIGEN_NOEXCEPT
498  : m_storage( std::move(other.m_storage) )
499  {
500  }
501 
502  EIGEN_DEVICE_FUNC
503  PlainObjectBase& operator=(PlainObjectBase&& other) EIGEN_NOEXCEPT
504  {
505  using std::swap;
506  swap(m_storage, other.m_storage);
507  return *this;
508  }
509 #endif
510 
512  EIGEN_DEVICE_FUNC
513  EIGEN_STRONG_INLINE PlainObjectBase(const PlainObjectBase& other)
514  : Base(), m_storage(other.m_storage) { }
515  EIGEN_DEVICE_FUNC
516  EIGEN_STRONG_INLINE PlainObjectBase(Index size, Index rows, Index cols)
517  : m_storage(size, rows, cols)
518  {
519 // _check_template_params();
520 // EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
521  }
522 
524  template<typename OtherDerived>
525  EIGEN_DEVICE_FUNC
526  EIGEN_STRONG_INLINE PlainObjectBase(const DenseBase<OtherDerived> &other)
527  : m_storage()
528  {
529  _check_template_params();
530  resizeLike(other);
531  _set_noalias(other);
532  }
533 
535  template<typename OtherDerived>
536  EIGEN_DEVICE_FUNC
537  EIGEN_STRONG_INLINE PlainObjectBase(const EigenBase<OtherDerived> &other)
538  : m_storage()
539  {
540  _check_template_params();
541  resizeLike(other);
542  *this = other.derived();
543  }
545  template<typename OtherDerived>
546  EIGEN_DEVICE_FUNC
547  EIGEN_STRONG_INLINE PlainObjectBase(const ReturnByValue<OtherDerived>& other)
548  {
549  _check_template_params();
550  // FIXME this does not automatically transpose vectors if necessary
551  resize(other.rows(), other.cols());
552  other.evalTo(this->derived());
553  }
554 
555  public:
556 
559  template<typename OtherDerived>
560  EIGEN_DEVICE_FUNC
561  EIGEN_STRONG_INLINE Derived& operator=(const EigenBase<OtherDerived> &other)
562  {
563  _resize_to_match(other);
564  Base::operator=(other.derived());
565  return this->derived();
566  }
567 
576  static inline ConstMapType Map(const Scalar* data)
577  { return ConstMapType(data); }
578  static inline MapType Map(Scalar* data)
579  { return MapType(data); }
580  static inline ConstMapType Map(const Scalar* data, Index size)
581  { return ConstMapType(data, size); }
582  static inline MapType Map(Scalar* data, Index size)
583  { return MapType(data, size); }
584  static inline ConstMapType Map(const Scalar* data, Index rows, Index cols)
585  { return ConstMapType(data, rows, cols); }
586  static inline MapType Map(Scalar* data, Index rows, Index cols)
587  { return MapType(data, rows, cols); }
588 
589  static inline ConstAlignedMapType MapAligned(const Scalar* data)
590  { return ConstAlignedMapType(data); }
591  static inline AlignedMapType MapAligned(Scalar* data)
592  { return AlignedMapType(data); }
593  static inline ConstAlignedMapType MapAligned(const Scalar* data, Index size)
594  { return ConstAlignedMapType(data, size); }
595  static inline AlignedMapType MapAligned(Scalar* data, Index size)
596  { return AlignedMapType(data, size); }
597  static inline ConstAlignedMapType MapAligned(const Scalar* data, Index rows, Index cols)
598  { return ConstAlignedMapType(data, rows, cols); }
599  static inline AlignedMapType MapAligned(Scalar* data, Index rows, Index cols)
600  { return AlignedMapType(data, rows, cols); }
601 
602  template<int Outer, int Inner>
603  static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, const Stride<Outer, Inner>& stride)
604  { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, stride); }
605  template<int Outer, int Inner>
606  static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, const Stride<Outer, Inner>& stride)
607  { return typename StridedMapType<Stride<Outer, Inner> >::type(data, stride); }
608  template<int Outer, int Inner>
609  static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, Index size, const Stride<Outer, Inner>& stride)
610  { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, size, stride); }
611  template<int Outer, int Inner>
612  static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, Index size, const Stride<Outer, Inner>& stride)
613  { return typename StridedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
614  template<int Outer, int Inner>
615  static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
616  { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
617  template<int Outer, int Inner>
618  static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
619  { return typename StridedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
620 
621  template<int Outer, int Inner>
622  static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, const Stride<Outer, Inner>& stride)
623  { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, stride); }
624  template<int Outer, int Inner>
625  static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, const Stride<Outer, Inner>& stride)
626  { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, stride); }
627  template<int Outer, int Inner>
628  static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, Index size, const Stride<Outer, Inner>& stride)
629  { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
630  template<int Outer, int Inner>
631  static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, Index size, const Stride<Outer, Inner>& stride)
632  { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
633  template<int Outer, int Inner>
634  static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
635  { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
636  template<int Outer, int Inner>
637  static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
638  { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
640 
641  using Base::setConstant;
642  EIGEN_DEVICE_FUNC Derived& setConstant(Index size, const Scalar& val);
643  EIGEN_DEVICE_FUNC Derived& setConstant(Index rows, Index cols, const Scalar& val);
644 
645  using Base::setZero;
646  EIGEN_DEVICE_FUNC Derived& setZero(Index size);
647  EIGEN_DEVICE_FUNC Derived& setZero(Index rows, Index cols);
648 
649  using Base::setOnes;
650  EIGEN_DEVICE_FUNC Derived& setOnes(Index size);
651  EIGEN_DEVICE_FUNC Derived& setOnes(Index rows, Index cols);
652 
653  using Base::setRandom;
654  Derived& setRandom(Index size);
655  Derived& setRandom(Index rows, Index cols);
656 
657  #ifdef EIGEN_PLAINOBJECTBASE_PLUGIN
658  #include EIGEN_PLAINOBJECTBASE_PLUGIN
659  #endif
660 
661  protected:
669  template<typename OtherDerived>
670  EIGEN_DEVICE_FUNC
671  EIGEN_STRONG_INLINE void _resize_to_match(const EigenBase<OtherDerived>& other)
672  {
673  #ifdef EIGEN_NO_AUTOMATIC_RESIZING
674  eigen_assert((this->size()==0 || (IsVectorAtCompileTime ? (this->size() == other.size())
675  : (rows() == other.rows() && cols() == other.cols())))
676  && "Size mismatch. Automatic resizing is disabled because EIGEN_NO_AUTOMATIC_RESIZING is defined");
677  EIGEN_ONLY_USED_FOR_DEBUG(other);
678  #else
679  resizeLike(other);
680  #endif
681  }
682 
697  // aliasing is dealt once in internall::call_assignment
698  // so at this stage we have to assume aliasing... and resising has to be done later.
699  template<typename OtherDerived>
700  EIGEN_DEVICE_FUNC
701  EIGEN_STRONG_INLINE Derived& _set(const DenseBase<OtherDerived>& other)
702  {
703  internal::call_assignment(this->derived(), other.derived());
704  return this->derived();
705  }
706 
712  template<typename OtherDerived>
713  EIGEN_DEVICE_FUNC
714  EIGEN_STRONG_INLINE Derived& _set_noalias(const DenseBase<OtherDerived>& other)
715  {
716  // I don't think we need this resize call since the lazyAssign will anyways resize
717  // and lazyAssign will be called by the assign selector.
718  //_resize_to_match(other);
719  // the 'false' below means to enforce lazy evaluation. We don't use lazyAssign() because
720  // it wouldn't allow to copy a row-vector into a column-vector.
721  internal::call_assignment_no_alias(this->derived(), other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
722  return this->derived();
723  }
724 
725  template<typename T0, typename T1>
726  EIGEN_DEVICE_FUNC
727  EIGEN_STRONG_INLINE void _init2(Index rows, Index cols, typename internal::enable_if<Base::SizeAtCompileTime!=2,T0>::type* = 0)
728  {
729  EIGEN_STATIC_ASSERT(bool(NumTraits<T0>::IsInteger) &&
731  FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
732  resize(rows,cols);
733  }
734 
735  template<typename T0, typename T1>
736  EIGEN_DEVICE_FUNC
737  EIGEN_STRONG_INLINE void _init2(const T0& val0, const T1& val1, typename internal::enable_if<Base::SizeAtCompileTime==2,T0>::type* = 0)
738  {
739  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
740  m_storage.data()[0] = Scalar(val0);
741  m_storage.data()[1] = Scalar(val1);
742  }
743 
744  template<typename T0, typename T1>
745  EIGEN_DEVICE_FUNC
746  EIGEN_STRONG_INLINE void _init2(const Index& val0, const Index& val1,
747  typename internal::enable_if< (!internal::is_same<Index,Scalar>::value)
748  && (internal::is_same<T0,Index>::value)
749  && (internal::is_same<T1,Index>::value)
750  && Base::SizeAtCompileTime==2,T1>::type* = 0)
751  {
752  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
753  m_storage.data()[0] = Scalar(val0);
754  m_storage.data()[1] = Scalar(val1);
755  }
756 
757  // The argument is convertible to the Index type and we either have a non 1x1 Matrix, or a dynamic-sized Array,
758  // then the argument is meant to be the size of the object.
759  template<typename T>
760  EIGEN_DEVICE_FUNC
761  EIGEN_STRONG_INLINE void _init1(Index size, typename internal::enable_if< (Base::SizeAtCompileTime!=1 || !internal::is_convertible<T, Scalar>::value)
762  && ((!internal::is_same<typename internal::traits<Derived>::XprKind,ArrayXpr>::value || Base::SizeAtCompileTime==Dynamic)),T>::type* = 0)
763  {
764  // NOTE MSVC 2008 complains if we directly put bool(NumTraits<T>::IsInteger) as the EIGEN_STATIC_ASSERT argument.
765  const bool is_integer = NumTraits<T>::IsInteger;
766  EIGEN_STATIC_ASSERT(is_integer,
767  FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
768  resize(size);
769  }
770 
771  // 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)
772  template<typename T>
773  EIGEN_DEVICE_FUNC
774  EIGEN_STRONG_INLINE void _init1(const Scalar& val0, typename internal::enable_if<Base::SizeAtCompileTime==1 && internal::is_convertible<T, Scalar>::value,T>::type* = 0)
775  {
776  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 1)
777  m_storage.data()[0] = val0;
778  }
779 
780  // 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)
781  template<typename T>
782  EIGEN_DEVICE_FUNC
783  EIGEN_STRONG_INLINE void _init1(const Index& val0,
784  typename internal::enable_if< (!internal::is_same<Index,Scalar>::value)
785  && (internal::is_same<Index,T>::value)
786  && Base::SizeAtCompileTime==1
787  && internal::is_convertible<T, Scalar>::value,T*>::type* = 0)
788  {
789  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 1)
790  m_storage.data()[0] = Scalar(val0);
791  }
792 
793  // Initialize a fixed size matrix from a pointer to raw data
794  template<typename T>
795  EIGEN_DEVICE_FUNC
796  EIGEN_STRONG_INLINE void _init1(const Scalar* data){
797  this->_set_noalias(ConstMapType(data));
798  }
799 
800  // Initialize an arbitrary matrix from a dense expression
801  template<typename T, typename OtherDerived>
802  EIGEN_DEVICE_FUNC
803  EIGEN_STRONG_INLINE void _init1(const DenseBase<OtherDerived>& other){
804  this->_set_noalias(other);
805  }
806 
807  // Initialize an arbitrary matrix from a generic Eigen expression
808  template<typename T, typename OtherDerived>
809  EIGEN_DEVICE_FUNC
810  EIGEN_STRONG_INLINE void _init1(const EigenBase<OtherDerived>& other){
811  this->derived() = other;
812  }
813 
814  template<typename T, typename OtherDerived>
815  EIGEN_DEVICE_FUNC
816  EIGEN_STRONG_INLINE void _init1(const ReturnByValue<OtherDerived>& other)
817  {
818  resize(other.rows(), other.cols());
819  other.evalTo(this->derived());
820  }
821 
822  template<typename T, typename OtherDerived, int ColsAtCompileTime>
823  EIGEN_DEVICE_FUNC
824  EIGEN_STRONG_INLINE void _init1(const RotationBase<OtherDerived,ColsAtCompileTime>& r)
825  {
826  this->derived() = r;
827  }
828 
829  // For fixed -size arrays:
830  template<typename T>
831  EIGEN_DEVICE_FUNC
832  EIGEN_STRONG_INLINE void _init1(const Scalar& val0,
833  typename internal::enable_if< Base::SizeAtCompileTime!=Dynamic
834  && Base::SizeAtCompileTime!=1
835  && internal::is_convertible<T, Scalar>::value
836  && internal::is_same<typename internal::traits<Derived>::XprKind,ArrayXpr>::value,T>::type* = 0)
837  {
838  Base::setConstant(val0);
839  }
840 
841  template<typename T>
842  EIGEN_DEVICE_FUNC
843  EIGEN_STRONG_INLINE void _init1(const Index& val0,
844  typename internal::enable_if< (!internal::is_same<Index,Scalar>::value)
845  && (internal::is_same<Index,T>::value)
846  && Base::SizeAtCompileTime!=Dynamic
847  && Base::SizeAtCompileTime!=1
848  && internal::is_convertible<T, Scalar>::value
849  && internal::is_same<typename internal::traits<Derived>::XprKind,ArrayXpr>::value,T*>::type* = 0)
850  {
851  Base::setConstant(val0);
852  }
853 
854  template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers>
855  friend struct internal::matrix_swap_impl;
856 
857  public:
858 
859 #ifndef EIGEN_PARSED_BY_DOXYGEN
860 
864  template<typename OtherDerived>
865  EIGEN_DEVICE_FUNC
866  void swap(DenseBase<OtherDerived> & other)
867  {
868  enum { SwapPointers = internal::is_same<Derived, OtherDerived>::value && Base::SizeAtCompileTime==Dynamic };
869  internal::matrix_swap_impl<Derived, OtherDerived, bool(SwapPointers)>::run(this->derived(), other.derived());
870  }
871 
875  template<typename OtherDerived>
876  EIGEN_DEVICE_FUNC
877  void swap(DenseBase<OtherDerived> const & other)
878  { Base::swap(other.derived()); }
879 
880  EIGEN_DEVICE_FUNC
881  static EIGEN_STRONG_INLINE void _check_template_params()
882  {
883  EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, (Options&RowMajor)==RowMajor)
884  && EIGEN_IMPLIES(MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1, (Options&RowMajor)==0)
885  && ((RowsAtCompileTime == Dynamic) || (RowsAtCompileTime >= 0))
886  && ((ColsAtCompileTime == Dynamic) || (ColsAtCompileTime >= 0))
887  && ((MaxRowsAtCompileTime == Dynamic) || (MaxRowsAtCompileTime >= 0))
888  && ((MaxColsAtCompileTime == Dynamic) || (MaxColsAtCompileTime >= 0))
889  && (MaxRowsAtCompileTime == RowsAtCompileTime || RowsAtCompileTime==Dynamic)
890  && (MaxColsAtCompileTime == ColsAtCompileTime || ColsAtCompileTime==Dynamic)
891  && (Options & (DontAlign|RowMajor)) == Options),
892  INVALID_MATRIX_TEMPLATE_PARAMETERS)
893  }
894 
895  enum { IsPlainObjectBase = 1 };
896 #endif
897 };
898 
899 namespace internal {
900 
901 template <typename Derived, typename OtherDerived, bool IsVector>
902 struct conservative_resize_like_impl
903 {
904  static void run(DenseBase<Derived>& _this, Index rows, Index cols)
905  {
906  if (_this.rows() == rows && _this.cols() == cols) return;
907  EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
908 
909  if ( ( Derived::IsRowMajor && _this.cols() == cols) || // row-major and we change only the number of rows
910  (!Derived::IsRowMajor && _this.rows() == rows) ) // column-major and we change only the number of columns
911  {
912  internal::check_rows_cols_for_overflow<Derived::MaxSizeAtCompileTime>::run(rows, cols);
913  _this.derived().m_storage.conservativeResize(rows*cols,rows,cols);
914  }
915  else
916  {
917  // The storage order does not allow us to use reallocation.
918  typename Derived::PlainObject tmp(rows,cols);
919  const Index common_rows = (std::min)(rows, _this.rows());
920  const Index common_cols = (std::min)(cols, _this.cols());
921  tmp.block(0,0,common_rows,common_cols) = _this.block(0,0,common_rows,common_cols);
922  _this.derived().swap(tmp);
923  }
924  }
925 
926  static void run(DenseBase<Derived>& _this, const DenseBase<OtherDerived>& other)
927  {
928  if (_this.rows() == other.rows() && _this.cols() == other.cols()) return;
929 
930  // Note: Here is space for improvement. Basically, for conservativeResize(Index,Index),
931  // neither RowsAtCompileTime or ColsAtCompileTime must be Dynamic. If only one of the
932  // dimensions is dynamic, one could use either conservativeResize(Index rows, NoChange_t) or
933  // conservativeResize(NoChange_t, Index cols). For these methods new static asserts like
934  // EIGEN_STATIC_ASSERT_DYNAMIC_ROWS and EIGEN_STATIC_ASSERT_DYNAMIC_COLS would be good.
935  EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
936  EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(OtherDerived)
937 
938  if ( ( Derived::IsRowMajor && _this.cols() == other.cols()) || // row-major and we change only the number of rows
939  (!Derived::IsRowMajor && _this.rows() == other.rows()) ) // column-major and we change only the number of columns
940  {
941  const Index new_rows = other.rows() - _this.rows();
942  const Index new_cols = other.cols() - _this.cols();
943  _this.derived().m_storage.conservativeResize(other.size(),other.rows(),other.cols());
944  if (new_rows>0)
945  _this.bottomRightCorner(new_rows, other.cols()) = other.bottomRows(new_rows);
946  else if (new_cols>0)
947  _this.bottomRightCorner(other.rows(), new_cols) = other.rightCols(new_cols);
948  }
949  else
950  {
951  // The storage order does not allow us to use reallocation.
952  typename Derived::PlainObject tmp(other);
953  const Index common_rows = (std::min)(tmp.rows(), _this.rows());
954  const Index common_cols = (std::min)(tmp.cols(), _this.cols());
955  tmp.block(0,0,common_rows,common_cols) = _this.block(0,0,common_rows,common_cols);
956  _this.derived().swap(tmp);
957  }
958  }
959 };
960 
961 // Here, the specialization for vectors inherits from the general matrix case
962 // to allow calling .conservativeResize(rows,cols) on vectors.
963 template <typename Derived, typename OtherDerived>
964 struct conservative_resize_like_impl<Derived,OtherDerived,true>
965  : conservative_resize_like_impl<Derived,OtherDerived,false>
966 {
967  using conservative_resize_like_impl<Derived,OtherDerived,false>::run;
968 
969  static void run(DenseBase<Derived>& _this, Index size)
970  {
971  const Index new_rows = Derived::RowsAtCompileTime==1 ? 1 : size;
972  const Index new_cols = Derived::RowsAtCompileTime==1 ? size : 1;
973  _this.derived().m_storage.conservativeResize(size,new_rows,new_cols);
974  }
975 
976  static void run(DenseBase<Derived>& _this, const DenseBase<OtherDerived>& other)
977  {
978  if (_this.rows() == other.rows() && _this.cols() == other.cols()) return;
979 
980  const Index num_new_elements = other.size() - _this.size();
981 
982  const Index new_rows = Derived::RowsAtCompileTime==1 ? 1 : other.rows();
983  const Index new_cols = Derived::RowsAtCompileTime==1 ? other.cols() : 1;
984  _this.derived().m_storage.conservativeResize(other.size(),new_rows,new_cols);
985 
986  if (num_new_elements > 0)
987  _this.tail(num_new_elements) = other.tail(num_new_elements);
988  }
989 };
990 
991 template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers>
992 struct matrix_swap_impl
993 {
994  EIGEN_DEVICE_FUNC
995  static inline void run(MatrixTypeA& a, MatrixTypeB& b)
996  {
997  a.base().swap(b);
998  }
999 };
1000 
1001 template<typename MatrixTypeA, typename MatrixTypeB>
1002 struct matrix_swap_impl<MatrixTypeA, MatrixTypeB, true>
1003 {
1004  EIGEN_DEVICE_FUNC
1005  static inline void run(MatrixTypeA& a, MatrixTypeB& b)
1006  {
1007  static_cast<typename MatrixTypeA::Base&>(a).m_storage.swap(static_cast<typename MatrixTypeB::Base&>(b).m_storage);
1008  }
1009 };
1010 
1011 } // end namespace internal
1012 
1013 } // end namespace Eigen
1014 
1015 #endif // EIGEN_DENSESTORAGEBASE_H
void resize(NoChange_t, Index cols)
Definition: PlainObjectBase.h:328
RowsBlockXpr bottomRows(Index n)
Definition: DenseBase.h:457
PlainObjectBase(const ReturnByValue< OtherDerived > &other)
Copy constructor with in-place evaluation.
Definition: PlainObjectBase.h:547
Definition: Constants.h:326
const Scalar & coeffRef(Index rowId, Index colId) const
Definition: PlainObjectBase.h:198
Definition: PlainObjectBase.h:76
Derived & lazyAssign(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:459
A matrix or vector expression mapping an existing array of data.
Definition: Map.h:88
void conservativeResize(Index rows, Index cols)
Definition: PlainObjectBase.h:384
Namespace containing all symbols from the Eigen library.
Definition: Core:271
Holds strides information for Map.
Definition: Stride.h:44
Holds information about the various numeric (i.e. scalar) types allowed by Eigen. ...
Definition: NumTraits.h:167
Derived & derived()
Definition: EigenBase.h:44
Eigen::Index Index
The interface type of indices.
Definition: EigenBase.h:37
const unsigned int RowMajorBit
Definition: Constants.h:61
Base class for all dense matrices, vectors, and arrays.
Definition: DenseBase.h:41
void resize(Index rows, Index cols)
Definition: PlainObjectBase.h:273
PlainObjectBase(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:526
PlainObjectBase(const EigenBase< OtherDerived > &other)
Definition: PlainObjectBase.h:537
PlainObjectBase(const PlainObjectBase &other)
Definition: PlainObjectBase.h:513
Definition: EigenBase.h:28
Scalar * data()
Definition: PlainObjectBase.h:253
Scalar & coeffRef(Index rowId, Index colId)
Definition: PlainObjectBase.h:177
void conservativeResize(NoChange_t, Index cols)
Definition: PlainObjectBase.h:411
BlockXpr block(Index startRow, Index startCol, Index blockRows, Index blockCols)
Definition: DenseBase.h:63
void resizeLike(const EigenBase< OtherDerived > &_other)
Definition: PlainObjectBase.h:356
Index size() const
Definition: EigenBase.h:65
Index rows() const
Definition: EigenBase.h:58
Scalar & coeffRef(Index index)
Definition: PlainObjectBase.h:190
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: XprHelper.h:35
void resize(Index rows, NoChange_t)
Definition: PlainObjectBase.h:342
const Scalar & coeff(Index index) const
Definition: PlainObjectBase.h:167
Dense storage base class for matrices and arrays.
Definition: PlainObjectBase.h:89
Derived & operator=(const PlainObjectBase &other)
Definition: PlainObjectBase.h:451
Common base class for compact rotation representations.
Definition: ForwardDeclarations.h:266
BlockXpr bottomRightCorner(Index cRows, Index cCols)
Definition: DenseBase.h:248
Base class for all 1D and 2D array, and related expressions.
Definition: ArrayBase.h:39
const Scalar * data() const
Definition: PlainObjectBase.h:249
void conservativeResize(Index size)
Definition: PlainObjectBase.h:426
Definition: Eigen_Colamd.h:50
void resize(Index size)
Definition: PlainObjectBase.h:303
const Scalar & coeff(Index rowId, Index colId) const
Definition: PlainObjectBase.h:154
const Scalar & coeffRef(Index index) const
Definition: PlainObjectBase.h:209
General-purpose arrays with easy API for coefficient-wise operations.
Definition: Array.h:45
Definition: Constants.h:322
Definition: Constants.h:509
const int Dynamic
Definition: Constants.h:21
void conservativeResizeLike(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:442
SegmentReturnType tail(Index n)
Definition: DenseBase.h:892
The matrix class, also used for vectors and row-vectors.
Definition: Matrix.h:178
Index cols() const
Definition: EigenBase.h:61
void conservativeResize(Index rows, NoChange_t)
Definition: PlainObjectBase.h:397
Derived & _set(const DenseBase< OtherDerived > &other)
Copies the value of the expression other into *this with automatic resizing.
Definition: PlainObjectBase.h:701
Derived & operator=(const EigenBase< OtherDerived > &other)
Copies the generic expression other into *this.
Definition: PlainObjectBase.h:561
ColsBlockXpr rightCols(Index n)
Definition: DenseBase.h:615
Base class for all dense matrices, vectors, and expressions.
Definition: MatrixBase.h:48