Eigen  3.3.0
 
Loading...
Searching...
No Matches
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
25namespace Eigen {
26
27namespace internal {
28
29template<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
37template<> 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 = (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
52template <typename Derived,
53 typename OtherDerived = Derived,
54 bool IsVector = bool(Derived::IsVectorAtCompileTime) && bool(OtherDerived::IsVectorAtCompileTime)>
55struct conservative_resize_like_impl;
56
57template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers> struct matrix_swap_impl;
58
59} // end namespace internal
60
70#ifdef EIGEN_PARSED_BY_DOXYGEN
71namespace doxygen {
72
73// this is a workaround to doxygen not being able to understand the inheritance logic
74// when it is hidden by the dense_xpr_base helper struct.
76template<typename Derived> struct dense_xpr_base_dispatcher;
78template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
79struct dense_xpr_base_dispatcher<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
80 : public MatrixBase<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > {};
82template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
83struct dense_xpr_base_dispatcher<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
84 : public ArrayBase<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > {};
85
86} // namespace doxygen
87
88template<typename Derived>
90#else
91template<typename Derived>
92class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
93#endif
94{
95 public:
96 enum { Options = internal::traits<Derived>::Options };
97 typedef typename internal::dense_xpr_base<Derived>::type Base;
98
99 typedef typename internal::traits<Derived>::StorageKind StorageKind;
100 typedef typename internal::traits<Derived>::Scalar Scalar;
101
102 typedef typename internal::packet_traits<Scalar>::type PacketScalar;
103 typedef typename NumTraits<Scalar>::Real RealScalar;
104 typedef Derived DenseType;
105
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;
113 using Base::Flags;
114
115 template<typename PlainObjectType, int MapOptions, typename StrideType> friend class Eigen::Map;
116 friend class Eigen::Map<Derived, Unaligned>;
118 friend class Eigen::Map<const Derived, Unaligned>;
120#if EIGEN_MAX_ALIGN_BYTES>0
121 // for EIGEN_MAX_ALIGN_BYTES==0, AlignedMax==Unaligned, and many compilers generate warnings for friend-ing a class twice.
122 friend class Eigen::Map<Derived, AlignedMax>;
123 friend class Eigen::Map<const Derived, AlignedMax>;
124#endif
127 template<typename StrideType> struct StridedMapType { typedef Eigen::Map<Derived, Unaligned, StrideType> type; };
128 template<typename StrideType> struct StridedConstMapType { typedef Eigen::Map<const Derived, Unaligned, StrideType> type; };
129 template<typename StrideType> struct StridedAlignedMapType { typedef Eigen::Map<Derived, AlignedMax, StrideType> type; };
130 template<typename StrideType> struct StridedConstAlignedMapType { typedef Eigen::Map<const Derived, AlignedMax, StrideType> type; };
131
132 protected:
133 DenseStorage<Scalar, Base::MaxSizeAtCompileTime, Base::RowsAtCompileTime, Base::ColsAtCompileTime, Options> m_storage;
134
135 public:
136 enum { NeedsToAlign = (SizeAtCompileTime != Dynamic) && (internal::traits<Derived>::Alignment>0) };
137 EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign)
138
139 EIGEN_DEVICE_FUNC
140 Base& base() { return *static_cast<Base*>(this); }
141 EIGEN_DEVICE_FUNC
142 const Base& base() const { return *static_cast<const Base*>(this); }
143
144 EIGEN_DEVICE_FUNC
145 EIGEN_STRONG_INLINE Index rows() const { return m_storage.rows(); }
146 EIGEN_DEVICE_FUNC
147 EIGEN_STRONG_INLINE Index cols() const { return m_storage.cols(); }
148
153 EIGEN_DEVICE_FUNC
154 EIGEN_STRONG_INLINE const Scalar& coeff(Index rowId, Index colId) const
155 {
156 if(Flags & RowMajorBit)
157 return m_storage.data()[colId + rowId * m_storage.cols()];
158 else // column-major
159 return m_storage.data()[rowId + colId * m_storage.rows()];
160 }
161
166 EIGEN_DEVICE_FUNC
167 EIGEN_STRONG_INLINE const Scalar& coeff(Index index) const
168 {
169 return m_storage.data()[index];
170 }
171
176 EIGEN_DEVICE_FUNC
177 EIGEN_STRONG_INLINE Scalar& coeffRef(Index rowId, Index colId)
178 {
179 if(Flags & RowMajorBit)
180 return m_storage.data()[colId + rowId * m_storage.cols()];
181 else // column-major
182 return m_storage.data()[rowId + colId * m_storage.rows()];
183 }
184
189 EIGEN_DEVICE_FUNC
190 EIGEN_STRONG_INLINE Scalar& coeffRef(Index index)
191 {
192 return m_storage.data()[index];
193 }
194
197 EIGEN_DEVICE_FUNC
198 EIGEN_STRONG_INLINE const Scalar& coeffRef(Index rowId, Index colId) const
199 {
200 if(Flags & RowMajorBit)
201 return m_storage.data()[colId + rowId * m_storage.cols()];
202 else // column-major
203 return m_storage.data()[rowId + colId * m_storage.rows()];
204 }
205
208 EIGEN_DEVICE_FUNC
209 EIGEN_STRONG_INLINE const Scalar& coeffRef(Index index) const
210 {
211 return m_storage.data()[index];
212 }
213
215 template<int LoadMode>
216 EIGEN_STRONG_INLINE PacketScalar packet(Index rowId, Index colId) const
217 {
218 return internal::ploadt<PacketScalar, LoadMode>
219 (m_storage.data() + (Flags & RowMajorBit
220 ? colId + rowId * m_storage.cols()
221 : rowId + colId * m_storage.rows()));
222 }
223
225 template<int LoadMode>
226 EIGEN_STRONG_INLINE PacketScalar packet(Index index) const
227 {
228 return internal::ploadt<PacketScalar, LoadMode>(m_storage.data() + index);
229 }
230
232 template<int StoreMode>
233 EIGEN_STRONG_INLINE void writePacket(Index rowId, Index colId, const PacketScalar& val)
234 {
235 internal::pstoret<Scalar, PacketScalar, StoreMode>
236 (m_storage.data() + (Flags & RowMajorBit
237 ? colId + rowId * m_storage.cols()
238 : rowId + colId * m_storage.rows()), val);
239 }
240
242 template<int StoreMode>
243 EIGEN_STRONG_INLINE void writePacket(Index index, const PacketScalar& val)
244 {
245 internal::pstoret<Scalar, PacketScalar, StoreMode>(m_storage.data() + index, val);
246 }
247
249 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar *data() const
250 { return m_storage.data(); }
251
253 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar *data()
254 { return m_storage.data(); }
255
272 EIGEN_DEVICE_FUNC
273 EIGEN_STRONG_INLINE void resize(Index rows, Index cols)
274 {
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
286 #else
287 m_storage.resize(rows*cols, rows, cols);
288 #endif
289 }
290
302 EIGEN_DEVICE_FUNC
303 inline void resize(Index size)
304 {
305 EIGEN_STATIC_ASSERT_VECTOR_ONLY(PlainObjectBase)
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();
309 #endif
310 if(RowsAtCompileTime == 1)
311 m_storage.resize(size, 1, size);
312 else
313 m_storage.resize(size, size, 1);
314 #ifdef EIGEN_INITIALIZE_COEFFS
315 if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
316 #endif
317 }
318
327 EIGEN_DEVICE_FUNC
328 inline void resize(NoChange_t, Index cols)
329 {
330 resize(rows(), cols);
331 }
332
341 EIGEN_DEVICE_FUNC
342 inline void resize(Index rows, NoChange_t)
343 {
344 resize(rows, cols());
345 }
346
354 template<typename OtherDerived>
355 EIGEN_DEVICE_FUNC
356 EIGEN_STRONG_INLINE void resizeLike(const EigenBase<OtherDerived>& _other)
357 {
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)
362 {
363 eigen_assert(other.rows() == 1 || other.cols() == 1);
364 resize(1, othersize);
365 }
366 else if(ColsAtCompileTime == 1)
367 {
368 eigen_assert(other.rows() == 1 || other.cols() == 1);
369 resize(othersize, 1);
370 }
371 else resize(other.rows(), other.cols());
372 }
373
383 EIGEN_DEVICE_FUNC
384 EIGEN_STRONG_INLINE void conservativeResize(Index rows, Index cols)
385 {
386 internal::conservative_resize_like_impl<Derived>::run(*this, rows, cols);
387 }
388
396 EIGEN_DEVICE_FUNC
397 EIGEN_STRONG_INLINE void conservativeResize(Index rows, NoChange_t)
398 {
399 // Note: see the comment in conservativeResize(Index,Index)
400 conservativeResize(rows, cols());
401 }
402
410 EIGEN_DEVICE_FUNC
411 EIGEN_STRONG_INLINE void conservativeResize(NoChange_t, Index cols)
412 {
413 // Note: see the comment in conservativeResize(Index,Index)
414 conservativeResize(rows(), cols);
415 }
416
425 EIGEN_DEVICE_FUNC
426 EIGEN_STRONG_INLINE void conservativeResize(Index size)
427 {
428 internal::conservative_resize_like_impl<Derived>::run(*this, size);
429 }
430
440 template<typename OtherDerived>
441 EIGEN_DEVICE_FUNC
442 EIGEN_STRONG_INLINE void conservativeResizeLike(const DenseBase<OtherDerived>& other)
443 {
444 internal::conservative_resize_like_impl<Derived,OtherDerived>::run(*this, other);
445 }
446
450 EIGEN_DEVICE_FUNC
451 EIGEN_STRONG_INLINE Derived& operator=(const PlainObjectBase& other)
452 {
453 return _set(other);
454 }
455
457 template<typename OtherDerived>
458 EIGEN_DEVICE_FUNC
459 EIGEN_STRONG_INLINE Derived& lazyAssign(const DenseBase<OtherDerived>& other)
460 {
461 _resize_to_match(other);
462 return Base::lazyAssign(other.derived());
463 }
464
465 template<typename OtherDerived>
466 EIGEN_DEVICE_FUNC
467 EIGEN_STRONG_INLINE Derived& operator=(const ReturnByValue<OtherDerived>& func)
468 {
469 resize(func.rows(), func.cols());
470 return Base::operator=(func);
471 }
472
473 // Prevent user from trying to instantiate PlainObjectBase objects
474 // by making all its constructor protected. See bug 1074.
475 protected:
476
477 EIGEN_DEVICE_FUNC
478 EIGEN_STRONG_INLINE PlainObjectBase() : m_storage()
479 {
480// _check_template_params();
481// EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
482 }
483
484#ifndef EIGEN_PARSED_BY_DOXYGEN
485 // FIXME is it still needed ?
487 EIGEN_DEVICE_FUNC
488 explicit PlainObjectBase(internal::constructor_without_unaligned_array_assert)
489 : m_storage(internal::constructor_without_unaligned_array_assert())
490 {
491// _check_template_params(); EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
492 }
493#endif
494
495#if EIGEN_HAS_RVALUE_REFERENCES
496 EIGEN_DEVICE_FUNC
497 PlainObjectBase(PlainObjectBase&& other) EIGEN_NOEXCEPT
498 : m_storage( std::move(other.m_storage) )
499 {
500 }
501
502 EIGEN_DEVICE_FUNC
503 PlainObjectBase& operator=(PlainObjectBase&& other) EIGEN_NOEXCEPT
504 {
505 using std::swap;
506 swap(m_storage, other.m_storage);
507 return *this;
508 }
509#endif
510
512 EIGEN_DEVICE_FUNC
513 EIGEN_STRONG_INLINE PlainObjectBase(const PlainObjectBase& other)
514 : Base(), m_storage(other.m_storage) { }
515 EIGEN_DEVICE_FUNC
516 EIGEN_STRONG_INLINE PlainObjectBase(Index size, Index rows, Index cols)
517 : m_storage(size, rows, cols)
518 {
519// _check_template_params();
520// EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
521 }
522
524 template<typename OtherDerived>
525 EIGEN_DEVICE_FUNC
526 EIGEN_STRONG_INLINE PlainObjectBase(const DenseBase<OtherDerived> &other)
527 : m_storage()
528 {
529 _check_template_params();
530 resizeLike(other);
531 _set_noalias(other);
532 }
533
535 template<typename OtherDerived>
536 EIGEN_DEVICE_FUNC
537 EIGEN_STRONG_INLINE PlainObjectBase(const EigenBase<OtherDerived> &other)
538 : m_storage()
539 {
540 _check_template_params();
541 resizeLike(other);
542 *this = other.derived();
543 }
545 template<typename OtherDerived>
546 EIGEN_DEVICE_FUNC
547 EIGEN_STRONG_INLINE PlainObjectBase(const ReturnByValue<OtherDerived>& other)
548 {
549 _check_template_params();
550 // FIXME this does not automatically transpose vectors if necessary
551 resize(other.rows(), other.cols());
552 other.evalTo(this->derived());
553 }
554
555 public:
556
559 template<typename OtherDerived>
560 EIGEN_DEVICE_FUNC
561 EIGEN_STRONG_INLINE Derived& operator=(const EigenBase<OtherDerived> &other)
562 {
563 _resize_to_match(other);
564 Base::operator=(other.derived());
565 return this->derived();
566 }
567
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); }
586 static inline MapType Map(Scalar* data, Index rows, Index cols)
587 { return MapType(data, rows, cols); }
588
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); }
601
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); }
620
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); }
640
641 using Base::setConstant;
642 EIGEN_DEVICE_FUNC Derived& setConstant(Index size, const Scalar& val);
643 EIGEN_DEVICE_FUNC Derived& setConstant(Index rows, Index cols, const Scalar& val);
644
645 using Base::setZero;
646 EIGEN_DEVICE_FUNC Derived& setZero(Index size);
647 EIGEN_DEVICE_FUNC Derived& setZero(Index rows, Index cols);
648
649 using Base::setOnes;
650 EIGEN_DEVICE_FUNC Derived& setOnes(Index size);
651 EIGEN_DEVICE_FUNC Derived& setOnes(Index rows, Index cols);
652
653 using Base::setRandom;
654 Derived& setRandom(Index size);
655 Derived& setRandom(Index rows, Index cols);
656
657 #ifdef EIGEN_PLAINOBJECTBASE_PLUGIN
658 #include EIGEN_PLAINOBJECTBASE_PLUGIN
659 #endif
660
661 protected:
669 template<typename OtherDerived>
670 EIGEN_DEVICE_FUNC
671 EIGEN_STRONG_INLINE void _resize_to_match(const EigenBase<OtherDerived>& other)
672 {
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);
678 #else
679 resizeLike(other);
680 #endif
681 }
682
697 // aliasing is dealt once in internall::call_assignment
698 // so at this stage we have to assume aliasing... and resising has to be done later.
699 template<typename OtherDerived>
700 EIGEN_DEVICE_FUNC
701 EIGEN_STRONG_INLINE Derived& _set(const DenseBase<OtherDerived>& other)
702 {
703 internal::call_assignment(this->derived(), other.derived());
704 return this->derived();
705 }
706
712 template<typename OtherDerived>
713 EIGEN_DEVICE_FUNC
714 EIGEN_STRONG_INLINE Derived& _set_noalias(const DenseBase<OtherDerived>& other)
715 {
716 // I don't think we need this resize call since the lazyAssign will anyways resize
717 // and lazyAssign will be called by the assign selector.
718 //_resize_to_match(other);
719 // the 'false' below means to enforce lazy evaluation. We don't use lazyAssign() because
720 // it wouldn't allow to copy a row-vector into a column-vector.
721 internal::call_assignment_no_alias(this->derived(), other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
722 return this->derived();
723 }
724
725 template<typename T0, typename T1>
726 EIGEN_DEVICE_FUNC
727 EIGEN_STRONG_INLINE void _init2(Index rows, Index cols, typename internal::enable_if<Base::SizeAtCompileTime!=2,T0>::type* = 0)
728 {
729 EIGEN_STATIC_ASSERT(bool(NumTraits<T0>::IsInteger) &&
731 FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
732 resize(rows,cols);
733 }
734
735 template<typename T0, typename T1>
736 EIGEN_DEVICE_FUNC
737 EIGEN_STRONG_INLINE void _init2(const T0& val0, const T1& val1, typename internal::enable_if<Base::SizeAtCompileTime==2,T0>::type* = 0)
738 {
739 EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
740 m_storage.data()[0] = Scalar(val0);
741 m_storage.data()[1] = Scalar(val1);
742 }
743
744 template<typename T0, typename T1>
745 EIGEN_DEVICE_FUNC
746 EIGEN_STRONG_INLINE void _init2(const Index& val0, const Index& val1,
747 typename internal::enable_if< (!internal::is_same<Index,Scalar>::value)
748 && (internal::is_same<T0,Index>::value)
749 && (internal::is_same<T1,Index>::value)
750 && Base::SizeAtCompileTime==2,T1>::type* = 0)
751 {
752 EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
753 m_storage.data()[0] = Scalar(val0);
754 m_storage.data()[1] = Scalar(val1);
755 }
756
757 // The argument is convertible to the Index type and we either have a non 1x1 Matrix, or a dynamic-sized Array,
758 // then the argument is meant to be the size of the object.
759 template<typename T>
760 EIGEN_DEVICE_FUNC
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)
763 {
764 // NOTE MSVC 2008 complains if we directly put bool(NumTraits<T>::IsInteger) as the EIGEN_STATIC_ASSERT argument.
765 const bool is_integer = NumTraits<T>::IsInteger;
766 EIGEN_STATIC_ASSERT(is_integer,
767 FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
768 resize(size);
769 }
770
771 // We have a 1x1 matrix/array => the argument is interpreted as the value of the unique coefficient (case where scalar type can be implicitely converted)
772 template<typename T>
773 EIGEN_DEVICE_FUNC
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)
775 {
776 EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 1)
777 m_storage.data()[0] = val0;
778 }
779
780 // 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)
781 template<typename T>
782 EIGEN_DEVICE_FUNC
783 EIGEN_STRONG_INLINE void _init1(const Index& val0,
784 typename internal::enable_if< (!internal::is_same<Index,Scalar>::value)
785 && (internal::is_same<Index,T>::value)
786 && Base::SizeAtCompileTime==1
787 && internal::is_convertible<T, Scalar>::value,T*>::type* = 0)
788 {
789 EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 1)
790 m_storage.data()[0] = Scalar(val0);
791 }
792
793 // Initialize a fixed size matrix from a pointer to raw data
794 template<typename T>
795 EIGEN_DEVICE_FUNC
796 EIGEN_STRONG_INLINE void _init1(const Scalar* data){
797 this->_set_noalias(ConstMapType(data));
798 }
799
800 // Initialize an arbitrary matrix from a dense expression
801 template<typename T, typename OtherDerived>
802 EIGEN_DEVICE_FUNC
803 EIGEN_STRONG_INLINE void _init1(const DenseBase<OtherDerived>& other){
804 this->_set_noalias(other);
805 }
806
807 // Initialize an arbitrary matrix from a generic Eigen expression
808 template<typename T, typename OtherDerived>
809 EIGEN_DEVICE_FUNC
810 EIGEN_STRONG_INLINE void _init1(const EigenBase<OtherDerived>& other){
811 this->derived() = other;
812 }
813
814 template<typename T, typename OtherDerived>
815 EIGEN_DEVICE_FUNC
816 EIGEN_STRONG_INLINE void _init1(const ReturnByValue<OtherDerived>& other)
817 {
818 resize(other.rows(), other.cols());
819 other.evalTo(this->derived());
820 }
821
822 template<typename T, typename OtherDerived, int ColsAtCompileTime>
823 EIGEN_DEVICE_FUNC
824 EIGEN_STRONG_INLINE void _init1(const RotationBase<OtherDerived,ColsAtCompileTime>& r)
825 {
826 this->derived() = r;
827 }
828
829 // For fixed -size arrays:
830 template<typename T>
831 EIGEN_DEVICE_FUNC
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)
837 {
838 Base::setConstant(val0);
839 }
840
841 template<typename T>
842 EIGEN_DEVICE_FUNC
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)
850 {
851 Base::setConstant(val0);
852 }
853
854 template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers>
855 friend struct internal::matrix_swap_impl;
856
857 public:
858
859#ifndef EIGEN_PARSED_BY_DOXYGEN
864 template<typename OtherDerived>
865 EIGEN_DEVICE_FUNC
866 void swap(DenseBase<OtherDerived> & other)
867 {
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());
870 }
871
875 template<typename OtherDerived>
876 EIGEN_DEVICE_FUNC
877 void swap(DenseBase<OtherDerived> const & other)
878 { Base::swap(other.derived()); }
879
880 EIGEN_DEVICE_FUNC
881 static EIGEN_STRONG_INLINE void _check_template_params()
882 {
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)
891 && (Options & (DontAlign|RowMajor)) == Options),
892 INVALID_MATRIX_TEMPLATE_PARAMETERS)
893 }
894
895 enum { IsPlainObjectBase = 1 };
896#endif
897};
898
899namespace internal {
900
901template <typename Derived, typename OtherDerived, bool IsVector>
902struct conservative_resize_like_impl
903{
904 static void run(DenseBase<Derived>& _this, Index rows, Index cols)
905 {
906 if (_this.rows() == rows && _this.cols() == cols) return;
907 EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
908
909 if ( ( Derived::IsRowMajor && _this.cols() == cols) || // row-major and we change only the number of rows
910 (!Derived::IsRowMajor && _this.rows() == rows) ) // column-major and we change only the number of columns
911 {
912 internal::check_rows_cols_for_overflow<Derived::MaxSizeAtCompileTime>::run(rows, cols);
913 _this.derived().m_storage.conservativeResize(rows*cols,rows,cols);
914 }
915 else
916 {
917 // The storage order does not allow us to use reallocation.
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);
923 }
924 }
925
926 static void run(DenseBase<Derived>& _this, const DenseBase<OtherDerived>& other)
927 {
928 if (_this.rows() == other.rows() && _this.cols() == other.cols()) return;
929
930 // Note: Here is space for improvement. Basically, for conservativeResize(Index,Index),
931 // neither RowsAtCompileTime or ColsAtCompileTime must be Dynamic. If only one of the
932 // dimensions is dynamic, one could use either conservativeResize(Index rows, NoChange_t) or
933 // conservativeResize(NoChange_t, Index cols). For these methods new static asserts like
934 // EIGEN_STATIC_ASSERT_DYNAMIC_ROWS and EIGEN_STATIC_ASSERT_DYNAMIC_COLS would be good.
935 EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
936 EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(OtherDerived)
937
938 if ( ( Derived::IsRowMajor && _this.cols() == other.cols()) || // row-major and we change only the number of rows
939 (!Derived::IsRowMajor && _this.rows() == other.rows()) ) // column-major and we change only the number of columns
940 {
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());
944 if (new_rows>0)
945 _this.bottomRightCorner(new_rows, other.cols()) = other.bottomRows(new_rows);
946 else if (new_cols>0)
947 _this.bottomRightCorner(other.rows(), new_cols) = other.rightCols(new_cols);
948 }
949 else
950 {
951 // The storage order does not allow us to use reallocation.
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);
957 }
958 }
959};
960
961// Here, the specialization for vectors inherits from the general matrix case
962// to allow calling .conservativeResize(rows,cols) on vectors.
963template <typename Derived, typename OtherDerived>
964struct conservative_resize_like_impl<Derived,OtherDerived,true>
965 : conservative_resize_like_impl<Derived,OtherDerived,false>
966{
967 using conservative_resize_like_impl<Derived,OtherDerived,false>::run;
968
969 static void run(DenseBase<Derived>& _this, Index size)
970 {
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);
974 }
975
976 static void run(DenseBase<Derived>& _this, const DenseBase<OtherDerived>& other)
977 {
978 if (_this.rows() == other.rows() && _this.cols() == other.cols()) return;
979
980 const Index num_new_elements = other.size() - _this.size();
981
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);
985
986 if (num_new_elements > 0)
987 _this.tail(num_new_elements) = other.tail(num_new_elements);
988 }
989};
990
991template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers>
992struct matrix_swap_impl
993{
994 EIGEN_DEVICE_FUNC
995 static inline void run(MatrixTypeA& a, MatrixTypeB& b)
996 {
997 a.base().swap(b);
998 }
999};
1000
1001template<typename MatrixTypeA, typename MatrixTypeB>
1002struct matrix_swap_impl<MatrixTypeA, MatrixTypeB, true>
1003{
1004 EIGEN_DEVICE_FUNC
1005 static inline void run(MatrixTypeA& a, MatrixTypeB& b)
1006 {
1007 static_cast<typename MatrixTypeA::Base&>(a).m_storage.swap(static_cast<typename MatrixTypeB::Base&>(b).m_storage);
1008 }
1009};
1010
1011} // end namespace internal
1012
1013} // end namespace Eigen
1014
1015#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:44
A matrix or vector expression mapping an existing array of data.
Definition: Map.h:90
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:94
Scalar & coeffRef(Index rowId, Index colId)
Definition: PlainObjectBase.h:177
void resize(NoChange_t, Index cols)
Definition: PlainObjectBase.h:328
const Scalar & coeff(Index index) const
Definition: PlainObjectBase.h:167
PlainObjectBase(const ReturnByValue< OtherDerived > &other)
Copy constructor with in-place evaluation.
Definition: PlainObjectBase.h:547
static StridedMapType< Stride< Outer, Inner > >::type Map(Scalar *data, Index size, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:612
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:832
void _init2(const T0 &val0, const T1 &val1, typename internal::enable_if< Base::SizeAtCompileTime==2, T0 >::type *=0)
Definition: PlainObjectBase.h:737
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:843
static StridedMapType< Stride< Outer, Inner > >::type Map(Scalar *data, Index rows, Index cols, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:618
const Scalar & coeffRef(Index rowId, Index colId) const
Definition: PlainObjectBase.h:198
void _resize_to_match(const EigenBase< OtherDerived > &other)
Definition: PlainObjectBase.h:671
Derived & lazyAssign(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:459
static StridedAlignedMapType< Stride< Outer, Inner > >::type MapAligned(Scalar *data, Index rows, Index cols, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:637
static StridedConstAlignedMapType< Stride< Outer, Inner > >::type MapAligned(const Scalar *data, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:622
void _init1(const EigenBase< OtherDerived > &other)
Definition: PlainObjectBase.h:810
void conservativeResizeLike(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:442
void _init1(const RotationBase< OtherDerived, ColsAtCompileTime > &r)
Definition: PlainObjectBase.h:824
PlainObjectBase(const PlainObjectBase &other)
Definition: PlainObjectBase.h:513
void _init2(Index rows, Index cols, typename internal::enable_if< Base::SizeAtCompileTime!=2, T0 >::type *=0)
Definition: PlainObjectBase.h:727
const Scalar & coeff(Index rowId, Index colId) const
Definition: PlainObjectBase.h:154
Derived & setRandom(Index size)
Definition: Random.h:151
static AlignedMapType MapAligned(Scalar *data, Index size)
Definition: PlainObjectBase.h:595
void _init1(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:803
void conservativeResize(Index rows, Index cols)
Definition: PlainObjectBase.h:384
static ConstAlignedMapType MapAligned(const Scalar *data, Index size)
Definition: PlainObjectBase.h:593
PlainObjectBase(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:526
void conservativeResize(Index size)
Definition: PlainObjectBase.h:426
const Scalar & coeffRef(Index index) const
Definition: PlainObjectBase.h:209
static StridedMapType< Stride< Outer, Inner > >::type Map(Scalar *data, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:606
Derived & _set_noalias(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:714
void _init1(const Scalar &val0, typename internal::enable_if< Base::SizeAtCompileTime==1 &&internal::is_convertible< T, Scalar >::value, T >::type *=0)
Definition: PlainObjectBase.h:774
Derived & setOnes(Index size)
Definition: CwiseNullaryOp.h:641
static StridedAlignedMapType< Stride< Outer, Inner > >::type MapAligned(Scalar *data, Index size, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:631
static ConstAlignedMapType MapAligned(const Scalar *data, Index rows, Index cols)
Definition: PlainObjectBase.h:597
void resize(Index size)
Definition: PlainObjectBase.h:303
Scalar * data()
Definition: PlainObjectBase.h:253
void conservativeResize(Index rows, NoChange_t)
Definition: PlainObjectBase.h:397
PlainObjectBase(const EigenBase< OtherDerived > &other)
Definition: PlainObjectBase.h:537
Derived & _set(const DenseBase< OtherDerived > &other)
Copies the value of the expression other into *this with automatic resizing.
Definition: PlainObjectBase.h:701
static AlignedMapType MapAligned(Scalar *data, Index rows, Index cols)
Definition: PlainObjectBase.h:599
void resize(Index rows, Index cols)
Definition: PlainObjectBase.h:273
static AlignedMapType MapAligned(Scalar *data)
Definition: PlainObjectBase.h:591
Scalar & coeffRef(Index index)
Definition: PlainObjectBase.h:190
void _init1(const Scalar *data)
Definition: PlainObjectBase.h:796
void resizeLike(const EigenBase< OtherDerived > &_other)
Definition: PlainObjectBase.h:356
static StridedAlignedMapType< Stride< Outer, Inner > >::type MapAligned(Scalar *data, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:625
Derived & setConstant(Index size, const Scalar &val)
Definition: CwiseNullaryOp.h:341
void _init1(const ReturnByValue< OtherDerived > &other)
Definition: PlainObjectBase.h:816
static ConstMapType Map(const Scalar *data)
Definition: PlainObjectBase.h:576
static MapType Map(Scalar *data, Index size)
Definition: PlainObjectBase.h:582
static MapType Map(Scalar *data)
Definition: PlainObjectBase.h:578
static StridedConstMapType< Stride< Outer, Inner > >::type Map(const Scalar *data, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:603
static ConstMapType Map(const Scalar *data, Index size)
Definition: PlainObjectBase.h:580
static StridedConstMapType< Stride< Outer, Inner > >::type Map(const Scalar *data, Index size, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:609
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:746
Derived & setZero(Index size)
Definition: CwiseNullaryOp.h:515
static StridedConstAlignedMapType< Stride< Outer, Inner > >::type MapAligned(const Scalar *data, Index rows, Index cols, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:634
static MapType Map(Scalar *data, Index rows, Index cols)
Definition: PlainObjectBase.h:586
Derived & operator=(const PlainObjectBase &other)
Definition: PlainObjectBase.h:451
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:783
static StridedConstAlignedMapType< Stride< Outer, Inner > >::type MapAligned(const Scalar *data, Index size, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:628
static ConstMapType Map(const Scalar *data, Index rows, Index cols)
Definition: PlainObjectBase.h:584
static StridedConstMapType< Stride< Outer, Inner > >::type Map(const Scalar *data, Index rows, Index cols, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:615
void resize(Index rows, NoChange_t)
Definition: PlainObjectBase.h:342
static ConstAlignedMapType MapAligned(const Scalar *data)
Definition: PlainObjectBase.h:589
const Scalar * data() const
Definition: PlainObjectBase.h:249
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:761
Derived & operator=(const EigenBase< OtherDerived > &other)
Copies the generic expression other into *this.
Definition: PlainObjectBase.h:561
void conservativeResize(NoChange_t, Index cols)
Definition: PlainObjectBase.h:411
Common base class for compact rotation representations.
Definition: RotationBase.h:30
Holds strides information for Map.
Definition: Stride.h:45
@ Unaligned
Definition: Constants.h:228
@ DontAlign
Definition: Constants.h:326
@ RowMajor
Definition: Constants.h:322
const unsigned int RowMajorBit
Definition: Constants.h:61
Namespace containing all symbols from the Eigen library.
Definition: Core:287
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:33
const int Dynamic
Definition: Constants.h:21
Definition: Constants.h:509
Definition: EigenBase.h:29
Index cols() const
Definition: EigenBase.h:61
Derived & derived()
Definition: EigenBase.h:44
Index rows() const
Definition: EigenBase.h:58
Index size() const
Definition: EigenBase.h:65
Holds information about the various numeric (i.e. scalar) types allowed by Eigen.
Definition: NumTraits.h:151
Definition: PlainObjectBase.h:76