11 #ifndef EIGEN_DENSESTORAGEBASE_H 12 #define EIGEN_DENSESTORAGEBASE_H 14 #if defined(EIGEN_INITIALIZE_MATRICES_BY_ZERO) 15 # define EIGEN_INITIALIZE_COEFFS 16 # define EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED for(Index 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(Index i=0;i<base().size();++i) coeffRef(i)=std::numeric_limits<Scalar>::quiet_NaN(); 21 # undef EIGEN_INITIALIZE_COEFFS 22 # define EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED 29 template<
int MaxSizeAtCompileTime>
struct check_rows_cols_for_overflow {
30 template<
typename Index>
32 static EIGEN_ALWAYS_INLINE
void run(
Index,
Index)
37 template<>
struct check_rows_cols_for_overflow<
Dynamic> {
38 template<
typename Index>
40 static EIGEN_ALWAYS_INLINE
void run(
Index rows,
Index cols)
44 Index max_index = (std::size_t(1) << (8 *
sizeof(
Index) - 1)) - 1;
45 bool error = (rows == 0 || cols == 0) ?
false 46 : (rows > max_index / cols);
48 throw_std_bad_alloc();
52 template <
typename Derived,
53 typename OtherDerived = Derived,
54 bool IsVector = bool(Derived::IsVectorAtCompileTime) && bool(OtherDerived::IsVectorAtCompileTime)>
55 struct conservative_resize_like_impl;
57 template<
typename MatrixTypeA,
typename MatrixTypeB,
bool SwapPo
inters>
struct matrix_swap_impl;
61 #ifdef EIGEN_PARSED_BY_DOXYGEN 73 template<
typename _Scalar,
int _Rows,
int _Cols,
int _Options,
int _MaxRows,
int _MaxCols>
77 template<
typename _Scalar,
int _Rows,
int _Cols,
int _Options,
int _MaxRows,
int _MaxCols>
94 template<
typename Derived>
97 template<typename Derived>
102 enum { Options = internal::traits<Derived>::Options };
103 typedef typename internal::dense_xpr_base<Derived>::type Base;
105 typedef typename internal::traits<Derived>::StorageKind StorageKind;
106 typedef typename internal::traits<Derived>::Scalar Scalar;
108 typedef typename internal::packet_traits<Scalar>::type PacketScalar;
110 typedef Derived DenseType;
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;
131 DenseStorage<Scalar, Base::MaxSizeAtCompileTime, Base::RowsAtCompileTime, Base::ColsAtCompileTime, Options> m_storage;
134 enum { NeedsToAlign = (SizeAtCompileTime !=
Dynamic) && (internal::traits<Derived>::Alignment>0) };
135 EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign)
138 Base& base() {
return *
static_cast<Base*
>(
this); }
140 const Base& base()
const {
return *
static_cast<const Base*
>(
this); }
142 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
143 Index rows()
const EIGEN_NOEXCEPT {
return m_storage.rows(); }
144 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
145 Index cols()
const EIGEN_NOEXCEPT {
return m_storage.cols(); }
155 return m_storage.data()[colId + rowId * m_storage.cols()];
157 return m_storage.data()[rowId + colId * m_storage.rows()];
167 return m_storage.data()[index];
178 return m_storage.data()[colId + rowId * m_storage.cols()];
180 return m_storage.data()[rowId + colId * m_storage.rows()];
190 return m_storage.data()[index];
199 return m_storage.data()[colId + rowId * m_storage.cols()];
201 return m_storage.data()[rowId + colId * m_storage.rows()];
209 return m_storage.data()[index];
213 template<
int LoadMode>
214 EIGEN_STRONG_INLINE PacketScalar packet(
Index rowId,
Index colId)
const 216 return internal::ploadt<PacketScalar, LoadMode>
218 ? colId + rowId * m_storage.cols()
219 : rowId + colId * m_storage.rows()));
223 template<
int LoadMode>
224 EIGEN_STRONG_INLINE PacketScalar packet(
Index index)
const 226 return internal::ploadt<PacketScalar, LoadMode>(m_storage.data() + index);
230 template<
int StoreMode>
231 EIGEN_STRONG_INLINE
void writePacket(
Index rowId,
Index colId,
const PacketScalar& val)
233 internal::pstoret<Scalar, PacketScalar, StoreMode>
235 ? colId + rowId * m_storage.cols()
236 : rowId + colId * m_storage.rows()), val);
240 template<
int StoreMode>
241 EIGEN_STRONG_INLINE
void writePacket(
Index index,
const PacketScalar& val)
243 internal::pstoret<Scalar, PacketScalar, StoreMode>(m_storage.data() + index, val);
247 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
const Scalar *
data()
const 248 {
return m_storage.data(); }
251 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar *
data()
252 {
return m_storage.data(); }
273 eigen_assert( EIGEN_IMPLIES(RowsAtCompileTime!=
Dynamic,rows==RowsAtCompileTime)
274 && EIGEN_IMPLIES(ColsAtCompileTime!=
Dynamic,cols==ColsAtCompileTime)
275 && EIGEN_IMPLIES(RowsAtCompileTime==
Dynamic && MaxRowsAtCompileTime!=
Dynamic,rows<=MaxRowsAtCompileTime)
276 && EIGEN_IMPLIES(ColsAtCompileTime==
Dynamic && MaxColsAtCompileTime!=
Dynamic,cols<=MaxColsAtCompileTime)
277 && rows>=0 && cols>=0 &&
"Invalid sizes when resizing a matrix or array.");
278 internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(rows, cols);
279 #ifdef EIGEN_INITIALIZE_COEFFS 280 Index size = rows*cols;
281 bool size_changed = size != this->size();
282 m_storage.resize(size, rows, cols);
283 if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
285 m_storage.resize(rows*cols, rows, cols);
304 eigen_assert(((SizeAtCompileTime ==
Dynamic && (MaxSizeAtCompileTime==
Dynamic || size<=MaxSizeAtCompileTime)) || SizeAtCompileTime == size) && size>=0);
305 #ifdef EIGEN_INITIALIZE_COEFFS 306 bool size_changed = size != this->size();
308 if(RowsAtCompileTime == 1)
309 m_storage.resize(size, 1, size);
311 m_storage.resize(size, size, 1);
312 #ifdef EIGEN_INITIALIZE_COEFFS 313 if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
328 resize(rows(), cols);
342 resize(rows, cols());
352 template<
typename OtherDerived>
356 const OtherDerived& other = _other.
derived();
357 internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(other.rows(), other.cols());
358 const Index othersize = other.rows()*other.cols();
359 if(RowsAtCompileTime == 1)
361 eigen_assert(other.rows() == 1 || other.cols() == 1);
362 resize(1, othersize);
364 else if(ColsAtCompileTime == 1)
366 eigen_assert(other.rows() == 1 || other.cols() == 1);
367 resize(othersize, 1);
369 else resize(other.rows(), other.cols());
384 internal::conservative_resize_like_impl<Derived>::run(*
this, rows, cols);
398 conservativeResize(rows, cols());
412 conservativeResize(rows(), cols);
426 internal::conservative_resize_like_impl<Derived>::run(*
this, size);
438 template<
typename OtherDerived>
442 internal::conservative_resize_like_impl<Derived,OtherDerived>::run(*
this, other);
455 template<
typename OtherDerived>
459 _resize_to_match(other);
460 return Base::lazyAssign(other.
derived());
463 template<
typename OtherDerived>
465 EIGEN_STRONG_INLINE Derived& operator=(
const ReturnByValue<OtherDerived>& func)
467 resize(func.rows(), func.cols());
468 return Base::operator=(func);
482 #ifndef EIGEN_PARSED_BY_DOXYGEN 486 explicit PlainObjectBase(internal::constructor_without_unaligned_array_assert)
487 : m_storage(internal::constructor_without_unaligned_array_assert())
493 #if EIGEN_HAS_RVALUE_REFERENCES 495 PlainObjectBase(PlainObjectBase&& other) EIGEN_NOEXCEPT
496 : m_storage( std::move(other.m_storage) )
501 PlainObjectBase& operator=(PlainObjectBase&& other) EIGEN_NOEXCEPT
503 _check_template_params();
504 m_storage = std::move(other.m_storage);
512 : Base(), m_storage(other.m_storage) { }
514 EIGEN_STRONG_INLINE PlainObjectBase(
Index size,
Index rows,
Index cols)
515 : m_storage(size, rows, cols)
532 template <
typename... ArgTypes>
533 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
534 PlainObjectBase(
const Scalar& a0,
const Scalar& a1,
const Scalar& a2,
const Scalar& a3,
const ArgTypes&... args)
537 _check_template_params();
538 EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase,
sizeof...(args) + 4);
539 m_storage.data()[0] = a0;
540 m_storage.data()[1] = a1;
541 m_storage.data()[2] = a2;
542 m_storage.data()[3] = a3;
544 auto x = {(m_storage.data()[i++] = args, 0)...};
545 static_cast<void>(x);
552 explicit EIGEN_STRONG_INLINE
PlainObjectBase(
const std::initializer_list<std::initializer_list<Scalar>>& list)
555 _check_template_params();
557 size_t list_size = 0;
558 if (list.begin() != list.end()) {
559 list_size = list.begin()->size();
563 if (ColsAtCompileTime == 1 && list.size() == 1) {
564 eigen_assert(list_size == static_cast<size_t>(RowsAtCompileTime) || RowsAtCompileTime ==
Dynamic);
565 resize(list_size, ColsAtCompileTime);
566 std::copy(list.begin()->begin(), list.begin()->end(), m_storage.data());
568 eigen_assert(list.size() ==
static_cast<size_t>(RowsAtCompileTime) || RowsAtCompileTime ==
Dynamic);
569 eigen_assert(list_size == static_cast<size_t>(ColsAtCompileTime) || ColsAtCompileTime ==
Dynamic);
570 resize(list.size(), list_size);
573 for (
const std::initializer_list<Scalar>& row : list) {
574 eigen_assert(list_size == row.size());
576 for (
const Scalar& e : row) {
577 coeffRef(row_index, col_index) = e;
584 #endif // end EIGEN_HAS_CXX11 587 template<
typename OtherDerived>
592 _check_template_params();
598 template<
typename OtherDerived>
603 _check_template_params();
608 template<
typename OtherDerived>
612 _check_template_params();
614 resize(other.rows(), other.cols());
615 other.evalTo(this->derived());
623 template<
typename OtherDerived>
627 _resize_to_match(other);
628 Base::operator=(other.
derived());
629 return this->derived();
644 static inline ConstMapType
Map(
const Scalar* data)
645 {
return ConstMapType(data); }
646 static inline MapType
Map(Scalar* data)
647 {
return MapType(data); }
648 static inline ConstMapType
Map(
const Scalar* data,
Index size)
649 {
return ConstMapType(data, size); }
650 static inline MapType
Map(Scalar* data,
Index size)
651 {
return MapType(data, size); }
652 static inline ConstMapType
Map(
const Scalar* data,
Index rows,
Index cols)
653 {
return ConstMapType(data, rows, cols); }
654 static inline MapType
Map(Scalar* data,
Index rows,
Index cols)
655 {
return MapType(data, rows, cols); }
657 static inline ConstAlignedMapType MapAligned(
const Scalar* data)
658 {
return ConstAlignedMapType(data); }
659 static inline AlignedMapType MapAligned(Scalar* data)
660 {
return AlignedMapType(data); }
661 static inline ConstAlignedMapType MapAligned(
const Scalar* data,
Index size)
662 {
return ConstAlignedMapType(data, size); }
663 static inline AlignedMapType MapAligned(Scalar* data,
Index size)
664 {
return AlignedMapType(data, size); }
665 static inline ConstAlignedMapType MapAligned(
const Scalar* data,
Index rows,
Index cols)
666 {
return ConstAlignedMapType(data, rows, cols); }
667 static inline AlignedMapType MapAligned(Scalar* data,
Index rows,
Index cols)
668 {
return AlignedMapType(data, rows, cols); }
670 template<
int Outer,
int Inner>
671 static inline typename StridedConstMapType<Stride<Outer, Inner> >::type
Map(
const Scalar* data,
const Stride<Outer, Inner>& stride)
672 {
return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, stride); }
673 template<
int Outer,
int Inner>
674 static inline typename StridedMapType<Stride<Outer, Inner> >::type
Map(Scalar* data,
const Stride<Outer, Inner>& stride)
675 {
return typename StridedMapType<Stride<Outer, Inner> >::type(data, stride); }
676 template<
int Outer,
int Inner>
677 static inline typename StridedConstMapType<Stride<Outer, Inner> >::type
Map(
const Scalar* data,
Index size,
const Stride<Outer, Inner>& stride)
678 {
return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, size, stride); }
679 template<
int Outer,
int Inner>
681 {
return typename StridedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
682 template<
int Outer,
int Inner>
684 {
return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
685 template<
int Outer,
int Inner>
687 {
return typename StridedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
689 template<
int Outer,
int Inner>
690 static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(
const Scalar* data,
const Stride<Outer, Inner>& stride)
691 {
return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, stride); }
692 template<
int Outer,
int Inner>
693 static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data,
const Stride<Outer, Inner>& stride)
694 {
return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, stride); }
695 template<
int Outer,
int Inner>
696 static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(
const Scalar* data,
Index size,
const Stride<Outer, Inner>& stride)
697 {
return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
698 template<
int Outer,
int Inner>
699 static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data,
Index size,
const Stride<Outer, Inner>& stride)
700 {
return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
701 template<
int Outer,
int Inner>
702 static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(
const Scalar* data,
Index rows,
Index cols,
const Stride<Outer, Inner>& stride)
703 {
return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
704 template<
int Outer,
int Inner>
705 static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data,
Index rows,
Index cols,
const Stride<Outer, Inner>& stride)
706 {
return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
709 using Base::setConstant;
710 EIGEN_DEVICE_FUNC Derived& setConstant(
Index size,
const Scalar& val);
711 EIGEN_DEVICE_FUNC Derived& setConstant(
Index rows,
Index cols,
const Scalar& val);
712 EIGEN_DEVICE_FUNC Derived& setConstant(NoChange_t,
Index cols,
const Scalar& val);
713 EIGEN_DEVICE_FUNC Derived& setConstant(
Index rows, NoChange_t,
const Scalar& val);
716 EIGEN_DEVICE_FUNC Derived& setZero(
Index size);
717 EIGEN_DEVICE_FUNC Derived& setZero(
Index rows,
Index cols);
718 EIGEN_DEVICE_FUNC Derived& setZero(NoChange_t,
Index cols);
719 EIGEN_DEVICE_FUNC Derived& setZero(
Index rows, NoChange_t);
722 EIGEN_DEVICE_FUNC Derived& setOnes(
Index size);
723 EIGEN_DEVICE_FUNC Derived& setOnes(
Index rows,
Index cols);
724 EIGEN_DEVICE_FUNC Derived& setOnes(NoChange_t,
Index cols);
725 EIGEN_DEVICE_FUNC Derived& setOnes(
Index rows, NoChange_t);
727 using Base::setRandom;
728 Derived& setRandom(
Index size);
730 Derived& setRandom(NoChange_t,
Index cols);
731 Derived& setRandom(
Index rows, NoChange_t);
733 #ifdef EIGEN_PLAINOBJECTBASE_PLUGIN 734 #include EIGEN_PLAINOBJECTBASE_PLUGIN 745 template<
typename OtherDerived>
749 #ifdef EIGEN_NO_AUTOMATIC_RESIZING 750 eigen_assert((this->size()==0 || (IsVectorAtCompileTime ? (this->size() == other.
size())
751 : (rows() == other.
rows() && cols() == other.
cols())))
752 &&
"Size mismatch. Automatic resizing is disabled because EIGEN_NO_AUTOMATIC_RESIZING is defined");
753 EIGEN_ONLY_USED_FOR_DEBUG(other);
775 template<
typename OtherDerived>
779 internal::call_assignment(this->derived(), other.
derived());
780 return this->derived();
788 template<
typename OtherDerived>
797 internal::call_assignment_no_alias(this->derived(), other.
derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
798 return this->derived();
801 template<
typename T0,
typename T1>
803 EIGEN_STRONG_INLINE
void _init2(
Index rows,
Index cols,
typename internal::enable_if<Base::SizeAtCompileTime!=2,T0>::type* = 0)
805 const bool t0_is_integer_alike = internal::is_valid_index_type<T0>::value;
806 const bool t1_is_integer_alike = internal::is_valid_index_type<T1>::value;
807 EIGEN_STATIC_ASSERT(t0_is_integer_alike &&
809 FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
813 template<
typename T0,
typename T1>
815 EIGEN_STRONG_INLINE
void _init2(
const T0& val0,
const T1& val1,
typename internal::enable_if<Base::SizeAtCompileTime==2,T0>::type* = 0)
817 EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
818 m_storage.data()[0] = Scalar(val0);
819 m_storage.data()[1] = Scalar(val1);
822 template<
typename T0,
typename T1>
824 EIGEN_STRONG_INLINE
void _init2(
const Index& val0,
const Index& val1,
825 typename internal::enable_if< (!internal::is_same<Index,Scalar>::value)
826 && (internal::is_same<T0,Index>::value)
827 && (internal::is_same<T1,Index>::value)
828 && Base::SizeAtCompileTime==2,T1>::type* = 0)
830 EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
831 m_storage.data()[0] = Scalar(val0);
832 m_storage.data()[1] = Scalar(val1);
839 EIGEN_STRONG_INLINE
void _init1(
Index size,
typename internal::enable_if< (Base::SizeAtCompileTime!=1 || !internal::is_convertible<T, Scalar>::value)
840 && ((!internal::is_same<
typename internal::traits<Derived>::XprKind,
ArrayXpr>::value || Base::SizeAtCompileTime==
Dynamic)),T>::type* = 0)
843 const bool is_integer_alike = internal::is_valid_index_type<T>::value;
844 EIGEN_UNUSED_VARIABLE(is_integer_alike);
845 EIGEN_STATIC_ASSERT(is_integer_alike,
846 FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
853 EIGEN_STRONG_INLINE
void _init1(
const Scalar& val0,
typename internal::enable_if<Base::SizeAtCompileTime==1 && internal::is_convertible<T, Scalar>::value,T>::type* = 0)
855 EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 1)
856 m_storage.data()[0] = val0;
862 EIGEN_STRONG_INLINE
void _init1(
const Index& val0,
863 typename internal::enable_if< (!internal::is_same<Index,Scalar>::value)
864 && (internal::is_same<Index,T>::value)
865 && Base::SizeAtCompileTime==1
866 && internal::is_convertible<T, Scalar>::value,T*>::type* = 0)
868 EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 1)
869 m_storage.data()[0] = Scalar(val0);
875 EIGEN_STRONG_INLINE
void _init1(
const Scalar* data){
876 this->_set_noalias(ConstMapType(data));
880 template<
typename T,
typename OtherDerived>
883 this->_set_noalias(other);
889 EIGEN_STRONG_INLINE
void _init1(
const Derived& other){
890 this->_set_noalias(other);
894 template<
typename T,
typename OtherDerived>
897 this->derived() = other;
900 template<
typename T,
typename OtherDerived>
902 EIGEN_STRONG_INLINE
void _init1(
const ReturnByValue<OtherDerived>& other)
904 resize(other.rows(), other.cols());
905 other.evalTo(this->derived());
908 template<
typename T,
typename OtherDerived,
int ColsAtCompileTime>
918 EIGEN_STRONG_INLINE
void _init1(
const Scalar& val0,
919 typename internal::enable_if< Base::SizeAtCompileTime!=
Dynamic 920 && Base::SizeAtCompileTime!=1
921 && internal::is_convertible<T, Scalar>::value
922 && internal::is_same<
typename internal::traits<Derived>::XprKind,
ArrayXpr>::value,T>::type* = 0)
924 Base::setConstant(val0);
930 EIGEN_STRONG_INLINE
void _init1(
const Index& val0,
931 typename internal::enable_if< (!internal::is_same<Index,Scalar>::value)
932 && (internal::is_same<Index,T>::value)
933 && Base::SizeAtCompileTime!=
Dynamic 934 && Base::SizeAtCompileTime!=1
935 && internal::is_convertible<T, Scalar>::value
936 && internal::is_same<
typename internal::traits<Derived>::XprKind,
ArrayXpr>::value,T*>::type* = 0)
938 Base::setConstant(val0);
941 template<
typename MatrixTypeA,
typename MatrixTypeB,
bool SwapPo
inters>
942 friend struct internal::matrix_swap_impl;
946 #ifndef EIGEN_PARSED_BY_DOXYGEN 951 template<
typename OtherDerived>
952 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
955 enum { SwapPointers = internal::is_same<Derived, OtherDerived>::value && Base::SizeAtCompileTime==
Dynamic };
956 internal::matrix_swap_impl<Derived, OtherDerived, bool(SwapPointers)>::run(this->derived(), other.
derived());
962 template<
typename OtherDerived>
963 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
965 { Base::swap(other.
derived()); }
968 static EIGEN_STRONG_INLINE
void _check_template_params()
970 EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, (
int(Options)&
RowMajor)==RowMajor)
971 && EIGEN_IMPLIES(MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1, (
int(Options)&RowMajor)==0)
972 && ((RowsAtCompileTime ==
Dynamic) || (RowsAtCompileTime >= 0))
973 && ((ColsAtCompileTime ==
Dynamic) || (ColsAtCompileTime >= 0))
974 && ((MaxRowsAtCompileTime ==
Dynamic) || (MaxRowsAtCompileTime >= 0))
975 && ((MaxColsAtCompileTime ==
Dynamic) || (MaxColsAtCompileTime >= 0))
976 && (MaxRowsAtCompileTime == RowsAtCompileTime || RowsAtCompileTime==
Dynamic)
977 && (MaxColsAtCompileTime == ColsAtCompileTime || ColsAtCompileTime==
Dynamic)
978 && (Options & (
DontAlign|RowMajor)) == Options),
979 INVALID_MATRIX_TEMPLATE_PARAMETERS)
982 enum { IsPlainObjectBase = 1 };
987 template<
typename PlainObjectType,
int MapOptions,
typename Str
ideType>
friend class Eigen::Map;
989 friend class Eigen::Map<const Derived, Unaligned>;
990 #if EIGEN_MAX_ALIGN_BYTES>0 993 friend class Eigen::Map<const Derived, AlignedMax>;
999 template <
typename Derived,
typename OtherDerived,
bool IsVector>
1000 struct conservative_resize_like_impl
1002 #if EIGEN_HAS_TYPE_TRAITS 1003 static const bool IsRelocatable = std::is_trivially_copyable<typename Derived::Scalar>::value;
1009 if (_this.
rows() == rows && _this.
cols() == cols)
return;
1010 EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
1013 && (( Derived::IsRowMajor && _this.
cols() == cols) ||
1014 (!Derived::IsRowMajor && _this.
rows() == rows) ))
1016 internal::check_rows_cols_for_overflow<Derived::MaxSizeAtCompileTime>::run(rows, cols);
1017 _this.
derived().m_storage.conservativeResize(rows*cols,rows,cols);
1022 Derived tmp(rows,cols);
1023 const Index common_rows = numext::mini(rows, _this.
rows());
1024 const Index common_cols = numext::mini(cols, _this.
cols());
1025 tmp.block(0,0,common_rows,common_cols) = _this.
block(0,0,common_rows,common_cols);
1039 EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
1040 EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(OtherDerived)
1042 if ( IsRelocatable &&
1043 (( Derived::IsRowMajor && _this.
cols() == other.
cols()) ||
1044 (!Derived::IsRowMajor && _this.
rows() == other.
rows()) ))
1051 else if (new_cols>0)
1058 const Index common_rows = numext::mini(tmp.rows(), _this.
rows());
1059 const Index common_cols = numext::mini(tmp.cols(), _this.
cols());
1060 tmp.block(0,0,common_rows,common_cols) = _this.
block(0,0,common_rows,common_cols);
1068 template <
typename Derived,
typename OtherDerived>
1069 struct conservative_resize_like_impl<Derived,OtherDerived,true>
1070 : conservative_resize_like_impl<Derived,OtherDerived,false>
1072 typedef conservative_resize_like_impl<Derived,OtherDerived,false> Base;
1074 using Base::IsRelocatable;
1078 const Index new_rows = Derived::RowsAtCompileTime==1 ? 1 : size;
1079 const Index new_cols = Derived::RowsAtCompileTime==1 ? size : 1;
1081 _this.
derived().m_storage.conservativeResize(size,new_rows,new_cols);
1083 Base::run(_this.
derived(), new_rows, new_cols);
1092 const Index new_rows = Derived::RowsAtCompileTime==1 ? 1 : other.
rows();
1093 const Index new_cols = Derived::RowsAtCompileTime==1 ? other.
cols() : 1;
1095 _this.
derived().m_storage.conservativeResize(other.
size(),new_rows,new_cols);
1097 Base::run(_this.
derived(), new_rows, new_cols);
1099 if (num_new_elements > 0)
1100 _this.
tail(num_new_elements) = other.
tail(num_new_elements);
1104 template<
typename MatrixTypeA,
typename MatrixTypeB,
bool SwapPo
inters>
1105 struct matrix_swap_impl
1108 static EIGEN_STRONG_INLINE
void run(MatrixTypeA& a, MatrixTypeB& b)
1114 template<
typename MatrixTypeA,
typename MatrixTypeB>
1115 struct matrix_swap_impl<MatrixTypeA, MatrixTypeB, true>
1118 static inline void run(MatrixTypeA& a, MatrixTypeB& b)
1120 static_cast<typename MatrixTypeA::Base&
>(a).m_storage.swap(static_cast<typename MatrixTypeB::Base&>(b).m_storage);
1128 #endif // EIGEN_DENSESTORAGEBASE_H FixedBlockXpr<...,... >::Type block(Index startRow, Index startCol, NRowsType blockRows, NColsType blockCols)
Definition: DenseBase.h:97
void resize(NoChange_t, Index cols)
Definition: PlainObjectBase.h:326
PlainObjectBase(const ReturnByValue< OtherDerived > &other)
Copy constructor with in-place evaluation.
Definition: PlainObjectBase.h:610
Definition: Constants.h:325
const Scalar & coeffRef(Index rowId, Index colId) const
Definition: PlainObjectBase.h:196
FixedBlockXpr<...,... >::Type bottomRightCorner(NRowsType cRows, NColsType cCols)
Definition: DenseBase.h:356
Definition: PlainObjectBase.h:71
Derived & lazyAssign(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:457
A matrix or vector expression mapping an existing array of data.
Definition: Map.h:94
void conservativeResize(Index rows, Index cols)
Definition: PlainObjectBase.h:382
Namespace containing all symbols from the Eigen library.
Definition: Core:141
Holds strides information for Map.
Definition: Stride.h:48
Holds information about the various numeric (i.e. scalar) types allowed by Eigen. ...
Definition: NumTraits.h:232
Derived & derived()
Definition: EigenBase.h:46
EIGEN_CONSTEXPR Index size() const EIGEN_NOEXCEPT
Definition: EigenBase.h:67
const unsigned int RowMajorBit
Definition: Constants.h:66
Base class for all dense matrices, vectors, and arrays.
Definition: DenseBase.h:41
void resize(Index rows, Index cols)
Definition: PlainObjectBase.h:271
PlainObjectBase(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:589
PlainObjectBase(const EigenBase< OtherDerived > &other)
Definition: PlainObjectBase.h:600
PlainObjectBase(const PlainObjectBase &other)
Definition: PlainObjectBase.h:511
Definition: EigenBase.h:29
NColsBlockXpr<... >::Type rightCols(NColsType n)
Definition: DenseBase.h:873
FixedSegmentReturnType<... >::Type tail(NType n)
Definition: DenseBase.h:1258
Scalar * data()
Definition: PlainObjectBase.h:251
Scalar & coeffRef(Index rowId, Index colId)
Definition: PlainObjectBase.h:175
void conservativeResize(NoChange_t, Index cols)
Definition: PlainObjectBase.h:409
void resizeLike(const EigenBase< OtherDerived > &_other)
Definition: PlainObjectBase.h:354
Scalar & coeffRef(Index index)
Definition: PlainObjectBase.h:188
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:74
EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT
Definition: EigenBase.h:63
void resize(Index rows, NoChange_t)
Definition: PlainObjectBase.h:340
const Scalar & coeff(Index index) const
Definition: PlainObjectBase.h:165
Dense storage base class for matrices and arrays.
Definition: PlainObjectBase.h:95
Derived & operator=(const PlainObjectBase &other)
Definition: PlainObjectBase.h:449
Common base class for compact rotation representations.
Definition: RotationBase.h:29
Base class for all 1D and 2D array, and related expressions.
Definition: ArrayBase.h:39
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:552
const Scalar * data() const
Definition: PlainObjectBase.h:247
void conservativeResize(Index size)
Definition: PlainObjectBase.h:424
Definition: Eigen_Colamd.h:50
void resize(Index size)
Definition: PlainObjectBase.h:301
const Scalar & coeff(Index rowId, Index colId) const
Definition: PlainObjectBase.h:152
const Scalar & coeffRef(Index index) const
Definition: PlainObjectBase.h:207
General-purpose arrays with easy API for coefficient-wise operations.
Definition: Array.h:45
Definition: Constants.h:321
NRowsBlockXpr<... >::Type bottomRows(NRowsType n)
Definition: DenseBase.h:646
Definition: Constants.h:525
EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT
Definition: EigenBase.h:60
const int Dynamic
Definition: Constants.h:22
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. [c++11]
Definition: PlainObjectBase.h:534
void conservativeResizeLike(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:440
The matrix class, also used for vectors and row-vectors.
Definition: Matrix.h:178
void conservativeResize(Index rows, NoChange_t)
Definition: PlainObjectBase.h:395
Derived & _set(const DenseBase< OtherDerived > &other)
Copies the value of the expression other into *this with automatic resizing.
Definition: PlainObjectBase.h:777
Derived & operator=(const EigenBase< OtherDerived > &other)
Copies the generic expression other into *this.
Definition: PlainObjectBase.h:625
Base class for all dense matrices, vectors, and expressions.
Definition: MatrixBase.h:48