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(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(); 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;
121 template<
typename PlainObjectType,
int MapOptions,
typename Str
ideType>
friend class Eigen::Map;
124 friend class Eigen::Map<const Derived, Unaligned>;
126 #if EIGEN_MAX_ALIGN_BYTES>0 129 friend class Eigen::Map<const Derived, AlignedMax>;
139 DenseStorage<Scalar, Base::MaxSizeAtCompileTime, Base::RowsAtCompileTime, Base::ColsAtCompileTime, Options> m_storage;
142 enum { NeedsToAlign = (SizeAtCompileTime !=
Dynamic) && (internal::traits<Derived>::Alignment>0) };
143 EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign)
146 Base& base() {
return *
static_cast<Base*
>(
this); }
148 const Base& base()
const {
return *
static_cast<const Base*
>(
this); }
151 EIGEN_STRONG_INLINE
Index rows()
const {
return m_storage.rows(); }
153 EIGEN_STRONG_INLINE
Index cols()
const {
return m_storage.cols(); }
163 return m_storage.data()[colId + rowId * m_storage.cols()];
165 return m_storage.data()[rowId + colId * m_storage.rows()];
175 return m_storage.data()[index];
186 return m_storage.data()[colId + rowId * m_storage.cols()];
188 return m_storage.data()[rowId + colId * m_storage.rows()];
198 return m_storage.data()[index];
207 return m_storage.data()[colId + rowId * m_storage.cols()];
209 return m_storage.data()[rowId + colId * m_storage.rows()];
217 return m_storage.data()[index];
221 template<
int LoadMode>
222 EIGEN_STRONG_INLINE PacketScalar packet(
Index rowId,
Index colId)
const 224 return internal::ploadt<PacketScalar, LoadMode>
226 ? colId + rowId * m_storage.cols()
227 : rowId + colId * m_storage.rows()));
231 template<
int LoadMode>
232 EIGEN_STRONG_INLINE PacketScalar packet(
Index index)
const 234 return internal::ploadt<PacketScalar, LoadMode>(m_storage.data() + index);
238 template<
int StoreMode>
239 EIGEN_STRONG_INLINE
void writePacket(
Index rowId,
Index colId,
const PacketScalar& val)
241 internal::pstoret<Scalar, PacketScalar, StoreMode>
243 ? colId + rowId * m_storage.cols()
244 : rowId + colId * m_storage.rows()), val);
248 template<
int StoreMode>
249 EIGEN_STRONG_INLINE
void writePacket(
Index index,
const PacketScalar& val)
251 internal::pstoret<Scalar, PacketScalar, StoreMode>(m_storage.data() + index, val);
255 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
const Scalar *
data()
const 256 {
return m_storage.data(); }
259 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar *
data()
260 {
return m_storage.data(); }
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
293 m_storage.resize(rows*cols, rows, cols);
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();
316 if(RowsAtCompileTime == 1)
317 m_storage.resize(size, 1, size);
319 m_storage.resize(size, size, 1);
320 #ifdef EIGEN_INITIALIZE_COEFFS 321 if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
336 resize(rows(), cols);
350 resize(rows, cols());
360 template<
typename OtherDerived>
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)
369 eigen_assert(other.rows() == 1 || other.cols() == 1);
370 resize(1, othersize);
372 else if(ColsAtCompileTime == 1)
374 eigen_assert(other.rows() == 1 || other.cols() == 1);
375 resize(othersize, 1);
377 else resize(other.rows(), other.cols());
392 internal::conservative_resize_like_impl<Derived>::run(*
this, rows, cols);
406 conservativeResize(rows, cols());
420 conservativeResize(rows(), cols);
434 internal::conservative_resize_like_impl<Derived>::run(*
this, size);
446 template<
typename OtherDerived>
450 internal::conservative_resize_like_impl<Derived,OtherDerived>::run(*
this, other);
463 template<
typename OtherDerived>
467 _resize_to_match(other);
468 return Base::lazyAssign(other.
derived());
471 template<
typename OtherDerived>
473 EIGEN_STRONG_INLINE Derived& operator=(
const ReturnByValue<OtherDerived>& func)
475 resize(func.rows(), func.cols());
476 return Base::operator=(func);
490 #ifndef EIGEN_PARSED_BY_DOXYGEN 494 explicit PlainObjectBase(internal::constructor_without_unaligned_array_assert)
495 : m_storage(internal::constructor_without_unaligned_array_assert())
501 #if EIGEN_HAS_RVALUE_REFERENCES 503 PlainObjectBase(PlainObjectBase&& other) EIGEN_NOEXCEPT
504 : m_storage( std::move(other.m_storage) )
509 PlainObjectBase& operator=(PlainObjectBase&& other) EIGEN_NOEXCEPT
512 swap(m_storage, other.m_storage);
520 : Base(), m_storage(other.m_storage) { }
522 EIGEN_STRONG_INLINE PlainObjectBase(
Index size,
Index rows,
Index cols)
523 : m_storage(size, rows, cols)
530 template<
typename OtherDerived>
535 _check_template_params();
541 template<
typename OtherDerived>
546 _check_template_params();
551 template<
typename OtherDerived>
555 _check_template_params();
557 resize(other.rows(), other.cols());
558 other.evalTo(this->derived());
566 template<
typename OtherDerived>
570 _resize_to_match(other);
571 Base::operator=(other.
derived());
572 return this->derived();
583 static inline ConstMapType
Map(
const Scalar* data)
584 {
return ConstMapType(data); }
585 static inline MapType
Map(Scalar* data)
586 {
return MapType(data); }
587 static inline ConstMapType
Map(
const Scalar* data,
Index size)
588 {
return ConstMapType(data, size); }
589 static inline MapType
Map(Scalar* data,
Index size)
590 {
return MapType(data, size); }
591 static inline ConstMapType
Map(
const Scalar* data,
Index rows,
Index cols)
592 {
return ConstMapType(data, rows, cols); }
593 static inline MapType
Map(Scalar* data,
Index rows,
Index cols)
594 {
return MapType(data, rows, cols); }
596 static inline ConstAlignedMapType MapAligned(
const Scalar* data)
597 {
return ConstAlignedMapType(data); }
598 static inline AlignedMapType MapAligned(Scalar* data)
599 {
return AlignedMapType(data); }
600 static inline ConstAlignedMapType MapAligned(
const Scalar* data,
Index size)
601 {
return ConstAlignedMapType(data, size); }
602 static inline AlignedMapType MapAligned(Scalar* data,
Index size)
603 {
return AlignedMapType(data, size); }
604 static inline ConstAlignedMapType MapAligned(
const Scalar* data,
Index rows,
Index cols)
605 {
return ConstAlignedMapType(data, rows, cols); }
606 static inline AlignedMapType MapAligned(Scalar* data,
Index rows,
Index cols)
607 {
return AlignedMapType(data, rows, cols); }
609 template<
int Outer,
int Inner>
610 static inline typename StridedConstMapType<Stride<Outer, Inner> >::type
Map(
const Scalar* data,
const Stride<Outer, Inner>& stride)
611 {
return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, stride); }
612 template<
int Outer,
int Inner>
613 static inline typename StridedMapType<Stride<Outer, Inner> >::type
Map(Scalar* data,
const Stride<Outer, Inner>& stride)
614 {
return typename StridedMapType<Stride<Outer, Inner> >::type(data, stride); }
615 template<
int Outer,
int Inner>
616 static inline typename StridedConstMapType<Stride<Outer, Inner> >::type
Map(
const Scalar* data,
Index size,
const Stride<Outer, Inner>& stride)
617 {
return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, size, stride); }
618 template<
int Outer,
int Inner>
620 {
return typename StridedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
621 template<
int Outer,
int Inner>
623 {
return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
624 template<
int Outer,
int Inner>
626 {
return typename StridedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
628 template<
int Outer,
int Inner>
629 static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(
const Scalar* data,
const Stride<Outer, Inner>& stride)
630 {
return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, stride); }
631 template<
int Outer,
int Inner>
632 static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data,
const Stride<Outer, Inner>& stride)
633 {
return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, stride); }
634 template<
int Outer,
int Inner>
635 static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(
const Scalar* data,
Index size,
const Stride<Outer, Inner>& stride)
636 {
return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
637 template<
int Outer,
int Inner>
638 static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data,
Index size,
const Stride<Outer, Inner>& stride)
639 {
return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
640 template<
int Outer,
int Inner>
641 static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(
const Scalar* data,
Index rows,
Index cols,
const Stride<Outer, Inner>& stride)
642 {
return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
643 template<
int Outer,
int Inner>
644 static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data,
Index rows,
Index cols,
const Stride<Outer, Inner>& stride)
645 {
return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
648 using Base::setConstant;
649 EIGEN_DEVICE_FUNC Derived& setConstant(
Index size,
const Scalar& val);
650 EIGEN_DEVICE_FUNC Derived& setConstant(
Index rows,
Index cols,
const Scalar& val);
653 EIGEN_DEVICE_FUNC Derived& setZero(
Index size);
654 EIGEN_DEVICE_FUNC Derived& setZero(
Index rows,
Index cols);
657 EIGEN_DEVICE_FUNC Derived& setOnes(
Index size);
658 EIGEN_DEVICE_FUNC Derived& setOnes(
Index rows,
Index cols);
660 using Base::setRandom;
661 Derived& setRandom(
Index size);
664 #ifdef EIGEN_PLAINOBJECTBASE_PLUGIN 665 #include EIGEN_PLAINOBJECTBASE_PLUGIN 676 template<
typename OtherDerived>
680 #ifdef EIGEN_NO_AUTOMATIC_RESIZING 681 eigen_assert((this->size()==0 || (IsVectorAtCompileTime ? (this->size() == other.
size())
682 : (rows() == other.
rows() && cols() == other.
cols())))
683 &&
"Size mismatch. Automatic resizing is disabled because EIGEN_NO_AUTOMATIC_RESIZING is defined");
684 EIGEN_ONLY_USED_FOR_DEBUG(other);
706 template<
typename OtherDerived>
710 internal::call_assignment(this->derived(), other.
derived());
711 return this->derived();
719 template<
typename OtherDerived>
728 internal::call_assignment_no_alias(this->derived(), other.
derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
729 return this->derived();
732 template<
typename T0,
typename T1>
734 EIGEN_STRONG_INLINE
void _init2(
Index rows,
Index cols,
typename internal::enable_if<Base::SizeAtCompileTime!=2,T0>::type* = 0)
738 FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
742 template<
typename T0,
typename T1>
744 EIGEN_STRONG_INLINE
void _init2(
const T0& val0,
const T1& val1,
typename internal::enable_if<Base::SizeAtCompileTime==2,T0>::type* = 0)
746 EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
747 m_storage.data()[0] = Scalar(val0);
748 m_storage.data()[1] = Scalar(val1);
751 template<
typename T0,
typename T1>
753 EIGEN_STRONG_INLINE
void _init2(
const Index& val0,
const Index& val1,
754 typename internal::enable_if< (!internal::is_same<Index,Scalar>::value)
755 && (internal::is_same<T0,Index>::value)
756 && (internal::is_same<T1,Index>::value)
757 && Base::SizeAtCompileTime==2,T1>::type* = 0)
759 EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
760 m_storage.data()[0] = Scalar(val0);
761 m_storage.data()[1] = Scalar(val1);
768 EIGEN_STRONG_INLINE
void _init1(
Index size,
typename internal::enable_if< (Base::SizeAtCompileTime!=1 || !internal::is_convertible<T, Scalar>::value)
769 && ((!internal::is_same<
typename internal::traits<Derived>::XprKind,
ArrayXpr>::value || Base::SizeAtCompileTime==
Dynamic)),T>::type* = 0)
773 EIGEN_UNUSED_VARIABLE(is_integer);
774 EIGEN_STATIC_ASSERT(is_integer,
775 FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
782 EIGEN_STRONG_INLINE
void _init1(
const Scalar& val0,
typename internal::enable_if<Base::SizeAtCompileTime==1 && internal::is_convertible<T, Scalar>::value,T>::type* = 0)
784 EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 1)
785 m_storage.data()[0] = val0;
791 EIGEN_STRONG_INLINE
void _init1(
const Index& val0,
792 typename internal::enable_if< (!internal::is_same<Index,Scalar>::value)
793 && (internal::is_same<Index,T>::value)
794 && Base::SizeAtCompileTime==1
795 && internal::is_convertible<T, Scalar>::value,T*>::type* = 0)
797 EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 1)
798 m_storage.data()[0] = Scalar(val0);
804 EIGEN_STRONG_INLINE
void _init1(
const Scalar* data){
805 this->_set_noalias(ConstMapType(data));
809 template<
typename T,
typename OtherDerived>
812 this->_set_noalias(other);
818 EIGEN_STRONG_INLINE
void _init1(
const Derived& other){
819 this->_set_noalias(other);
823 template<
typename T,
typename OtherDerived>
826 this->derived() = other;
829 template<
typename T,
typename OtherDerived>
831 EIGEN_STRONG_INLINE
void _init1(
const ReturnByValue<OtherDerived>& other)
833 resize(other.rows(), other.cols());
834 other.evalTo(this->derived());
837 template<
typename T,
typename OtherDerived,
int ColsAtCompileTime>
847 EIGEN_STRONG_INLINE
void _init1(
const Scalar& val0,
848 typename internal::enable_if< Base::SizeAtCompileTime!=
Dynamic 849 && Base::SizeAtCompileTime!=1
850 && internal::is_convertible<T, Scalar>::value
851 && internal::is_same<
typename internal::traits<Derived>::XprKind,
ArrayXpr>::value,T>::type* = 0)
853 Base::setConstant(val0);
859 EIGEN_STRONG_INLINE
void _init1(
const Index& val0,
860 typename internal::enable_if< (!internal::is_same<Index,Scalar>::value)
861 && (internal::is_same<Index,T>::value)
862 && Base::SizeAtCompileTime!=
Dynamic 863 && Base::SizeAtCompileTime!=1
864 && internal::is_convertible<T, Scalar>::value
865 && internal::is_same<
typename internal::traits<Derived>::XprKind,
ArrayXpr>::value,T*>::type* = 0)
867 Base::setConstant(val0);
870 template<
typename MatrixTypeA,
typename MatrixTypeB,
bool SwapPo
inters>
871 friend struct internal::matrix_swap_impl;
875 #ifndef EIGEN_PARSED_BY_DOXYGEN 880 template<
typename OtherDerived>
884 enum { SwapPointers = internal::is_same<Derived, OtherDerived>::value && Base::SizeAtCompileTime==
Dynamic };
885 internal::matrix_swap_impl<Derived, OtherDerived, bool(SwapPointers)>::run(this->derived(), other.
derived());
891 template<
typename OtherDerived>
894 { Base::swap(other.
derived()); }
897 static EIGEN_STRONG_INLINE
void _check_template_params()
899 EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, (Options&
RowMajor)==RowMajor)
900 && EIGEN_IMPLIES(MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1, (Options&RowMajor)==0)
901 && ((RowsAtCompileTime ==
Dynamic) || (RowsAtCompileTime >= 0))
902 && ((ColsAtCompileTime ==
Dynamic) || (ColsAtCompileTime >= 0))
903 && ((MaxRowsAtCompileTime ==
Dynamic) || (MaxRowsAtCompileTime >= 0))
904 && ((MaxColsAtCompileTime ==
Dynamic) || (MaxColsAtCompileTime >= 0))
905 && (MaxRowsAtCompileTime == RowsAtCompileTime || RowsAtCompileTime==
Dynamic)
906 && (MaxColsAtCompileTime == ColsAtCompileTime || ColsAtCompileTime==
Dynamic)
907 && (Options & (
DontAlign|RowMajor)) == Options),
908 INVALID_MATRIX_TEMPLATE_PARAMETERS)
911 enum { IsPlainObjectBase = 1 };
917 template <
typename Derived,
typename OtherDerived,
bool IsVector>
918 struct conservative_resize_like_impl
922 if (_this.
rows() == rows && _this.
cols() == cols)
return;
923 EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
925 if ( ( Derived::IsRowMajor && _this.
cols() == cols) ||
926 (!Derived::IsRowMajor && _this.
rows() == rows) )
928 internal::check_rows_cols_for_overflow<Derived::MaxSizeAtCompileTime>::run(rows, cols);
929 _this.
derived().m_storage.conservativeResize(rows*cols,rows,cols);
934 typename Derived::PlainObject tmp(rows,cols);
935 const Index common_rows = numext::mini(rows, _this.
rows());
936 const Index common_cols = numext::mini(cols, _this.
cols());
937 tmp.block(0,0,common_rows,common_cols) = _this.
block(0,0,common_rows,common_cols);
951 EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
952 EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(OtherDerived)
954 if ( ( Derived::IsRowMajor && _this.
cols() == other.
cols()) ||
955 (!Derived::IsRowMajor && _this.
rows() == other.
rows()) )
968 typename Derived::PlainObject tmp(other);
969 const Index common_rows = numext::mini(tmp.rows(), _this.
rows());
970 const Index common_cols = numext::mini(tmp.cols(), _this.
cols());
971 tmp.block(0,0,common_rows,common_cols) = _this.
block(0,0,common_rows,common_cols);
979 template <
typename Derived,
typename OtherDerived>
980 struct conservative_resize_like_impl<Derived,OtherDerived,true>
981 : conservative_resize_like_impl<Derived,OtherDerived,false>
983 using conservative_resize_like_impl<Derived,OtherDerived,false>::run;
987 const Index new_rows = Derived::RowsAtCompileTime==1 ? 1 : size;
988 const Index new_cols = Derived::RowsAtCompileTime==1 ? size : 1;
989 _this.
derived().m_storage.conservativeResize(size,new_rows,new_cols);
998 const Index new_rows = Derived::RowsAtCompileTime==1 ? 1 : other.
rows();
999 const Index new_cols = Derived::RowsAtCompileTime==1 ? other.
cols() : 1;
1000 _this.
derived().m_storage.conservativeResize(other.
size(),new_rows,new_cols);
1002 if (num_new_elements > 0)
1003 _this.
tail(num_new_elements) = other.
tail(num_new_elements);
1007 template<
typename MatrixTypeA,
typename MatrixTypeB,
bool SwapPo
inters>
1008 struct matrix_swap_impl
1011 static inline void run(MatrixTypeA& a, MatrixTypeB& b)
1017 template<
typename MatrixTypeA,
typename MatrixTypeB>
1018 struct matrix_swap_impl<MatrixTypeA, MatrixTypeB, true>
1021 static inline void run(MatrixTypeA& a, MatrixTypeB& b)
1023 static_cast<typename MatrixTypeA::Base&
>(a).m_storage.swap(static_cast<typename MatrixTypeB::Base&>(b).m_storage);
1031 #endif // EIGEN_DENSESTORAGEBASE_H void resize(NoChange_t, Index cols)
Definition: PlainObjectBase.h:334
RowsBlockXpr bottomRows(Index n)
Definition: DenseBase.h:489
PlainObjectBase(const ReturnByValue< OtherDerived > &other)
Copy constructor with in-place evaluation.
Definition: PlainObjectBase.h:553
Definition: Constants.h:326
const Scalar & coeffRef(Index rowId, Index colId) const
Definition: PlainObjectBase.h:204
Definition: PlainObjectBase.h:71
Derived & lazyAssign(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:465
A matrix or vector expression mapping an existing array of data.
Definition: Map.h:88
void conservativeResize(Index rows, Index cols)
Definition: PlainObjectBase.h:390
Namespace containing all symbols from the Eigen library.
Definition: Core:287
Holds strides information for Map.
Definition: Stride.h:44
Holds information about the various numeric (i.e. scalar) types allowed by Eigen. ...
Definition: NumTraits.h:150
Derived & derived()
Definition: EigenBase.h:45
Eigen::Index Index
The interface type of indices.
Definition: EigenBase.h:38
const unsigned int RowMajorBit
Definition: Constants.h:61
Base class for all dense matrices, vectors, and arrays.
Definition: DenseBase.h:41
void resize(Index rows, Index cols)
Definition: PlainObjectBase.h:279
PlainObjectBase(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:532
PlainObjectBase(const EigenBase< OtherDerived > &other)
Definition: PlainObjectBase.h:543
PlainObjectBase(const PlainObjectBase &other)
Definition: PlainObjectBase.h:519
Definition: EigenBase.h:29
Scalar * data()
Definition: PlainObjectBase.h:259
Scalar & coeffRef(Index rowId, Index colId)
Definition: PlainObjectBase.h:183
void conservativeResize(NoChange_t, Index cols)
Definition: PlainObjectBase.h:417
BlockXpr block(Index startRow, Index startCol, Index blockRows, Index blockCols)
Definition: DenseBase.h:65
void resizeLike(const EigenBase< OtherDerived > &_other)
Definition: PlainObjectBase.h:362
Index size() const
Definition: EigenBase.h:66
Index rows() const
Definition: EigenBase.h:59
Scalar & coeffRef(Index index)
Definition: PlainObjectBase.h:196
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:33
void resize(Index rows, NoChange_t)
Definition: PlainObjectBase.h:348
const Scalar & coeff(Index index) const
Definition: PlainObjectBase.h:173
Dense storage base class for matrices and arrays.
Definition: PlainObjectBase.h:95
Derived & operator=(const PlainObjectBase &other)
Definition: PlainObjectBase.h:457
Common base class for compact rotation representations.
Definition: ForwardDeclarations.h:266
BlockXpr bottomRightCorner(Index cRows, Index cCols)
Definition: DenseBase.h:264
Base class for all 1D and 2D array, and related expressions.
Definition: ArrayBase.h:39
const Scalar * data() const
Definition: PlainObjectBase.h:255
void conservativeResize(Index size)
Definition: PlainObjectBase.h:432
Definition: Eigen_Colamd.h:50
void resize(Index size)
Definition: PlainObjectBase.h:309
const Scalar & coeff(Index rowId, Index colId) const
Definition: PlainObjectBase.h:160
const Scalar & coeffRef(Index index) const
Definition: PlainObjectBase.h:215
General-purpose arrays with easy API for coefficient-wise operations.
Definition: Array.h:45
Definition: Constants.h:322
Definition: Constants.h:509
const int Dynamic
Definition: Constants.h:21
void conservativeResizeLike(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:448
SegmentReturnType tail(Index n)
Definition: DenseBase.h:950
The matrix class, also used for vectors and row-vectors.
Definition: Matrix.h:178
Index cols() const
Definition: EigenBase.h:62
void conservativeResize(Index rows, NoChange_t)
Definition: PlainObjectBase.h:403
Derived & _set(const DenseBase< OtherDerived > &other)
Copies the value of the expression other into *this with automatic resizing.
Definition: PlainObjectBase.h:708
Derived & operator=(const EigenBase< OtherDerived > &other)
Copies the generic expression other into *this.
Definition: PlainObjectBase.h:568
ColsBlockXpr rightCols(Index n)
Definition: DenseBase.h:659
Base class for all dense matrices, vectors, and expressions.
Definition: MatrixBase.h:48