Please, help us to better know about our user community by answering the following short survey: https://forms.gle/wpyrxWi18ox9Z5ae9
Eigen  3.4.99 (git rev 199c5f2b47eb1f8e5a2d20e60f07e97cd95a6ba6)
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 = (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)
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 
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>
96 #else
97 template<typename Derived>
98 class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
99 #endif
100 {
101  public:
102  enum { Options = internal::traits<Derived>::Options };
103  typedef typename internal::dense_xpr_base<Derived>::type Base;
104 
105  typedef typename internal::traits<Derived>::StorageKind StorageKind;
106  typedef typename internal::traits<Derived>::Scalar Scalar;
107 
108  typedef typename internal::packet_traits<Scalar>::type PacketScalar;
109  typedef typename NumTraits<Scalar>::Real RealScalar;
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:
139  DenseStorage<Scalar, Base::MaxSizeAtCompileTime, Base::RowsAtCompileTime, Base::ColsAtCompileTime, Options> m_storage;
140 
141  public:
142  enum { NeedsToAlign = (SizeAtCompileTime != Dynamic) && (internal::traits<Derived>::Alignment>0) };
143  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign)
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
196  EIGEN_STRONG_INLINE Scalar& coeffRef(Index index)
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
279  EIGEN_STRONG_INLINE void resize(Index rows, Index cols)
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.");
286  internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(rows, cols);
287  #ifdef EIGEN_INITIALIZE_COEFFS
288  Index size = rows*cols;
289  bool size_changed = size != this->size();
290  m_storage.resize(size, rows, cols);
291  if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
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  {
311  EIGEN_STATIC_ASSERT_VECTOR_ONLY(PlainObjectBase)
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
321  if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
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
362  EIGEN_STRONG_INLINE void resizeLike(const EigenBase<OtherDerived>& _other)
363  {
364  const OtherDerived& other = _other.derived();
365  internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(other.rows(), other.cols());
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
390  EIGEN_STRONG_INLINE void conservativeResize(Index rows, Index cols)
391  {
392  internal::conservative_resize_like_impl<Derived>::run(*this, rows, cols);
393  }
394 
402  EIGEN_DEVICE_FUNC
403  EIGEN_STRONG_INLINE void conservativeResize(Index rows, NoChange_t)
404  {
405  // Note: see the comment in conservativeResize(Index,Index)
406  conservativeResize(rows, cols());
407  }
408 
416  EIGEN_DEVICE_FUNC
417  EIGEN_STRONG_INLINE void conservativeResize(NoChange_t, Index cols)
418  {
419  // Note: see the comment in conservativeResize(Index,Index)
420  conservativeResize(rows(), cols);
421  }
422 
431  EIGEN_DEVICE_FUNC
432  EIGEN_STRONG_INLINE void conservativeResize(Index size)
433  {
434  internal::conservative_resize_like_impl<Derived>::run(*this, size);
435  }
436 
446  template<typename OtherDerived>
447  EIGEN_DEVICE_FUNC
448  EIGEN_STRONG_INLINE void conservativeResizeLike(const DenseBase<OtherDerived>& other)
449  {
450  internal::conservative_resize_like_impl<Derived,OtherDerived>::run(*this, other);
451  }
452 
456  EIGEN_DEVICE_FUNC
457  EIGEN_STRONG_INLINE Derived& operator=(const PlainObjectBase& other)
458  {
459  return _set(other);
460  }
461 
463  template<typename OtherDerived>
464  EIGEN_DEVICE_FUNC
465  EIGEN_STRONG_INLINE Derived& lazyAssign(const DenseBase<OtherDerived>& other)
466  {
467  _resize_to_match(other);
468  return Base::lazyAssign(other.derived());
469  }
470 
471  template<typename OtherDerived>
472  EIGEN_DEVICE_FUNC
473  EIGEN_STRONG_INLINE Derived& operator=(const ReturnByValue<OtherDerived>& 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
484  EIGEN_STRONG_INLINE PlainObjectBase() : m_storage()
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
494  explicit PlainObjectBase(internal::constructor_without_unaligned_array_assert)
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
503  PlainObjectBase(PlainObjectBase&& other) EIGEN_NOEXCEPT
504  : m_storage( std::move(other.m_storage) )
505  {
506  }
507 
508  EIGEN_DEVICE_FUNC
509  PlainObjectBase& operator=(PlainObjectBase&& other) EIGEN_NOEXCEPT
510  {
511  using std::swap;
512  swap(m_storage, other.m_storage);
513  return *this;
514  }
515 #endif
516 
518  EIGEN_DEVICE_FUNC
519  EIGEN_STRONG_INLINE PlainObjectBase(const PlainObjectBase& other)
520  : Base(), m_storage(other.m_storage) { }
521  EIGEN_DEVICE_FUNC
522  EIGEN_STRONG_INLINE PlainObjectBase(Index size, Index rows, Index cols)
523  : m_storage(size, rows, cols)
524  {
525 // _check_template_params();
526 // EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
527  }
528 
529  #if EIGEN_HAS_CXX11
540  template <typename... ArgTypes>
541  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
542  PlainObjectBase(const Scalar& a0, const Scalar& a1, const Scalar& a2, const Scalar& a3, const ArgTypes&... args)
543  : m_storage()
544  {
545  _check_template_params();
546  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, sizeof...(args) + 4);
547  m_storage.data()[0] = a0;
548  m_storage.data()[1] = a1;
549  m_storage.data()[2] = a2;
550  m_storage.data()[3] = a3;
551  int i = 4;
552  auto x = {(m_storage.data()[i++] = args, 0)...};
553  static_cast<void>(x);
554  }
555 
559  EIGEN_DEVICE_FUNC
560  explicit EIGEN_STRONG_INLINE PlainObjectBase(const std::initializer_list<std::initializer_list<Scalar>>& list)
561  : m_storage()
562  {
563  _check_template_params();
564 
565  size_t list_size = 0;
566  if (list.begin() != list.end()) {
567  list_size = list.begin()->size();
568  }
569 
570  // This is to allow syntax like VectorXi {{1, 2, 3, 4}}
571  if (ColsAtCompileTime == 1 && list.size() == 1) {
572  eigen_assert(list_size == static_cast<size_t>(RowsAtCompileTime) || RowsAtCompileTime == Dynamic);
573  resize(list_size, ColsAtCompileTime);
574  std::copy(list.begin()->begin(), list.begin()->end(), m_storage.data());
575  } else {
576  eigen_assert(list.size() == static_cast<size_t>(RowsAtCompileTime) || RowsAtCompileTime == Dynamic);
577  eigen_assert(list_size == static_cast<size_t>(ColsAtCompileTime) || ColsAtCompileTime == Dynamic);
578  resize(list.size(), list_size);
579 
580  Index row_index = 0;
581  for (const std::initializer_list<Scalar>& row : list) {
582  eigen_assert(list_size == row.size());
583  Index col_index = 0;
584  for (const Scalar& e : row) {
585  coeffRef(row_index, col_index) = e;
586  ++col_index;
587  }
588  ++row_index;
589  }
590  }
591  }
592  #endif // end EIGEN_HAS_CXX11
593 
595  template<typename OtherDerived>
596  EIGEN_DEVICE_FUNC
597  EIGEN_STRONG_INLINE PlainObjectBase(const DenseBase<OtherDerived> &other)
598  : m_storage()
599  {
600  _check_template_params();
601  resizeLike(other);
602  _set_noalias(other);
603  }
604 
606  template<typename OtherDerived>
607  EIGEN_DEVICE_FUNC
608  EIGEN_STRONG_INLINE PlainObjectBase(const EigenBase<OtherDerived> &other)
609  : m_storage()
610  {
611  _check_template_params();
612  resizeLike(other);
613  *this = other.derived();
614  }
616  template<typename OtherDerived>
617  EIGEN_DEVICE_FUNC
618  EIGEN_STRONG_INLINE PlainObjectBase(const ReturnByValue<OtherDerived>& other)
619  {
620  _check_template_params();
621  // FIXME this does not automatically transpose vectors if necessary
622  resize(other.rows(), other.cols());
623  other.evalTo(this->derived());
624  }
625 
626  public:
627 
631  template<typename OtherDerived>
632  EIGEN_DEVICE_FUNC
633  EIGEN_STRONG_INLINE Derived& operator=(const EigenBase<OtherDerived> &other)
634  {
635  _resize_to_match(other);
636  Base::operator=(other.derived());
637  return this->derived();
638  }
639 
652  static inline ConstMapType Map(const Scalar* data)
653  { return ConstMapType(data); }
654  static inline MapType Map(Scalar* data)
655  { return MapType(data); }
656  static inline ConstMapType Map(const Scalar* data, Index size)
657  { return ConstMapType(data, size); }
658  static inline MapType Map(Scalar* data, Index size)
659  { return MapType(data, size); }
660  static inline ConstMapType Map(const Scalar* data, Index rows, Index cols)
661  { return ConstMapType(data, rows, cols); }
662  static inline MapType Map(Scalar* data, Index rows, Index cols)
663  { return MapType(data, rows, cols); }
664 
665  static inline ConstAlignedMapType MapAligned(const Scalar* data)
666  { return ConstAlignedMapType(data); }
667  static inline AlignedMapType MapAligned(Scalar* data)
668  { return AlignedMapType(data); }
669  static inline ConstAlignedMapType MapAligned(const Scalar* data, Index size)
670  { return ConstAlignedMapType(data, size); }
671  static inline AlignedMapType MapAligned(Scalar* data, Index size)
672  { return AlignedMapType(data, size); }
673  static inline ConstAlignedMapType MapAligned(const Scalar* data, Index rows, Index cols)
674  { return ConstAlignedMapType(data, rows, cols); }
675  static inline AlignedMapType MapAligned(Scalar* data, Index rows, Index cols)
676  { return AlignedMapType(data, rows, cols); }
677 
678  template<int Outer, int Inner>
679  static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, const Stride<Outer, Inner>& stride)
680  { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, stride); }
681  template<int Outer, int Inner>
682  static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, const Stride<Outer, Inner>& stride)
683  { return typename StridedMapType<Stride<Outer, Inner> >::type(data, stride); }
684  template<int Outer, int Inner>
685  static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, Index size, const Stride<Outer, Inner>& stride)
686  { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, size, stride); }
687  template<int Outer, int Inner>
688  static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, Index size, const Stride<Outer, Inner>& stride)
689  { return typename StridedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
690  template<int Outer, int Inner>
691  static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
692  { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
693  template<int Outer, int Inner>
694  static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
695  { return typename StridedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
696 
697  template<int Outer, int Inner>
698  static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, const Stride<Outer, Inner>& stride)
699  { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, stride); }
700  template<int Outer, int Inner>
701  static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, const Stride<Outer, Inner>& stride)
702  { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, stride); }
703  template<int Outer, int Inner>
704  static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, Index size, const Stride<Outer, Inner>& stride)
705  { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
706  template<int Outer, int Inner>
707  static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, Index size, const Stride<Outer, Inner>& stride)
708  { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
709  template<int Outer, int Inner>
710  static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
711  { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
712  template<int Outer, int Inner>
713  static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
714  { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
716 
717  using Base::setConstant;
718  EIGEN_DEVICE_FUNC Derived& setConstant(Index size, const Scalar& val);
719  EIGEN_DEVICE_FUNC Derived& setConstant(Index rows, Index cols, const Scalar& val);
720  EIGEN_DEVICE_FUNC Derived& setConstant(NoChange_t, Index cols, const Scalar& val);
721  EIGEN_DEVICE_FUNC Derived& setConstant(Index rows, NoChange_t, const Scalar& val);
722 
723  using Base::setZero;
724  EIGEN_DEVICE_FUNC Derived& setZero(Index size);
725  EIGEN_DEVICE_FUNC Derived& setZero(Index rows, Index cols);
726  EIGEN_DEVICE_FUNC Derived& setZero(NoChange_t, Index cols);
727  EIGEN_DEVICE_FUNC Derived& setZero(Index rows, NoChange_t);
728 
729  using Base::setOnes;
730  EIGEN_DEVICE_FUNC Derived& setOnes(Index size);
731  EIGEN_DEVICE_FUNC Derived& setOnes(Index rows, Index cols);
732  EIGEN_DEVICE_FUNC Derived& setOnes(NoChange_t, Index cols);
733  EIGEN_DEVICE_FUNC Derived& setOnes(Index rows, NoChange_t);
734 
735  using Base::setRandom;
736  Derived& setRandom(Index size);
737  Derived& setRandom(Index rows, Index cols);
738  Derived& setRandom(NoChange_t, Index cols);
739  Derived& setRandom(Index rows, NoChange_t);
740 
741  #ifdef EIGEN_PLAINOBJECTBASE_PLUGIN
742  #include EIGEN_PLAINOBJECTBASE_PLUGIN
743  #endif
744 
745  protected:
753  template<typename OtherDerived>
754  EIGEN_DEVICE_FUNC
755  EIGEN_STRONG_INLINE void _resize_to_match(const EigenBase<OtherDerived>& other)
756  {
757  #ifdef EIGEN_NO_AUTOMATIC_RESIZING
758  eigen_assert((this->size()==0 || (IsVectorAtCompileTime ? (this->size() == other.size())
759  : (rows() == other.rows() && cols() == other.cols())))
760  && "Size mismatch. Automatic resizing is disabled because EIGEN_NO_AUTOMATIC_RESIZING is defined");
761  EIGEN_ONLY_USED_FOR_DEBUG(other);
762  #else
763  resizeLike(other);
764  #endif
765  }
766 
781  // aliasing is dealt once in internal::call_assignment
782  // so at this stage we have to assume aliasing... and resising has to be done later.
783  template<typename OtherDerived>
784  EIGEN_DEVICE_FUNC
785  EIGEN_STRONG_INLINE Derived& _set(const DenseBase<OtherDerived>& other)
786  {
787  internal::call_assignment(this->derived(), other.derived());
788  return this->derived();
789  }
790 
796  template<typename OtherDerived>
797  EIGEN_DEVICE_FUNC
798  EIGEN_STRONG_INLINE Derived& _set_noalias(const DenseBase<OtherDerived>& other)
799  {
800  // I don't think we need this resize call since the lazyAssign will anyways resize
801  // and lazyAssign will be called by the assign selector.
802  //_resize_to_match(other);
803  // the 'false' below means to enforce lazy evaluation. We don't use lazyAssign() because
804  // it wouldn't allow to copy a row-vector into a column-vector.
805  internal::call_assignment_no_alias(this->derived(), other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
806  return this->derived();
807  }
808 
809  template<typename T0, typename T1>
810  EIGEN_DEVICE_FUNC
811  EIGEN_STRONG_INLINE void _init2(Index rows, Index cols, typename internal::enable_if<Base::SizeAtCompileTime!=2,T0>::type* = 0)
812  {
813  const bool t0_is_integer_alike = internal::is_valid_index_type<T0>::value;
814  const bool t1_is_integer_alike = internal::is_valid_index_type<T1>::value;
815  EIGEN_STATIC_ASSERT(t0_is_integer_alike &&
816  t1_is_integer_alike,
817  FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
818  resize(rows,cols);
819  }
820 
821  template<typename T0, typename T1>
822  EIGEN_DEVICE_FUNC
823  EIGEN_STRONG_INLINE void _init2(const T0& val0, const T1& val1, typename internal::enable_if<Base::SizeAtCompileTime==2,T0>::type* = 0)
824  {
825  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
826  m_storage.data()[0] = Scalar(val0);
827  m_storage.data()[1] = Scalar(val1);
828  }
829 
830  template<typename T0, typename T1>
831  EIGEN_DEVICE_FUNC
832  EIGEN_STRONG_INLINE void _init2(const Index& val0, const Index& val1,
833  typename internal::enable_if< (!internal::is_same<Index,Scalar>::value)
834  && (internal::is_same<T0,Index>::value)
835  && (internal::is_same<T1,Index>::value)
836  && Base::SizeAtCompileTime==2,T1>::type* = 0)
837  {
838  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
839  m_storage.data()[0] = Scalar(val0);
840  m_storage.data()[1] = Scalar(val1);
841  }
842 
843  // The argument is convertible to the Index type and we either have a non 1x1 Matrix, or a dynamic-sized Array,
844  // then the argument is meant to be the size of the object.
845  template<typename T>
846  EIGEN_DEVICE_FUNC
847  EIGEN_STRONG_INLINE void _init1(Index size, typename internal::enable_if< (Base::SizeAtCompileTime!=1 || !internal::is_convertible<T, Scalar>::value)
848  && ((!internal::is_same<typename internal::traits<Derived>::XprKind,ArrayXpr>::value || Base::SizeAtCompileTime==Dynamic)),T>::type* = 0)
849  {
850  // NOTE MSVC 2008 complains if we directly put bool(NumTraits<T>::IsInteger) as the EIGEN_STATIC_ASSERT argument.
851  const bool is_integer_alike = internal::is_valid_index_type<T>::value;
852  EIGEN_UNUSED_VARIABLE(is_integer_alike);
853  EIGEN_STATIC_ASSERT(is_integer_alike,
854  FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
855  resize(size);
856  }
857 
858  // We have a 1x1 matrix/array => the argument is interpreted as the value of the unique coefficient (case where scalar type can be implicitly converted)
859  template<typename T>
860  EIGEN_DEVICE_FUNC
861  EIGEN_STRONG_INLINE void _init1(const Scalar& val0, typename internal::enable_if<Base::SizeAtCompileTime==1 && internal::is_convertible<T, Scalar>::value,T>::type* = 0)
862  {
863  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 1)
864  m_storage.data()[0] = val0;
865  }
866 
867  // 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)
868  template<typename T>
869  EIGEN_DEVICE_FUNC
870  EIGEN_STRONG_INLINE void _init1(const Index& val0,
871  typename internal::enable_if< (!internal::is_same<Index,Scalar>::value)
872  && (internal::is_same<Index,T>::value)
873  && Base::SizeAtCompileTime==1
874  && internal::is_convertible<T, Scalar>::value,T*>::type* = 0)
875  {
876  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 1)
877  m_storage.data()[0] = Scalar(val0);
878  }
879 
880  // Initialize a fixed size matrix from a pointer to raw data
881  template<typename T>
882  EIGEN_DEVICE_FUNC
883  EIGEN_STRONG_INLINE void _init1(const Scalar* data){
884  this->_set_noalias(ConstMapType(data));
885  }
886 
887  // Initialize an arbitrary matrix from a dense expression
888  template<typename T, typename OtherDerived>
889  EIGEN_DEVICE_FUNC
890  EIGEN_STRONG_INLINE void _init1(const DenseBase<OtherDerived>& other){
891  this->_set_noalias(other);
892  }
893 
894  // Initialize an arbitrary matrix from an object convertible to the Derived type.
895  template<typename T>
896  EIGEN_DEVICE_FUNC
897  EIGEN_STRONG_INLINE void _init1(const Derived& other){
898  this->_set_noalias(other);
899  }
900 
901  // Initialize an arbitrary matrix from a generic Eigen expression
902  template<typename T, typename OtherDerived>
903  EIGEN_DEVICE_FUNC
904  EIGEN_STRONG_INLINE void _init1(const EigenBase<OtherDerived>& other){
905  this->derived() = other;
906  }
907 
908  template<typename T, typename OtherDerived>
909  EIGEN_DEVICE_FUNC
910  EIGEN_STRONG_INLINE void _init1(const ReturnByValue<OtherDerived>& other)
911  {
912  resize(other.rows(), other.cols());
913  other.evalTo(this->derived());
914  }
915 
916  template<typename T, typename OtherDerived, int ColsAtCompileTime>
917  EIGEN_DEVICE_FUNC
918  EIGEN_STRONG_INLINE void _init1(const RotationBase<OtherDerived,ColsAtCompileTime>& r)
919  {
920  this->derived() = r;
921  }
922 
923  // For fixed-size Array<Scalar,...>
924  template<typename T>
925  EIGEN_DEVICE_FUNC
926  EIGEN_STRONG_INLINE void _init1(const Scalar& val0,
927  typename internal::enable_if< Base::SizeAtCompileTime!=Dynamic
928  && Base::SizeAtCompileTime!=1
929  && internal::is_convertible<T, Scalar>::value
930  && internal::is_same<typename internal::traits<Derived>::XprKind,ArrayXpr>::value,T>::type* = 0)
931  {
932  Base::setConstant(val0);
933  }
934 
935  // For fixed-size Array<Index,...>
936  template<typename T>
937  EIGEN_DEVICE_FUNC
938  EIGEN_STRONG_INLINE void _init1(const Index& val0,
939  typename internal::enable_if< (!internal::is_same<Index,Scalar>::value)
940  && (internal::is_same<Index,T>::value)
941  && Base::SizeAtCompileTime!=Dynamic
942  && Base::SizeAtCompileTime!=1
943  && internal::is_convertible<T, Scalar>::value
944  && internal::is_same<typename internal::traits<Derived>::XprKind,ArrayXpr>::value,T*>::type* = 0)
945  {
946  Base::setConstant(val0);
947  }
948 
949  template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers>
950  friend struct internal::matrix_swap_impl;
951 
952  public:
953 
954 #ifndef EIGEN_PARSED_BY_DOXYGEN
959  template<typename OtherDerived>
960  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
961  void swap(DenseBase<OtherDerived> & other)
962  {
963  enum { SwapPointers = internal::is_same<Derived, OtherDerived>::value && Base::SizeAtCompileTime==Dynamic };
964  internal::matrix_swap_impl<Derived, OtherDerived, bool(SwapPointers)>::run(this->derived(), other.derived());
965  }
966 
970  template<typename OtherDerived>
971  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
972  void swap(DenseBase<OtherDerived> const & other)
973  { Base::swap(other.derived()); }
974 
975  EIGEN_DEVICE_FUNC
976  static EIGEN_STRONG_INLINE void _check_template_params()
977  {
978  EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, (int(Options)&RowMajor)==RowMajor)
979  && EIGEN_IMPLIES(MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1, (int(Options)&RowMajor)==0)
980  && ((RowsAtCompileTime == Dynamic) || (RowsAtCompileTime >= 0))
981  && ((ColsAtCompileTime == Dynamic) || (ColsAtCompileTime >= 0))
982  && ((MaxRowsAtCompileTime == Dynamic) || (MaxRowsAtCompileTime >= 0))
983  && ((MaxColsAtCompileTime == Dynamic) || (MaxColsAtCompileTime >= 0))
984  && (MaxRowsAtCompileTime == RowsAtCompileTime || RowsAtCompileTime==Dynamic)
985  && (MaxColsAtCompileTime == ColsAtCompileTime || ColsAtCompileTime==Dynamic)
986  && (Options & (DontAlign|RowMajor)) == Options),
987  INVALID_MATRIX_TEMPLATE_PARAMETERS)
988  }
989 
990  enum { IsPlainObjectBase = 1 };
991 #endif
992 };
993 
994 namespace internal {
995 
996 template <typename Derived, typename OtherDerived, bool IsVector>
997 struct conservative_resize_like_impl
998 {
999  #if EIGEN_HAS_TYPE_TRAITS
1000  static const bool IsRelocatable = std::is_trivially_copyable<typename Derived::Scalar>::value;
1001  #else
1002  static const bool IsRelocatable = !NumTraits<typename Derived::Scalar>::RequireInitialization;
1003  #endif
1004  static void run(DenseBase<Derived>& _this, Index rows, Index cols)
1005  {
1006  if (_this.rows() == rows && _this.cols() == cols) return;
1007  EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
1008 
1009  if ( IsRelocatable
1010  && (( Derived::IsRowMajor && _this.cols() == cols) || // row-major and we change only the number of rows
1011  (!Derived::IsRowMajor && _this.rows() == rows) )) // column-major and we change only the number of columns
1012  {
1013  internal::check_rows_cols_for_overflow<Derived::MaxSizeAtCompileTime>::run(rows, cols);
1014  _this.derived().m_storage.conservativeResize(rows*cols,rows,cols);
1015  }
1016  else
1017  {
1018  // The storage order does not allow us to use reallocation.
1019  typename Derived::PlainObject tmp(rows,cols);
1020  const Index common_rows = numext::mini(rows, _this.rows());
1021  const Index common_cols = numext::mini(cols, _this.cols());
1022  tmp.block(0,0,common_rows,common_cols) = _this.block(0,0,common_rows,common_cols);
1023  _this.derived().swap(tmp);
1024  }
1025  }
1026 
1027  static void run(DenseBase<Derived>& _this, const DenseBase<OtherDerived>& other)
1028  {
1029  if (_this.rows() == other.rows() && _this.cols() == other.cols()) return;
1030 
1031  // Note: Here is space for improvement. Basically, for conservativeResize(Index,Index),
1032  // neither RowsAtCompileTime or ColsAtCompileTime must be Dynamic. If only one of the
1033  // dimensions is dynamic, one could use either conservativeResize(Index rows, NoChange_t) or
1034  // conservativeResize(NoChange_t, Index cols). For these methods new static asserts like
1035  // EIGEN_STATIC_ASSERT_DYNAMIC_ROWS and EIGEN_STATIC_ASSERT_DYNAMIC_COLS would be good.
1036  EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
1037  EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(OtherDerived)
1038 
1039  if ( IsRelocatable &&
1040  (( Derived::IsRowMajor && _this.cols() == other.cols()) || // row-major and we change only the number of rows
1041  (!Derived::IsRowMajor && _this.rows() == other.rows()) )) // column-major and we change only the number of columns
1042  {
1043  const Index new_rows = other.rows() - _this.rows();
1044  const Index new_cols = other.cols() - _this.cols();
1045  _this.derived().m_storage.conservativeResize(other.size(),other.rows(),other.cols());
1046  if (new_rows>0)
1047  _this.bottomRightCorner(new_rows, other.cols()) = other.bottomRows(new_rows);
1048  else if (new_cols>0)
1049  _this.bottomRightCorner(other.rows(), new_cols) = other.rightCols(new_cols);
1050  }
1051  else
1052  {
1053  // The storage order does not allow us to use reallocation.
1054  typename Derived::PlainObject tmp(other);
1055  const Index common_rows = numext::mini(tmp.rows(), _this.rows());
1056  const Index common_cols = numext::mini(tmp.cols(), _this.cols());
1057  tmp.block(0,0,common_rows,common_cols) = _this.block(0,0,common_rows,common_cols);
1058  _this.derived().swap(tmp);
1059  }
1060  }
1061 };
1062 
1063 // Here, the specialization for vectors inherits from the general matrix case
1064 // to allow calling .conservativeResize(rows,cols) on vectors.
1065 template <typename Derived, typename OtherDerived>
1066 struct conservative_resize_like_impl<Derived,OtherDerived,true>
1067  : conservative_resize_like_impl<Derived,OtherDerived,false>
1068 {
1069  typedef conservative_resize_like_impl<Derived,OtherDerived,false> Base;
1070  using Base::run;
1071  using Base::IsRelocatable;
1072 
1073  static void run(DenseBase<Derived>& _this, Index size)
1074  {
1075  const Index new_rows = Derived::RowsAtCompileTime==1 ? 1 : size;
1076  const Index new_cols = Derived::RowsAtCompileTime==1 ? size : 1;
1077  if(IsRelocatable)
1078  _this.derived().m_storage.conservativeResize(size,new_rows,new_cols);
1079  else
1080  Base::run(_this.derived(), new_rows, new_cols);
1081  }
1082 
1083  static void run(DenseBase<Derived>& _this, const DenseBase<OtherDerived>& other)
1084  {
1085  if (_this.rows() == other.rows() && _this.cols() == other.cols()) return;
1086 
1087  const Index num_new_elements = other.size() - _this.size();
1088 
1089  const Index new_rows = Derived::RowsAtCompileTime==1 ? 1 : other.rows();
1090  const Index new_cols = Derived::RowsAtCompileTime==1 ? other.cols() : 1;
1091  if(IsRelocatable)
1092  _this.derived().m_storage.conservativeResize(other.size(),new_rows,new_cols);
1093  else
1094  Base::run(_this.derived(), new_rows, new_cols);
1095 
1096  if (num_new_elements > 0)
1097  _this.tail(num_new_elements) = other.tail(num_new_elements);
1098  }
1099 };
1100 
1101 template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers>
1102 struct matrix_swap_impl
1103 {
1104  EIGEN_DEVICE_FUNC
1105  static EIGEN_STRONG_INLINE void run(MatrixTypeA& a, MatrixTypeB& b)
1106  {
1107  a.base().swap(b);
1108  }
1109 };
1110 
1111 template<typename MatrixTypeA, typename MatrixTypeB>
1112 struct matrix_swap_impl<MatrixTypeA, MatrixTypeB, true>
1113 {
1114  EIGEN_DEVICE_FUNC
1115  static inline void run(MatrixTypeA& a, MatrixTypeB& b)
1116  {
1117  static_cast<typename MatrixTypeA::Base&>(a).m_storage.swap(static_cast<typename MatrixTypeB::Base&>(b).m_storage);
1118  }
1119 };
1120 
1121 } // end namespace internal
1122 
1123 } // end namespace Eigen
1124 
1125 #endif // EIGEN_DENSESTORAGEBASE_H
Base class for all 1D and 2D array, and related expressions.
Definition: ArrayBase.h:41
General-purpose arrays with easy API for coefficient-wise operations.
Definition: Array.h:47
Base class for all dense matrices, vectors, and arrays.
Definition: DenseBase.h:47
Derived & derived()
Definition: EigenBase.h:46
A matrix or vector expression mapping an existing array of data.
Definition: Map.h:96
Base class for all dense matrices, vectors, and expressions.
Definition: MatrixBase.h:50
The matrix class, also used for vectors and row-vectors.
Definition: Matrix.h:180
Dense storage base class for matrices and arrays.
Definition: PlainObjectBase.h:100
const Scalar & coeffRef(Index rowId, Index colId) const
Definition: PlainObjectBase.h:204
Derived & _set(const DenseBase< OtherDerived > &other)
Copies the value of the expression other into *this with automatic resizing.
Definition: PlainObjectBase.h:785
void resize(NoChange_t, Index cols)
Definition: PlainObjectBase.h:334
static StridedConstMapType< Stride< Outer, Inner > >::type Map(const Scalar *data, Index rows, Index cols, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:691
static StridedMapType< Stride< Outer, Inner > >::type Map(Scalar *data, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:682
PlainObjectBase(const ReturnByValue< OtherDerived > &other)
Copy constructor with in-place evaluation.
Definition: PlainObjectBase.h:618
static StridedAlignedMapType< Stride< Outer, Inner > >::type MapAligned(Scalar *data, Index size, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:707
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)
Definition: PlainObjectBase.h:926
void _init2(const T0 &val0, const T1 &val1, typename internal::enable_if< Base::SizeAtCompileTime==2, T0 >::type *=0)
Definition: PlainObjectBase.h:823
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)
Definition: PlainObjectBase.h:938
void _resize_to_match(const EigenBase< OtherDerived > &other)
Definition: PlainObjectBase.h:755
static StridedConstAlignedMapType< Stride< Outer, Inner > >::type MapAligned(const Scalar *data, Index rows, Index cols, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:710
void _init1(const EigenBase< OtherDerived > &other)
Definition: PlainObjectBase.h:904
void conservativeResizeLike(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:448
void _init1(const RotationBase< OtherDerived, ColsAtCompileTime > &r)
Definition: PlainObjectBase.h:918
PlainObjectBase(const PlainObjectBase &other)
Definition: PlainObjectBase.h:519
const Scalar & coeffRef(Index index) const
Definition: PlainObjectBase.h:215
void _init2(Index rows, Index cols, typename internal::enable_if< Base::SizeAtCompileTime!=2, T0 >::type *=0)
Definition: PlainObjectBase.h:811
PlainObjectBase(const Scalar &a0, const Scalar &a1, const Scalar &a2, const Scalar &a3, const ArgTypes &... args)
Construct a row of column vector with fixed size from an arbitrary number of coefficients....
Definition: PlainObjectBase.h:542
Derived & setRandom(Index size)
Definition: Random.h:151
static AlignedMapType MapAligned(Scalar *data, Index size)
Definition: PlainObjectBase.h:671
void _init1(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:890
Derived & lazyAssign(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:465
void conservativeResize(Index rows, Index cols)
Definition: PlainObjectBase.h:390
Scalar & coeffRef(Index index)
Definition: PlainObjectBase.h:196
static ConstAlignedMapType MapAligned(const Scalar *data, Index size)
Definition: PlainObjectBase.h:669
PlainObjectBase(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:597
void conservativeResize(Index size)
Definition: PlainObjectBase.h:432
void _init1(const Scalar &val0, typename internal::enable_if< Base::SizeAtCompileTime==1 &&internal::is_convertible< T, Scalar >::value, T >::type *=0)
Definition: PlainObjectBase.h:861
Derived & setOnes(Index size)
Definition: CwiseNullaryOp.h:714
static ConstAlignedMapType MapAligned(const Scalar *data, Index rows, Index cols)
Definition: PlainObjectBase.h:673
void resize(Index size)
Definition: PlainObjectBase.h:309
void conservativeResize(Index rows, NoChange_t)
Definition: PlainObjectBase.h:403
static StridedConstMapType< Stride< Outer, Inner > >::type Map(const Scalar *data, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:679
PlainObjectBase(const EigenBase< OtherDerived > &other)
Definition: PlainObjectBase.h:608
static StridedConstAlignedMapType< Stride< Outer, Inner > >::type MapAligned(const Scalar *data, Index size, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:704
const Scalar & coeff(Index rowId, Index colId) const
Definition: PlainObjectBase.h:160
static AlignedMapType MapAligned(Scalar *data, Index rows, Index cols)
Definition: PlainObjectBase.h:675
Scalar & coeffRef(Index rowId, Index colId)
Definition: PlainObjectBase.h:183
void resize(Index rows, Index cols)
Definition: PlainObjectBase.h:279
static AlignedMapType MapAligned(Scalar *data)
Definition: PlainObjectBase.h:667
void _init1(const Scalar *data)
Definition: PlainObjectBase.h:883
void resizeLike(const EigenBase< OtherDerived > &_other)
Definition: PlainObjectBase.h:362
Derived & setConstant(Index size, const Scalar &val)
Definition: CwiseNullaryOp.h:361
void _init1(const ReturnByValue< OtherDerived > &other)
Definition: PlainObjectBase.h:910
static StridedConstAlignedMapType< Stride< Outer, Inner > >::type MapAligned(const Scalar *data, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:698
static StridedMapType< Stride< Outer, Inner > >::type Map(Scalar *data, Index size, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:688
static ConstMapType Map(const Scalar *data)
Definition: PlainObjectBase.h:652
static MapType Map(Scalar *data, Index size)
Definition: PlainObjectBase.h:658
void _init1(const Derived &other)
Definition: PlainObjectBase.h:897
static MapType Map(Scalar *data)
Definition: PlainObjectBase.h:654
PlainObjectBase(const std::initializer_list< std::initializer_list< Scalar >> &list)
Constructs a Matrix or Array and initializes it by elements given by an initializer list of initializ...
Definition: PlainObjectBase.h:560
static ConstMapType Map(const Scalar *data, Index size)
Definition: PlainObjectBase.h:656
static StridedAlignedMapType< Stride< Outer, Inner > >::type MapAligned(Scalar *data, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:701
const Scalar * data() const
Definition: PlainObjectBase.h:255
const Scalar & coeff(Index index) const
Definition: PlainObjectBase.h:173
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)
Definition: PlainObjectBase.h:832
Derived & setZero(Index size)
Definition: CwiseNullaryOp.h:562
Scalar * data()
Definition: PlainObjectBase.h:259
static MapType Map(Scalar *data, Index rows, Index cols)
Definition: PlainObjectBase.h:662
static StridedMapType< Stride< Outer, Inner > >::type Map(Scalar *data, Index rows, Index cols, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:694
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)
Definition: PlainObjectBase.h:870
Derived & operator=(const EigenBase< OtherDerived > &other)
Copies the generic expression other into *this.
Definition: PlainObjectBase.h:633
static ConstMapType Map(const Scalar *data, Index rows, Index cols)
Definition: PlainObjectBase.h:660
void resize(Index rows, NoChange_t)
Definition: PlainObjectBase.h:348
static ConstAlignedMapType MapAligned(const Scalar *data)
Definition: PlainObjectBase.h:665
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)
Definition: PlainObjectBase.h:847
static StridedConstMapType< Stride< Outer, Inner > >::type Map(const Scalar *data, Index size, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:685
static StridedAlignedMapType< Stride< Outer, Inner > >::type MapAligned(Scalar *data, Index rows, Index cols, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:713
Derived & _set_noalias(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:798
Derived & operator=(const PlainObjectBase &other)
Definition: PlainObjectBase.h:457
void conservativeResize(NoChange_t, Index cols)
Definition: PlainObjectBase.h:417
Common base class for compact rotation representations.
Definition: RotationBase.h:30
Holds strides information for Map.
Definition: Stride.h:49
@ Unaligned
Definition: Constants.h:233
@ DontAlign
Definition: Constants.h:325
@ RowMajor
Definition: Constants.h:321
const unsigned int RowMajorBit
Definition: Constants.h:66
Namespace containing all symbols from the Eigen library.
Definition: Core:134
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:74
const int Dynamic
Definition: Constants.h:22
Definition: Constants.h:525
Definition: EigenBase.h:30
Index cols() const
Definition: EigenBase.h:63
Derived & derived()
Definition: EigenBase.h:46
Index rows() const
Definition: EigenBase.h:60
Index size() const
Definition: EigenBase.h:67
Holds information about the various numeric (i.e. scalar) types allowed by Eigen.
Definition: NumTraits.h:213
Definition: PlainObjectBase.h:71