Eigen  3.2.4
 All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
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  static EIGEN_ALWAYS_INLINE void run(Index, Index)
32  {
33  }
34 };
35 
36 template<> struct check_rows_cols_for_overflow<Dynamic> {
37  template<typename Index>
38  static EIGEN_ALWAYS_INLINE void run(Index rows, Index cols)
39  {
40  // http://hg.mozilla.org/mozilla-central/file/6c8a909977d3/xpcom/ds/CheckedInt.h#l242
41  // we assume Index is signed
42  Index max_index = (size_t(1) << (8 * sizeof(Index) - 1)) - 1; // assume Index is signed
43  bool error = (rows == 0 || cols == 0) ? false
44  : (rows > max_index / cols);
45  if (error)
46  throw_std_bad_alloc();
47  }
48 };
49 
50 template <typename Derived,
51  typename OtherDerived = Derived,
52  bool IsVector = bool(Derived::IsVectorAtCompileTime) && bool(OtherDerived::IsVectorAtCompileTime)>
53 struct conservative_resize_like_impl;
54 
55 template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers> struct matrix_swap_impl;
56 
57 } // end namespace internal
58 
67 #ifdef EIGEN_PARSED_BY_DOXYGEN
68 namespace internal {
69 
70 // this is a warkaround to doxygen not being able to understand the inheritence logic
71 // when it is hidden by the dense_xpr_base helper struct.
72 template<typename Derived> struct dense_xpr_base_dispatcher_for_doxygen;// : public MatrixBase<Derived> {};
74 template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
75 struct dense_xpr_base_dispatcher_for_doxygen<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
76  : public MatrixBase<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > {};
78 template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
79 struct dense_xpr_base_dispatcher_for_doxygen<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
80  : public ArrayBase<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > {};
81 
82 } // namespace internal
83 
84 template<typename Derived>
85 class PlainObjectBase : public internal::dense_xpr_base_dispatcher_for_doxygen<Derived>
86 #else
87 template<typename Derived>
88 class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
89 #endif
90 {
91  public:
92  enum { Options = internal::traits<Derived>::Options };
93  typedef typename internal::dense_xpr_base<Derived>::type Base;
94 
95  typedef typename internal::traits<Derived>::StorageKind StorageKind;
96  typedef typename internal::traits<Derived>::Index Index;
97  typedef typename internal::traits<Derived>::Scalar Scalar;
98  typedef typename internal::packet_traits<Scalar>::type PacketScalar;
99  typedef typename NumTraits<Scalar>::Real RealScalar;
100  typedef Derived DenseType;
101 
102  using Base::RowsAtCompileTime;
103  using Base::ColsAtCompileTime;
104  using Base::SizeAtCompileTime;
105  using Base::MaxRowsAtCompileTime;
106  using Base::MaxColsAtCompileTime;
107  using Base::MaxSizeAtCompileTime;
108  using Base::IsVectorAtCompileTime;
109  using Base::Flags;
110 
111  template<typename PlainObjectType, int MapOptions, typename StrideType> friend class Eigen::Map;
112  friend class Eigen::Map<Derived, Unaligned>;
114  friend class Eigen::Map<const Derived, Unaligned>;
116  friend class Eigen::Map<Derived, Aligned>;
118  friend class Eigen::Map<const Derived, Aligned>;
120  template<typename StrideType> struct StridedMapType { typedef Eigen::Map<Derived, Unaligned, StrideType> type; };
121  template<typename StrideType> struct StridedConstMapType { typedef Eigen::Map<const Derived, Unaligned, StrideType> type; };
122  template<typename StrideType> struct StridedAlignedMapType { typedef Eigen::Map<Derived, Aligned, StrideType> type; };
123  template<typename StrideType> struct StridedConstAlignedMapType { typedef Eigen::Map<const Derived, Aligned, StrideType> type; };
124 
125  protected:
126  DenseStorage<Scalar, Base::MaxSizeAtCompileTime, Base::RowsAtCompileTime, Base::ColsAtCompileTime, Options> m_storage;
127 
128  public:
129  enum { NeedsToAlign = SizeAtCompileTime != Dynamic && (internal::traits<Derived>::Flags & AlignedBit) != 0 };
130  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign)
131 
132  Base& base() { return *static_cast<Base*>(this); }
133  const Base& base() const { return *static_cast<const Base*>(this); }
134 
135  EIGEN_STRONG_INLINE Index rows() const { return m_storage.rows(); }
136  EIGEN_STRONG_INLINE Index cols() const { return m_storage.cols(); }
137 
138  EIGEN_STRONG_INLINE const Scalar& coeff(Index rowId, Index colId) const
139  {
140  if(Flags & RowMajorBit)
141  return m_storage.data()[colId + rowId * m_storage.cols()];
142  else // column-major
143  return m_storage.data()[rowId + colId * m_storage.rows()];
144  }
145 
146  EIGEN_STRONG_INLINE const Scalar& coeff(Index index) const
147  {
148  return m_storage.data()[index];
149  }
150 
151  EIGEN_STRONG_INLINE Scalar& coeffRef(Index rowId, Index colId)
152  {
153  if(Flags & RowMajorBit)
154  return m_storage.data()[colId + rowId * m_storage.cols()];
155  else // column-major
156  return m_storage.data()[rowId + colId * m_storage.rows()];
157  }
158 
159  EIGEN_STRONG_INLINE Scalar& coeffRef(Index index)
160  {
161  return m_storage.data()[index];
162  }
163 
164  EIGEN_STRONG_INLINE const Scalar& coeffRef(Index rowId, Index colId) const
165  {
166  if(Flags & RowMajorBit)
167  return m_storage.data()[colId + rowId * m_storage.cols()];
168  else // column-major
169  return m_storage.data()[rowId + colId * m_storage.rows()];
170  }
171 
172  EIGEN_STRONG_INLINE const Scalar& coeffRef(Index index) const
173  {
174  return m_storage.data()[index];
175  }
176 
178  template<int LoadMode>
179  EIGEN_STRONG_INLINE PacketScalar packet(Index rowId, Index colId) const
180  {
181  return internal::ploadt<PacketScalar, LoadMode>
182  (m_storage.data() + (Flags & RowMajorBit
183  ? colId + rowId * m_storage.cols()
184  : rowId + colId * m_storage.rows()));
185  }
186 
188  template<int LoadMode>
189  EIGEN_STRONG_INLINE PacketScalar packet(Index index) const
190  {
191  return internal::ploadt<PacketScalar, LoadMode>(m_storage.data() + index);
192  }
193 
195  template<int StoreMode>
196  EIGEN_STRONG_INLINE void writePacket(Index rowId, Index colId, const PacketScalar& val)
197  {
198  internal::pstoret<Scalar, PacketScalar, StoreMode>
199  (m_storage.data() + (Flags & RowMajorBit
200  ? colId + rowId * m_storage.cols()
201  : rowId + colId * m_storage.rows()), val);
202  }
203 
205  template<int StoreMode>
206  EIGEN_STRONG_INLINE void writePacket(Index index, const PacketScalar& val)
207  {
208  internal::pstoret<Scalar, PacketScalar, StoreMode>(m_storage.data() + index, val);
209  }
210 
212  EIGEN_STRONG_INLINE const Scalar *data() const
213  { return m_storage.data(); }
214 
216  EIGEN_STRONG_INLINE Scalar *data()
217  { return m_storage.data(); }
218 
235  EIGEN_STRONG_INLINE void resize(Index nbRows, Index nbCols)
236  {
237  eigen_assert( EIGEN_IMPLIES(RowsAtCompileTime!=Dynamic,nbRows==RowsAtCompileTime)
238  && EIGEN_IMPLIES(ColsAtCompileTime!=Dynamic,nbCols==ColsAtCompileTime)
239  && EIGEN_IMPLIES(RowsAtCompileTime==Dynamic && MaxRowsAtCompileTime!=Dynamic,nbRows<=MaxRowsAtCompileTime)
240  && EIGEN_IMPLIES(ColsAtCompileTime==Dynamic && MaxColsAtCompileTime!=Dynamic,nbCols<=MaxColsAtCompileTime)
241  && nbRows>=0 && nbCols>=0 && "Invalid sizes when resizing a matrix or array.");
242  internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(nbRows, nbCols);
243  #ifdef EIGEN_INITIALIZE_COEFFS
244  Index size = nbRows*nbCols;
245  bool size_changed = size != this->size();
246  m_storage.resize(size, nbRows, nbCols);
247  if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
248  #else
249  internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(nbRows, nbCols);
250  m_storage.resize(nbRows*nbCols, nbRows, nbCols);
251  #endif
252  }
253 
265  inline void resize(Index size)
266  {
267  EIGEN_STATIC_ASSERT_VECTOR_ONLY(PlainObjectBase)
268  eigen_assert(((SizeAtCompileTime == Dynamic && (MaxSizeAtCompileTime==Dynamic || size<=MaxSizeAtCompileTime)) || SizeAtCompileTime == size) && size>=0);
269  #ifdef EIGEN_INITIALIZE_COEFFS
270  bool size_changed = size != this->size();
271  #endif
272  if(RowsAtCompileTime == 1)
273  m_storage.resize(size, 1, size);
274  else
275  m_storage.resize(size, size, 1);
276  #ifdef EIGEN_INITIALIZE_COEFFS
277  if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
278  #endif
279  }
280 
289  inline void resize(NoChange_t, Index nbCols)
290  {
291  resize(rows(), nbCols);
292  }
293 
302  inline void resize(Index nbRows, NoChange_t)
303  {
304  resize(nbRows, cols());
305  }
306 
314  template<typename OtherDerived>
315  EIGEN_STRONG_INLINE void resizeLike(const EigenBase<OtherDerived>& _other)
316  {
317  const OtherDerived& other = _other.derived();
318  internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(other.rows(), other.cols());
319  const Index othersize = other.rows()*other.cols();
320  if(RowsAtCompileTime == 1)
321  {
322  eigen_assert(other.rows() == 1 || other.cols() == 1);
323  resize(1, othersize);
324  }
325  else if(ColsAtCompileTime == 1)
326  {
327  eigen_assert(other.rows() == 1 || other.cols() == 1);
328  resize(othersize, 1);
329  }
330  else resize(other.rows(), other.cols());
331  }
332 
342  EIGEN_STRONG_INLINE void conservativeResize(Index nbRows, Index nbCols)
343  {
344  internal::conservative_resize_like_impl<Derived>::run(*this, nbRows, nbCols);
345  }
346 
354  EIGEN_STRONG_INLINE void conservativeResize(Index nbRows, NoChange_t)
355  {
356  // Note: see the comment in conservativeResize(Index,Index)
357  conservativeResize(nbRows, cols());
358  }
359 
367  EIGEN_STRONG_INLINE void conservativeResize(NoChange_t, Index nbCols)
368  {
369  // Note: see the comment in conservativeResize(Index,Index)
370  conservativeResize(rows(), nbCols);
371  }
372 
381  EIGEN_STRONG_INLINE void conservativeResize(Index size)
382  {
383  internal::conservative_resize_like_impl<Derived>::run(*this, size);
384  }
385 
395  template<typename OtherDerived>
396  EIGEN_STRONG_INLINE void conservativeResizeLike(const DenseBase<OtherDerived>& other)
397  {
398  internal::conservative_resize_like_impl<Derived,OtherDerived>::run(*this, other);
399  }
400 
404  EIGEN_STRONG_INLINE Derived& operator=(const PlainObjectBase& other)
405  {
406  return _set(other);
407  }
408 
410  template<typename OtherDerived>
411  EIGEN_STRONG_INLINE Derived& lazyAssign(const DenseBase<OtherDerived>& other)
412  {
413  _resize_to_match(other);
414  return Base::lazyAssign(other.derived());
415  }
416 
417  template<typename OtherDerived>
418  EIGEN_STRONG_INLINE Derived& operator=(const ReturnByValue<OtherDerived>& func)
419  {
420  resize(func.rows(), func.cols());
421  return Base::operator=(func);
422  }
423 
424  EIGEN_STRONG_INLINE PlainObjectBase() : m_storage()
425  {
426 // _check_template_params();
427 // EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
428  }
429 
430 #ifndef EIGEN_PARSED_BY_DOXYGEN
431  // FIXME is it still needed ?
433  PlainObjectBase(internal::constructor_without_unaligned_array_assert)
434  : m_storage(internal::constructor_without_unaligned_array_assert())
435  {
436 // _check_template_params(); EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
437  }
438 #endif
439 
440  EIGEN_STRONG_INLINE PlainObjectBase(Index a_size, Index nbRows, Index nbCols)
441  : m_storage(a_size, nbRows, nbCols)
442  {
443 // _check_template_params();
444 // EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
445  }
446 
449  template<typename OtherDerived>
450  EIGEN_STRONG_INLINE Derived& operator=(const EigenBase<OtherDerived> &other)
451  {
452  _resize_to_match(other);
453  Base::operator=(other.derived());
454  return this->derived();
455  }
456 
458  template<typename OtherDerived>
459  EIGEN_STRONG_INLINE PlainObjectBase(const EigenBase<OtherDerived> &other)
460  : m_storage(other.derived().rows() * other.derived().cols(), other.derived().rows(), other.derived().cols())
461  {
462  _check_template_params();
463  internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(other.derived().rows(), other.derived().cols());
464  Base::operator=(other.derived());
465  }
466 
475  static inline ConstMapType Map(const Scalar* data)
476  { return ConstMapType(data); }
477  static inline MapType Map(Scalar* data)
478  { return MapType(data); }
479  static inline ConstMapType Map(const Scalar* data, Index size)
480  { return ConstMapType(data, size); }
481  static inline MapType Map(Scalar* data, Index size)
482  { return MapType(data, size); }
483  static inline ConstMapType Map(const Scalar* data, Index rows, Index cols)
484  { return ConstMapType(data, rows, cols); }
485  static inline MapType Map(Scalar* data, Index rows, Index cols)
486  { return MapType(data, rows, cols); }
487 
488  static inline ConstAlignedMapType MapAligned(const Scalar* data)
489  { return ConstAlignedMapType(data); }
490  static inline AlignedMapType MapAligned(Scalar* data)
491  { return AlignedMapType(data); }
492  static inline ConstAlignedMapType MapAligned(const Scalar* data, Index size)
493  { return ConstAlignedMapType(data, size); }
494  static inline AlignedMapType MapAligned(Scalar* data, Index size)
495  { return AlignedMapType(data, size); }
496  static inline ConstAlignedMapType MapAligned(const Scalar* data, Index rows, Index cols)
497  { return ConstAlignedMapType(data, rows, cols); }
498  static inline AlignedMapType MapAligned(Scalar* data, Index rows, Index cols)
499  { return AlignedMapType(data, rows, cols); }
500 
501  template<int Outer, int Inner>
502  static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, const Stride<Outer, Inner>& stride)
503  { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, stride); }
504  template<int Outer, int Inner>
505  static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, const Stride<Outer, Inner>& stride)
506  { return typename StridedMapType<Stride<Outer, Inner> >::type(data, stride); }
507  template<int Outer, int Inner>
508  static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, Index size, const Stride<Outer, Inner>& stride)
509  { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, size, stride); }
510  template<int Outer, int Inner>
511  static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, Index size, const Stride<Outer, Inner>& stride)
512  { return typename StridedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
513  template<int Outer, int Inner>
514  static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
515  { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
516  template<int Outer, int Inner>
517  static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
518  { return typename StridedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
519 
520  template<int Outer, int Inner>
521  static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, const Stride<Outer, Inner>& stride)
522  { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, stride); }
523  template<int Outer, int Inner>
524  static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, const Stride<Outer, Inner>& stride)
525  { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, stride); }
526  template<int Outer, int Inner>
527  static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, Index size, const Stride<Outer, Inner>& stride)
528  { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
529  template<int Outer, int Inner>
530  static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, Index size, const Stride<Outer, Inner>& stride)
531  { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
532  template<int Outer, int Inner>
533  static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
534  { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
535  template<int Outer, int Inner>
536  static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
537  { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
539 
540  using Base::setConstant;
541  Derived& setConstant(Index size, const Scalar& value);
542  Derived& setConstant(Index rows, Index cols, const Scalar& value);
543 
544  using Base::setZero;
545  Derived& setZero(Index size);
546  Derived& setZero(Index rows, Index cols);
547 
548  using Base::setOnes;
549  Derived& setOnes(Index size);
550  Derived& setOnes(Index rows, Index cols);
551 
552  using Base::setRandom;
553  Derived& setRandom(Index size);
554  Derived& setRandom(Index rows, Index cols);
555 
556  #ifdef EIGEN_PLAINOBJECTBASE_PLUGIN
557  #include EIGEN_PLAINOBJECTBASE_PLUGIN
558  #endif
559 
560  protected:
568  template<typename OtherDerived>
569  EIGEN_STRONG_INLINE void _resize_to_match(const EigenBase<OtherDerived>& other)
570  {
571  #ifdef EIGEN_NO_AUTOMATIC_RESIZING
572  eigen_assert((this->size()==0 || (IsVectorAtCompileTime ? (this->size() == other.size())
573  : (rows() == other.rows() && cols() == other.cols())))
574  && "Size mismatch. Automatic resizing is disabled because EIGEN_NO_AUTOMATIC_RESIZING is defined");
575  EIGEN_ONLY_USED_FOR_DEBUG(other);
576  #else
577  resizeLike(other);
578  #endif
579  }
580 
595  template<typename OtherDerived>
596  EIGEN_STRONG_INLINE Derived& _set(const DenseBase<OtherDerived>& other)
597  {
598  _set_selector(other.derived(), typename internal::conditional<static_cast<bool>(int(OtherDerived::Flags) & EvalBeforeAssigningBit), internal::true_type, internal::false_type>::type());
599  return this->derived();
600  }
601 
602  template<typename OtherDerived>
603  EIGEN_STRONG_INLINE void _set_selector(const OtherDerived& other, const internal::true_type&) { _set_noalias(other.eval()); }
604 
605  template<typename OtherDerived>
606  EIGEN_STRONG_INLINE void _set_selector(const OtherDerived& other, const internal::false_type&) { _set_noalias(other); }
607 
613  template<typename OtherDerived>
614  EIGEN_STRONG_INLINE Derived& _set_noalias(const DenseBase<OtherDerived>& other)
615  {
616  // I don't think we need this resize call since the lazyAssign will anyways resize
617  // and lazyAssign will be called by the assign selector.
618  //_resize_to_match(other);
619  // the 'false' below means to enforce lazy evaluation. We don't use lazyAssign() because
620  // it wouldn't allow to copy a row-vector into a column-vector.
621  return internal::assign_selector<Derived,OtherDerived,false>::run(this->derived(), other.derived());
622  }
623 
624  template<typename T0, typename T1>
625  EIGEN_STRONG_INLINE void _init2(Index nbRows, Index nbCols, typename internal::enable_if<Base::SizeAtCompileTime!=2,T0>::type* = 0)
626  {
627  EIGEN_STATIC_ASSERT(bool(NumTraits<T0>::IsInteger) &&
628  bool(NumTraits<T1>::IsInteger),
629  FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
630  resize(nbRows,nbCols);
631  }
632  template<typename T0, typename T1>
633  EIGEN_STRONG_INLINE void _init2(const Scalar& val0, const Scalar& val1, typename internal::enable_if<Base::SizeAtCompileTime==2,T0>::type* = 0)
634  {
635  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
636  m_storage.data()[0] = val0;
637  m_storage.data()[1] = val1;
638  }
639 
640  template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers>
641  friend struct internal::matrix_swap_impl;
642 
646  template<typename OtherDerived>
647  void _swap(DenseBase<OtherDerived> const & other)
648  {
649  enum { SwapPointers = internal::is_same<Derived, OtherDerived>::value && Base::SizeAtCompileTime==Dynamic };
650  internal::matrix_swap_impl<Derived, OtherDerived, bool(SwapPointers)>::run(this->derived(), other.const_cast_derived());
651  }
652 
653  public:
654 #ifndef EIGEN_PARSED_BY_DOXYGEN
655  static EIGEN_STRONG_INLINE void _check_template_params()
656  {
657  EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, (Options&RowMajor)==RowMajor)
658  && EIGEN_IMPLIES(MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1, (Options&RowMajor)==0)
659  && ((RowsAtCompileTime == Dynamic) || (RowsAtCompileTime >= 0))
660  && ((ColsAtCompileTime == Dynamic) || (ColsAtCompileTime >= 0))
661  && ((MaxRowsAtCompileTime == Dynamic) || (MaxRowsAtCompileTime >= 0))
662  && ((MaxColsAtCompileTime == Dynamic) || (MaxColsAtCompileTime >= 0))
663  && (MaxRowsAtCompileTime == RowsAtCompileTime || RowsAtCompileTime==Dynamic)
664  && (MaxColsAtCompileTime == ColsAtCompileTime || ColsAtCompileTime==Dynamic)
665  && (Options & (DontAlign|RowMajor)) == Options),
666  INVALID_MATRIX_TEMPLATE_PARAMETERS)
667  }
668 #endif
669 
670 private:
671  enum { ThisConstantIsPrivateInPlainObjectBase };
672 };
673 
674 namespace internal {
675 
676 template <typename Derived, typename OtherDerived, bool IsVector>
677 struct conservative_resize_like_impl
678 {
679  typedef typename Derived::Index Index;
680  static void run(DenseBase<Derived>& _this, Index rows, Index cols)
681  {
682  if (_this.rows() == rows && _this.cols() == cols) return;
683  EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
684 
685  if ( ( Derived::IsRowMajor && _this.cols() == cols) || // row-major and we change only the number of rows
686  (!Derived::IsRowMajor && _this.rows() == rows) ) // column-major and we change only the number of columns
687  {
688  internal::check_rows_cols_for_overflow<Derived::MaxSizeAtCompileTime>::run(rows, cols);
689  _this.derived().m_storage.conservativeResize(rows*cols,rows,cols);
690  }
691  else
692  {
693  // The storage order does not allow us to use reallocation.
694  typename Derived::PlainObject tmp(rows,cols);
695  const Index common_rows = (std::min)(rows, _this.rows());
696  const Index common_cols = (std::min)(cols, _this.cols());
697  tmp.block(0,0,common_rows,common_cols) = _this.block(0,0,common_rows,common_cols);
698  _this.derived().swap(tmp);
699  }
700  }
701 
702  static void run(DenseBase<Derived>& _this, const DenseBase<OtherDerived>& other)
703  {
704  if (_this.rows() == other.rows() && _this.cols() == other.cols()) return;
705 
706  // Note: Here is space for improvement. Basically, for conservativeResize(Index,Index),
707  // neither RowsAtCompileTime or ColsAtCompileTime must be Dynamic. If only one of the
708  // dimensions is dynamic, one could use either conservativeResize(Index rows, NoChange_t) or
709  // conservativeResize(NoChange_t, Index cols). For these methods new static asserts like
710  // EIGEN_STATIC_ASSERT_DYNAMIC_ROWS and EIGEN_STATIC_ASSERT_DYNAMIC_COLS would be good.
711  EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
712  EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(OtherDerived)
713 
714  if ( ( Derived::IsRowMajor && _this.cols() == other.cols()) || // row-major and we change only the number of rows
715  (!Derived::IsRowMajor && _this.rows() == other.rows()) ) // column-major and we change only the number of columns
716  {
717  const Index new_rows = other.rows() - _this.rows();
718  const Index new_cols = other.cols() - _this.cols();
719  _this.derived().m_storage.conservativeResize(other.size(),other.rows(),other.cols());
720  if (new_rows>0)
721  _this.bottomRightCorner(new_rows, other.cols()) = other.bottomRows(new_rows);
722  else if (new_cols>0)
723  _this.bottomRightCorner(other.rows(), new_cols) = other.rightCols(new_cols);
724  }
725  else
726  {
727  // The storage order does not allow us to use reallocation.
728  typename Derived::PlainObject tmp(other);
729  const Index common_rows = (std::min)(tmp.rows(), _this.rows());
730  const Index common_cols = (std::min)(tmp.cols(), _this.cols());
731  tmp.block(0,0,common_rows,common_cols) = _this.block(0,0,common_rows,common_cols);
732  _this.derived().swap(tmp);
733  }
734  }
735 };
736 
737 // Here, the specialization for vectors inherits from the general matrix case
738 // to allow calling .conservativeResize(rows,cols) on vectors.
739 template <typename Derived, typename OtherDerived>
740 struct conservative_resize_like_impl<Derived,OtherDerived,true>
741  : conservative_resize_like_impl<Derived,OtherDerived,false>
742 {
743  using conservative_resize_like_impl<Derived,OtherDerived,false>::run;
744 
745  typedef typename Derived::Index Index;
746  static void run(DenseBase<Derived>& _this, Index size)
747  {
748  const Index new_rows = Derived::RowsAtCompileTime==1 ? 1 : size;
749  const Index new_cols = Derived::RowsAtCompileTime==1 ? size : 1;
750  _this.derived().m_storage.conservativeResize(size,new_rows,new_cols);
751  }
752 
753  static void run(DenseBase<Derived>& _this, const DenseBase<OtherDerived>& other)
754  {
755  if (_this.rows() == other.rows() && _this.cols() == other.cols()) return;
756 
757  const Index num_new_elements = other.size() - _this.size();
758 
759  const Index new_rows = Derived::RowsAtCompileTime==1 ? 1 : other.rows();
760  const Index new_cols = Derived::RowsAtCompileTime==1 ? other.cols() : 1;
761  _this.derived().m_storage.conservativeResize(other.size(),new_rows,new_cols);
762 
763  if (num_new_elements > 0)
764  _this.tail(num_new_elements) = other.tail(num_new_elements);
765  }
766 };
767 
768 template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers>
769 struct matrix_swap_impl
770 {
771  static inline void run(MatrixTypeA& a, MatrixTypeB& b)
772  {
773  a.base().swap(b);
774  }
775 };
776 
777 template<typename MatrixTypeA, typename MatrixTypeB>
778 struct matrix_swap_impl<MatrixTypeA, MatrixTypeB, true>
779 {
780  static inline void run(MatrixTypeA& a, MatrixTypeB& b)
781  {
782  static_cast<typename MatrixTypeA::Base&>(a).m_storage.swap(static_cast<typename MatrixTypeB::Base&>(b).m_storage);
783  }
784 };
785 
786 } // end namespace internal
787 
788 } // end namespace Eigen
789 
790 #endif // EIGEN_DENSESTORAGEBASE_H
Derived & setOnes(Index size)
Definition: CwiseNullaryOp.h:641
const Scalar * data() const
Definition: PlainObjectBase.h:212
Derived & operator=(const EigenBase< OtherDerived > &other)
Definition: PlainObjectBase.h:450
Derived & lazyAssign(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:411
Definition: Constants.h:270
A matrix or vector expression mapping an existing array of data.
Definition: Map.h:104
void conservativeResize(Index size)
Definition: PlainObjectBase.h:381
Holds information about the various numeric (i.e. scalar) types allowed by Eigen. ...
Definition: NumTraits.h:88
const int Dynamic
Definition: Constants.h:21
Base class for all dense matrices, vectors, and arrays.
Definition: DenseBase.h:41
void resize(Index size)
Definition: PlainObjectBase.h:265
Scalar * data()
Definition: PlainObjectBase.h:216
Definition: EigenBase.h:26
void conservativeResizeLike(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:396
void conservativeResize(Index nbRows, Index nbCols)
Definition: PlainObjectBase.h:342
Derived & setRandom(Index size)
Definition: Random.h:126
void resize(Index nbRows, NoChange_t)
Definition: PlainObjectBase.h:302
Derived & derived()
Definition: EigenBase.h:34
void conservativeResize(Index nbRows, NoChange_t)
Definition: PlainObjectBase.h:354
Dense storage base class for matrices and arrays.
Definition: PlainObjectBase.h:85
Derived & setConstant(Index size, const Scalar &value)
Definition: CwiseNullaryOp.h:348
Derived & _set(const DenseBase< OtherDerived > &other)
Copies the value of the expression other into *this with automatic resizing.
Definition: PlainObjectBase.h:596
internal::traits< Derived >::Index Index
The type of indices.
Definition: DenseBase.h:61
const unsigned int EvalBeforeAssigningBit
Definition: Constants.h:63
Derived & operator=(const PlainObjectBase &other)
Definition: PlainObjectBase.h:404
const unsigned int RowMajorBit
Definition: Constants.h:53
void resize(Index nbRows, Index nbCols)
Definition: PlainObjectBase.h:235
void resizeLike(const EigenBase< OtherDerived > &_other)
Definition: PlainObjectBase.h:315
const unsigned int AlignedBit
Definition: Constants.h:147
Definition: Constants.h:266
void resize(NoChange_t, Index nbCols)
Definition: PlainObjectBase.h:289
PlainObjectBase(const EigenBase< OtherDerived > &other)
Definition: PlainObjectBase.h:459
void conservativeResize(NoChange_t, Index nbCols)
Definition: PlainObjectBase.h:367
Derived & setZero(Index size)
Definition: CwiseNullaryOp.h:515