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 = (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;
70 #ifdef EIGEN_PARSED_BY_DOXYGEN 78 template<
typename _Scalar,
int _Rows,
int _Cols,
int _Options,
int _MaxRows,
int _MaxCols>
80 :
public MatrixBase<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > {};
82 template<
typename _Scalar,
int _Rows,
int _Cols,
int _Options,
int _MaxRows,
int _MaxCols>
84 :
public ArrayBase<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > {};
88 template<
typename Derived>
91 template<typename Derived>
96 enum { Options = internal::traits<Derived>::Options };
97 typedef typename internal::dense_xpr_base<Derived>::type Base;
99 typedef typename internal::traits<Derived>::StorageKind StorageKind;
100 typedef typename internal::traits<Derived>::Scalar Scalar;
102 typedef typename internal::packet_traits<Scalar>::type PacketScalar;
104 typedef Derived DenseType;
106 using Base::RowsAtCompileTime;
107 using Base::ColsAtCompileTime;
108 using Base::SizeAtCompileTime;
109 using Base::MaxRowsAtCompileTime;
110 using Base::MaxColsAtCompileTime;
111 using Base::MaxSizeAtCompileTime;
112 using Base::IsVectorAtCompileTime;
115 template<
typename PlainObjectType,
int MapOptions,
typename Str
ideType>
friend class Eigen::Map;
120 #if EIGEN_MAX_ALIGN_BYTES>0 123 friend class Eigen::Map<const Derived, AlignedMax>;
133 DenseStorage<Scalar, Base::MaxSizeAtCompileTime, Base::RowsAtCompileTime, Base::ColsAtCompileTime, Options> m_storage;
136 enum { NeedsToAlign = (SizeAtCompileTime !=
Dynamic) && (internal::traits<Derived>::Alignment>0) };
137 EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign)
140 Base& base() {
return *
static_cast<Base*
>(
this); }
142 const Base& base()
const {
return *
static_cast<const Base*
>(
this); }
145 EIGEN_STRONG_INLINE
Index rows()
const {
return m_storage.rows(); }
147 EIGEN_STRONG_INLINE
Index cols()
const {
return m_storage.cols(); }
157 return m_storage.data()[colId + rowId * m_storage.cols()];
159 return m_storage.data()[rowId + colId * m_storage.rows()];
169 return m_storage.data()[index];
180 return m_storage.data()[colId + rowId * m_storage.cols()];
182 return m_storage.data()[rowId + colId * m_storage.rows()];
192 return m_storage.data()[index];
201 return m_storage.data()[colId + rowId * m_storage.cols()];
203 return m_storage.data()[rowId + colId * m_storage.rows()];
211 return m_storage.data()[index];
215 template<
int LoadMode>
216 EIGEN_STRONG_INLINE PacketScalar packet(
Index rowId,
Index colId)
const 218 return internal::ploadt<PacketScalar, LoadMode>
220 ? colId + rowId * m_storage.cols()
221 : rowId + colId * m_storage.rows()));
225 template<
int LoadMode>
226 EIGEN_STRONG_INLINE PacketScalar packet(
Index index)
const 228 return internal::ploadt<PacketScalar, LoadMode>(m_storage.data() + index);
232 template<
int StoreMode>
233 EIGEN_STRONG_INLINE
void writePacket(
Index rowId,
Index colId,
const PacketScalar& val)
235 internal::pstoret<Scalar, PacketScalar, StoreMode>
237 ? colId + rowId * m_storage.cols()
238 : rowId + colId * m_storage.rows()), val);
242 template<
int StoreMode>
243 EIGEN_STRONG_INLINE
void writePacket(
Index index,
const PacketScalar& val)
245 internal::pstoret<Scalar, PacketScalar, StoreMode>(m_storage.data() + index, val);
249 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
const Scalar *
data()
const 250 {
return m_storage.data(); }
254 {
return m_storage.data(); }
275 eigen_assert( EIGEN_IMPLIES(RowsAtCompileTime!=
Dynamic,rows==RowsAtCompileTime)
276 && EIGEN_IMPLIES(ColsAtCompileTime!=
Dynamic,cols==ColsAtCompileTime)
277 && EIGEN_IMPLIES(RowsAtCompileTime==
Dynamic && MaxRowsAtCompileTime!=
Dynamic,rows<=MaxRowsAtCompileTime)
278 && EIGEN_IMPLIES(ColsAtCompileTime==
Dynamic && MaxColsAtCompileTime!=
Dynamic,cols<=MaxColsAtCompileTime)
279 && rows>=0 && cols>=0 &&
"Invalid sizes when resizing a matrix or array.");
280 internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(rows, cols);
281 #ifdef EIGEN_INITIALIZE_COEFFS 282 Index size = rows*cols;
283 bool size_changed = size != this->size();
284 m_storage.resize(size, rows, cols);
285 if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
287 m_storage.resize(rows*cols, rows, cols);
306 eigen_assert(((SizeAtCompileTime ==
Dynamic && (MaxSizeAtCompileTime==
Dynamic || size<=MaxSizeAtCompileTime)) || SizeAtCompileTime == size) && size>=0);
307 #ifdef EIGEN_INITIALIZE_COEFFS 308 bool size_changed = size != this->size();
310 if(RowsAtCompileTime == 1)
311 m_storage.resize(size, 1, size);
313 m_storage.resize(size, size, 1);
314 #ifdef EIGEN_INITIALIZE_COEFFS 315 if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
354 template<
typename OtherDerived>
358 const OtherDerived& other = _other.
derived();
359 internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(other.rows(), other.cols());
360 const Index othersize = other.rows()*other.cols();
361 if(RowsAtCompileTime == 1)
363 eigen_assert(other.rows() == 1 || other.cols() == 1);
366 else if(ColsAtCompileTime == 1)
368 eigen_assert(other.rows() == 1 || other.cols() == 1);
371 else resize(other.rows(), other.cols());
386 internal::conservative_resize_like_impl<Derived>::run(*
this, rows, cols);
428 internal::conservative_resize_like_impl<Derived>::run(*
this, size);
440 template<
typename OtherDerived>
444 internal::conservative_resize_like_impl<Derived,OtherDerived>::run(*
this, other);
457 template<
typename OtherDerived>
461 _resize_to_match(other);
462 return Base::lazyAssign(other.
derived());
465 template<
typename OtherDerived>
467 EIGEN_STRONG_INLINE Derived&
operator=(
const ReturnByValue<OtherDerived>& func)
469 resize(func.rows(), func.cols());
470 return Base::operator=(func);
478 EIGEN_STRONG_INLINE PlainObjectBase() : m_storage()
484 #ifndef EIGEN_PARSED_BY_DOXYGEN 488 explicit PlainObjectBase(internal::constructor_without_unaligned_array_assert)
489 : m_storage(
internal::constructor_without_unaligned_array_assert())
495 #if EIGEN_HAS_RVALUE_REFERENCES 497 PlainObjectBase(PlainObjectBase&& other) EIGEN_NOEXCEPT
498 : m_storage( std::move(other.m_storage) )
503 PlainObjectBase&
operator=(PlainObjectBase&& other) EIGEN_NOEXCEPT
506 swap(m_storage, other.m_storage);
514 : Base(), m_storage(other.m_storage) { }
517 : m_storage(size, rows, cols)
524 template<
typename OtherDerived>
529 _check_template_params();
535 template<
typename OtherDerived>
540 _check_template_params();
545 template<
typename OtherDerived>
549 _check_template_params();
551 resize(other.rows(), other.cols());
552 other.evalTo(this->derived());
559 template<
typename OtherDerived>
563 _resize_to_match(other);
564 Base::operator=(other.
derived());
565 return this->derived();
576 static inline ConstMapType
Map(
const Scalar*
data)
577 {
return ConstMapType(
data); }
578 static inline MapType Map(Scalar*
data)
579 {
return MapType(
data); }
580 static inline ConstMapType Map(
const Scalar*
data,
Index size)
581 {
return ConstMapType(
data, size); }
582 static inline MapType Map(Scalar*
data,
Index size)
583 {
return MapType(
data, size); }
584 static inline ConstMapType Map(
const Scalar*
data,
Index rows,
Index cols)
585 {
return ConstMapType(
data, rows, cols); }
587 {
return MapType(
data, rows, cols); }
589 static inline ConstAlignedMapType MapAligned(
const Scalar*
data)
590 {
return ConstAlignedMapType(
data); }
591 static inline AlignedMapType MapAligned(Scalar*
data)
592 {
return AlignedMapType(
data); }
593 static inline ConstAlignedMapType MapAligned(
const Scalar*
data,
Index size)
594 {
return ConstAlignedMapType(
data, size); }
595 static inline AlignedMapType MapAligned(Scalar*
data,
Index size)
596 {
return AlignedMapType(
data, size); }
597 static inline ConstAlignedMapType MapAligned(
const Scalar*
data,
Index rows,
Index cols)
598 {
return ConstAlignedMapType(
data, rows, cols); }
599 static inline AlignedMapType MapAligned(Scalar*
data,
Index rows,
Index cols)
600 {
return AlignedMapType(
data, rows, cols); }
602 template<
int Outer,
int Inner>
603 static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(
const Scalar*
data,
const Stride<Outer, Inner>& stride)
604 {
return typename StridedConstMapType<Stride<Outer, Inner> >::type(
data, stride); }
605 template<
int Outer,
int Inner>
606 static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar*
data,
const Stride<Outer, Inner>& stride)
607 {
return typename StridedMapType<Stride<Outer, Inner> >::type(
data, stride); }
608 template<
int Outer,
int Inner>
609 static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(
const Scalar*
data,
Index size,
const Stride<Outer, Inner>& stride)
610 {
return typename StridedConstMapType<Stride<Outer, Inner> >::type(
data, size, stride); }
611 template<
int Outer,
int Inner>
612 static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar*
data,
Index size,
const Stride<Outer, Inner>& stride)
613 {
return typename StridedMapType<Stride<Outer, Inner> >::type(
data, size, stride); }
614 template<
int Outer,
int Inner>
615 static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(
const Scalar*
data,
Index rows,
Index cols,
const Stride<Outer, Inner>& stride)
616 {
return typename StridedConstMapType<Stride<Outer, Inner> >::type(
data, rows, cols, stride); }
617 template<
int Outer,
int Inner>
618 static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar*
data,
Index rows,
Index cols,
const Stride<Outer, Inner>& stride)
619 {
return typename StridedMapType<Stride<Outer, Inner> >::type(
data, rows, cols, stride); }
621 template<
int Outer,
int Inner>
622 static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(
const Scalar*
data,
const Stride<Outer, Inner>& stride)
623 {
return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(
data, stride); }
624 template<
int Outer,
int Inner>
625 static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar*
data,
const Stride<Outer, Inner>& stride)
626 {
return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(
data, stride); }
627 template<
int Outer,
int Inner>
628 static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(
const Scalar*
data,
Index size,
const Stride<Outer, Inner>& stride)
629 {
return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(
data, size, stride); }
630 template<
int Outer,
int Inner>
631 static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar*
data,
Index size,
const Stride<Outer, Inner>& stride)
632 {
return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(
data, size, stride); }
633 template<
int Outer,
int Inner>
634 static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(
const Scalar*
data,
Index rows,
Index cols,
const Stride<Outer, Inner>& stride)
635 {
return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(
data, rows, cols, stride); }
636 template<
int Outer,
int Inner>
637 static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar*
data,
Index rows,
Index cols,
const Stride<Outer, Inner>& stride)
638 {
return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(
data, rows, cols, stride); }
641 using Base::setConstant;
653 using Base::setRandom;
657 #ifdef EIGEN_PLAINOBJECTBASE_PLUGIN 658 #include EIGEN_PLAINOBJECTBASE_PLUGIN 669 template<
typename OtherDerived>
671 EIGEN_STRONG_INLINE
void _resize_to_match(
const EigenBase<OtherDerived>& other)
673 #ifdef EIGEN_NO_AUTOMATIC_RESIZING 674 eigen_assert((this->size()==0 || (IsVectorAtCompileTime ? (this->size() == other.size())
675 : (rows() == other.rows() && cols() == other.cols())))
676 &&
"Size mismatch. Automatic resizing is disabled because EIGEN_NO_AUTOMATIC_RESIZING is defined");
677 EIGEN_ONLY_USED_FOR_DEBUG(other);
699 template<
typename OtherDerived>
703 internal::call_assignment(this->derived(), other.
derived());
704 return this->derived();
712 template<
typename OtherDerived>
721 internal::call_assignment_no_alias(this->derived(), other.
derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
722 return this->derived();
725 template<
typename T0,
typename T1>
727 EIGEN_STRONG_INLINE
void _init2(
Index rows,
Index cols,
typename internal::enable_if<Base::SizeAtCompileTime!=2,T0>::type* = 0)
729 EIGEN_STATIC_ASSERT(
bool(NumTraits<T0>::IsInteger) &&
730 bool(NumTraits<T1>::IsInteger),
731 FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
735 template<
typename T0,
typename T1>
737 EIGEN_STRONG_INLINE
void _init2(
const T0& val0,
const T1& val1,
typename internal::enable_if<Base::SizeAtCompileTime==2,T0>::type* = 0)
739 EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
740 m_storage.
data()[0] = Scalar(val0);
741 m_storage.
data()[1] = Scalar(val1);
744 template<typename T0, typename T1>
746 EIGEN_STRONG_INLINE
void _init2(const
Index& val0, const
Index& val1,
750 && Base::SizeAtCompileTime==2,T1>::type* = 0)
752 EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
753 m_storage.
data()[0] = Scalar(val0);
754 m_storage.
data()[1] = Scalar(val1);
761 EIGEN_STRONG_INLINE
void _init1(
Index size, typename
internal::enable_if< (Base::SizeAtCompileTime!=1 || !
internal::is_convertible<T, Scalar>::value)
762 && ((!
internal::is_same<typename
internal::traits<Derived>::XprKind,ArrayXpr>::value || Base::SizeAtCompileTime==
Dynamic)),T>::type* = 0)
765 const bool is_integer = NumTraits<T>::IsInteger;
766 EIGEN_STATIC_ASSERT(is_integer,
767 FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
774 EIGEN_STRONG_INLINE
void _init1(
const Scalar& val0,
typename internal::enable_if<Base::SizeAtCompileTime==1 && internal::is_convertible<T, Scalar>::value,T>::type* = 0)
776 EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 1)
777 m_storage.
data()[0] = val0;
783 EIGEN_STRONG_INLINE
void _init1(const
Index& val0,
786 && Base::SizeAtCompileTime==1
787 &&
internal::is_convertible<T, Scalar>::value,T*>::type* = 0)
789 EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 1)
790 m_storage.
data()[0] = Scalar(val0);
796 EIGEN_STRONG_INLINE
void _init1(const Scalar*
data){
797 this->_set_noalias(ConstMapType(
data));
801 template<
typename T,
typename OtherDerived>
803 EIGEN_STRONG_INLINE
void _init1(
const DenseBase<OtherDerived>& other){
804 this->_set_noalias(other);
808 template<
typename T,
typename OtherDerived>
810 EIGEN_STRONG_INLINE
void _init1(
const EigenBase<OtherDerived>& other){
811 this->derived() = other;
814 template<
typename T,
typename OtherDerived>
816 EIGEN_STRONG_INLINE
void _init1(
const ReturnByValue<OtherDerived>& other)
818 resize(other.rows(), other.cols());
819 other.evalTo(this->derived());
822 template<
typename T,
typename OtherDerived,
int ColsAtCompileTime>
824 EIGEN_STRONG_INLINE
void _init1(
const RotationBase<OtherDerived,ColsAtCompileTime>& r)
832 EIGEN_STRONG_INLINE
void _init1(
const Scalar& val0,
833 typename internal::enable_if< Base::SizeAtCompileTime!=
Dynamic 834 && Base::SizeAtCompileTime!=1
835 && internal::is_convertible<T, Scalar>::value
836 && internal::is_same<
typename internal::traits<Derived>::XprKind,ArrayXpr>::value,T>::type* = 0)
838 Base::setConstant(val0);
843 EIGEN_STRONG_INLINE
void _init1(
const Index& val0,
844 typename internal::enable_if< (!internal::is_same<Index,Scalar>::value)
845 && (internal::is_same<Index,T>::value)
846 && Base::SizeAtCompileTime!=
Dynamic 847 && Base::SizeAtCompileTime!=1
848 && internal::is_convertible<T, Scalar>::value
849 && internal::is_same<
typename internal::traits<Derived>::XprKind,ArrayXpr>::value,T*>::type* = 0)
851 Base::setConstant(val0);
854 template<
typename MatrixTypeA,
typename MatrixTypeB,
bool SwapPo
inters>
855 friend struct internal::matrix_swap_impl;
859 #ifndef EIGEN_PARSED_BY_DOXYGEN 864 template<
typename OtherDerived>
866 void swap(DenseBase<OtherDerived> & other)
868 enum { SwapPointers = internal::is_same<Derived, OtherDerived>::value && Base::SizeAtCompileTime==
Dynamic };
869 internal::matrix_swap_impl<Derived, OtherDerived, bool(SwapPointers)>::run(this->derived(), other.derived());
875 template<
typename OtherDerived>
877 void swap(DenseBase<OtherDerived>
const & other)
878 { Base::swap(other.derived()); }
881 static EIGEN_STRONG_INLINE
void _check_template_params()
883 EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, (Options&
RowMajor)==
RowMajor)
884 && EIGEN_IMPLIES(MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1, (Options&
RowMajor)==0)
885 && ((RowsAtCompileTime ==
Dynamic) || (RowsAtCompileTime >= 0))
886 && ((ColsAtCompileTime ==
Dynamic) || (ColsAtCompileTime >= 0))
887 && ((MaxRowsAtCompileTime ==
Dynamic) || (MaxRowsAtCompileTime >= 0))
888 && ((MaxColsAtCompileTime ==
Dynamic) || (MaxColsAtCompileTime >= 0))
889 && (MaxRowsAtCompileTime == RowsAtCompileTime || RowsAtCompileTime==
Dynamic)
890 && (MaxColsAtCompileTime == ColsAtCompileTime || ColsAtCompileTime==
Dynamic)
892 INVALID_MATRIX_TEMPLATE_PARAMETERS)
895 enum { IsPlainObjectBase = 1 };
901 template <
typename Derived,
typename OtherDerived,
bool IsVector>
902 struct conservative_resize_like_impl
904 static void run(DenseBase<Derived>& _this,
Index rows,
Index cols)
906 if (_this.rows() == rows && _this.cols() == cols)
return;
907 EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
909 if ( ( Derived::IsRowMajor && _this.cols() == cols) ||
910 (!Derived::IsRowMajor && _this.rows() == rows) )
912 internal::check_rows_cols_for_overflow<Derived::MaxSizeAtCompileTime>::run(rows, cols);
913 _this.derived().m_storage.conservativeResize(rows*cols,rows,cols);
918 typename Derived::PlainObject tmp(rows,cols);
919 const Index common_rows = numext::mini(rows, _this.rows());
920 const Index common_cols = numext::mini(cols, _this.cols());
921 tmp.block(0,0,common_rows,common_cols) = _this.block(0,0,common_rows,common_cols);
922 _this.derived().swap(tmp);
926 static void run(DenseBase<Derived>& _this,
const DenseBase<OtherDerived>& other)
928 if (_this.rows() == other.rows() && _this.cols() == other.cols())
return;
935 EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
936 EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(OtherDerived)
938 if ( ( Derived::IsRowMajor && _this.cols() == other.cols()) ||
939 (!Derived::IsRowMajor && _this.rows() == other.rows()) )
941 const Index new_rows = other.rows() - _this.rows();
942 const Index new_cols = other.cols() - _this.cols();
943 _this.derived().m_storage.conservativeResize(other.size(),other.rows(),other.cols());
945 _this.bottomRightCorner(new_rows, other.cols()) = other.bottomRows(new_rows);
947 _this.bottomRightCorner(other.rows(), new_cols) = other.rightCols(new_cols);
952 typename Derived::PlainObject tmp(other);
953 const Index common_rows = numext::mini(tmp.rows(), _this.rows());
954 const Index common_cols = numext::mini(tmp.cols(), _this.cols());
955 tmp.block(0,0,common_rows,common_cols) = _this.block(0,0,common_rows,common_cols);
956 _this.derived().swap(tmp);
963 template <
typename Derived,
typename OtherDerived>
964 struct conservative_resize_like_impl<Derived,OtherDerived,true>
965 : conservative_resize_like_impl<Derived,OtherDerived,false>
967 using conservative_resize_like_impl<Derived,OtherDerived,false>::run;
969 static void run(DenseBase<Derived>& _this,
Index size)
971 const Index new_rows = Derived::RowsAtCompileTime==1 ? 1 : size;
972 const Index new_cols = Derived::RowsAtCompileTime==1 ? size : 1;
973 _this.derived().m_storage.conservativeResize(size,new_rows,new_cols);
976 static void run(DenseBase<Derived>& _this,
const DenseBase<OtherDerived>& other)
978 if (_this.rows() == other.rows() && _this.cols() == other.cols())
return;
980 const Index num_new_elements = other.size() - _this.size();
982 const Index new_rows = Derived::RowsAtCompileTime==1 ? 1 : other.rows();
983 const Index new_cols = Derived::RowsAtCompileTime==1 ? other.cols() : 1;
984 _this.derived().m_storage.conservativeResize(other.size(),new_rows,new_cols);
986 if (num_new_elements > 0)
987 _this.tail(num_new_elements) = other.tail(num_new_elements);
991 template<
typename MatrixTypeA,
typename MatrixTypeB,
bool SwapPo
inters>
992 struct matrix_swap_impl
995 static inline void run(MatrixTypeA& a, MatrixTypeB& b)
1001 template<
typename MatrixTypeA,
typename MatrixTypeB>
1002 struct matrix_swap_impl<MatrixTypeA, MatrixTypeB, true>
1005 static inline void run(MatrixTypeA& a, MatrixTypeB& b)
1007 static_cast<typename MatrixTypeA::Base&
>(a).m_storage.swap(static_cast<typename MatrixTypeB::Base&>(b).m_storage);
1015 #endif // EIGEN_DENSESTORAGEBASE_H void resize(NoChange_t, Index cols)
Definition: PlainObjectBase.h:328
internal::traits< Derived >::Scalar Scalar
Definition: DenseBase.h:66
PlainObjectBase(const ReturnByValue< OtherDerived > &other)
Copy constructor with in-place evaluation.
Definition: PlainObjectBase.h:547
Definition: Constants.h:326
const Scalar & coeffRef(Index rowId, Index colId) const
Definition: PlainObjectBase.h:198
Definition: PlainObjectBase.h:76
Derived & lazyAssign(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:459
A matrix or vector expression mapping an existing array of data.
Definition: Map.h:88
void conservativeResize(Index rows, Index cols)
Definition: PlainObjectBase.h:384
Derived & setRandom(Index size)
Definition: Random.h:151
Namespace containing all symbols from the Eigen library.
Definition: Core:287
Holds information about the various numeric (i.e. scalar) types allowed by Eigen. ...
Definition: NumTraits.h:150
Derived & derived()
Definition: EigenBase.h:44
Eigen::Index Index
The interface type of indices.
Definition: EigenBase.h:37
Definition: Constants.h:228
const unsigned int RowMajorBit
Definition: Constants.h:61
Base class for all dense matrices, vectors, and arrays.
Definition: DenseBase.h:41
void resize(Index rows, Index cols)
Definition: PlainObjectBase.h:273
PlainObjectBase(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:526
PlainObjectBase(const EigenBase< OtherDerived > &other)
Definition: PlainObjectBase.h:537
PlainObjectBase(const PlainObjectBase &other)
Definition: PlainObjectBase.h:513
Definition: EigenBase.h:28
Scalar * data()
Definition: PlainObjectBase.h:253
Derived & setOnes(Index size)
Definition: CwiseNullaryOp.h:641
Scalar & coeffRef(Index rowId, Index colId)
Definition: PlainObjectBase.h:177
void conservativeResize(NoChange_t, Index cols)
Definition: PlainObjectBase.h:411
Derived & setZero(Index size)
Definition: CwiseNullaryOp.h:515
void resizeLike(const EigenBase< OtherDerived > &_other)
Definition: PlainObjectBase.h:356
Scalar & coeffRef(Index index)
Definition: PlainObjectBase.h:190
Derived & derived()
Definition: EigenBase.h:44
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:342
const Scalar & coeff(Index index) const
Definition: PlainObjectBase.h:167
Dense storage base class for matrices and arrays.
Definition: PlainObjectBase.h:89
Derived & operator=(const PlainObjectBase &other)
Definition: PlainObjectBase.h:451
Base class for all 1D and 2D array, and related expressions.
Definition: ArrayBase.h:39
Derived & setConstant(Index size, const Scalar &val)
Definition: CwiseNullaryOp.h:341
const Scalar * data() const
Definition: PlainObjectBase.h:249
void conservativeResize(Index size)
Definition: PlainObjectBase.h:426
Definition: Eigen_Colamd.h:50
void resize(Index size)
Definition: PlainObjectBase.h:303
const Scalar & coeff(Index rowId, Index colId) const
Definition: PlainObjectBase.h:154
const Scalar & coeffRef(Index index) const
Definition: PlainObjectBase.h:209
General-purpose arrays with easy API for coefficient-wise operations.
Definition: Array.h:45
Definition: Constants.h:322
const int Dynamic
Definition: Constants.h:21
void conservativeResizeLike(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:442
The matrix class, also used for vectors and row-vectors.
Definition: Matrix.h:178
void conservativeResize(Index rows, NoChange_t)
Definition: PlainObjectBase.h:397
Derived & _set(const DenseBase< OtherDerived > &other)
Copies the value of the expression other into *this with automatic resizing.
Definition: PlainObjectBase.h:701
Derived & operator=(const EigenBase< OtherDerived > &other)
Copies the generic expression other into *this.
Definition: PlainObjectBase.h:561
Base class for all dense matrices, vectors, and expressions.
Definition: MatrixBase.h:48