Please, help us to better know about our user community by answering the following short survey: https://forms.gle/wpyrxWi18ox9Z5ae9
Eigen  3.4.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(Index i=0;i<base().size();++i) coeffRef(i)=Scalar(0);
17#elif defined(EIGEN_INITIALIZE_MATRICES_BY_NAN)
18# define EIGEN_INITIALIZE_COEFFS
19# define EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED for(Index i=0;i<base().size();++i) coeffRef(i)=std::numeric_limits<Scalar>::quiet_NaN();
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 = (std::size_t(1) << (8 * sizeof(Index) - 1)) - 1; // assume Index is signed
45 bool error = (rows == 0 || cols == 0) ? false
46 : (rows > max_index / cols);
47 if (error)
48 throw_std_bad_alloc();
49 }
50};
51
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
61#ifdef EIGEN_PARSED_BY_DOXYGEN
62namespace doxygen {
63
64// This is a workaround to doxygen not being able to understand the inheritance logic
65// when it is hidden by the dense_xpr_base helper struct.
66// Moreover, doxygen fails to include members that are not documented in the declaration body of
67// MatrixBase if we inherits MatrixBase<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >,
68// this is why we simply inherits MatrixBase, though this does not make sense.
69
71template<typename Derived> struct dense_xpr_base_dispatcher;
73template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
74struct dense_xpr_base_dispatcher<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
75 : public MatrixBase {};
77template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
78struct dense_xpr_base_dispatcher<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
79 : public ArrayBase {};
80
81} // namespace doxygen
82
94template<typename Derived>
96#else
97template<typename Derived>
98class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
99#endif
100{
101 public:
102 enum { Options = internal::traits<Derived>::Options };
103 typedef typename internal::dense_xpr_base<Derived>::type Base;
104
105 typedef typename internal::traits<Derived>::StorageKind StorageKind;
106 typedef typename internal::traits<Derived>::Scalar Scalar;
107
108 typedef typename internal::packet_traits<Scalar>::type PacketScalar;
109 typedef typename NumTraits<Scalar>::Real RealScalar;
110 typedef Derived DenseType;
111
112 using Base::RowsAtCompileTime;
113 using Base::ColsAtCompileTime;
114 using Base::SizeAtCompileTime;
115 using Base::MaxRowsAtCompileTime;
116 using Base::MaxColsAtCompileTime;
117 using Base::MaxSizeAtCompileTime;
118 using Base::IsVectorAtCompileTime;
119 using Base::Flags;
120
125 template<typename StrideType> struct StridedMapType { typedef Eigen::Map<Derived, Unaligned, StrideType> type; };
126 template<typename StrideType> struct StridedConstMapType { typedef Eigen::Map<const Derived, Unaligned, StrideType> type; };
127 template<typename StrideType> struct StridedAlignedMapType { typedef Eigen::Map<Derived, AlignedMax, StrideType> type; };
128 template<typename StrideType> struct StridedConstAlignedMapType { typedef Eigen::Map<const Derived, AlignedMax, StrideType> type; };
129
130 protected:
131 DenseStorage<Scalar, Base::MaxSizeAtCompileTime, Base::RowsAtCompileTime, Base::ColsAtCompileTime, Options> m_storage;
132
133 public:
134 enum { NeedsToAlign = (SizeAtCompileTime != Dynamic) && (internal::traits<Derived>::Alignment>0) };
135 EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign)
136
137 EIGEN_DEVICE_FUNC
138 Base& base() { return *static_cast<Base*>(this); }
139 EIGEN_DEVICE_FUNC
140 const Base& base() const { return *static_cast<const Base*>(this); }
141
142 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
143 Index rows() const EIGEN_NOEXCEPT { return m_storage.rows(); }
144 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
145 Index cols() const EIGEN_NOEXCEPT { return m_storage.cols(); }
146
151 EIGEN_DEVICE_FUNC
152 EIGEN_STRONG_INLINE const Scalar& coeff(Index rowId, Index colId) const
153 {
154 if(Flags & RowMajorBit)
155 return m_storage.data()[colId + rowId * m_storage.cols()];
156 else // column-major
157 return m_storage.data()[rowId + colId * m_storage.rows()];
158 }
159
164 EIGEN_DEVICE_FUNC
165 EIGEN_STRONG_INLINE const Scalar& coeff(Index index) const
166 {
167 return m_storage.data()[index];
168 }
169
174 EIGEN_DEVICE_FUNC
175 EIGEN_STRONG_INLINE Scalar& coeffRef(Index rowId, Index colId)
176 {
177 if(Flags & RowMajorBit)
178 return m_storage.data()[colId + rowId * m_storage.cols()];
179 else // column-major
180 return m_storage.data()[rowId + colId * m_storage.rows()];
181 }
182
187 EIGEN_DEVICE_FUNC
188 EIGEN_STRONG_INLINE Scalar& coeffRef(Index index)
189 {
190 return m_storage.data()[index];
191 }
192
195 EIGEN_DEVICE_FUNC
196 EIGEN_STRONG_INLINE const Scalar& coeffRef(Index rowId, Index colId) const
197 {
198 if(Flags & RowMajorBit)
199 return m_storage.data()[colId + rowId * m_storage.cols()];
200 else // column-major
201 return m_storage.data()[rowId + colId * m_storage.rows()];
202 }
203
206 EIGEN_DEVICE_FUNC
207 EIGEN_STRONG_INLINE const Scalar& coeffRef(Index index) const
208 {
209 return m_storage.data()[index];
210 }
211
213 template<int LoadMode>
214 EIGEN_STRONG_INLINE PacketScalar packet(Index rowId, Index colId) const
215 {
216 return internal::ploadt<PacketScalar, LoadMode>
217 (m_storage.data() + (Flags & RowMajorBit
218 ? colId + rowId * m_storage.cols()
219 : rowId + colId * m_storage.rows()));
220 }
221
223 template<int LoadMode>
224 EIGEN_STRONG_INLINE PacketScalar packet(Index index) const
225 {
226 return internal::ploadt<PacketScalar, LoadMode>(m_storage.data() + index);
227 }
228
230 template<int StoreMode>
231 EIGEN_STRONG_INLINE void writePacket(Index rowId, Index colId, const PacketScalar& val)
232 {
233 internal::pstoret<Scalar, PacketScalar, StoreMode>
234 (m_storage.data() + (Flags & RowMajorBit
235 ? colId + rowId * m_storage.cols()
236 : rowId + colId * m_storage.rows()), val);
237 }
238
240 template<int StoreMode>
241 EIGEN_STRONG_INLINE void writePacket(Index index, const PacketScalar& val)
242 {
243 internal::pstoret<Scalar, PacketScalar, StoreMode>(m_storage.data() + index, val);
244 }
245
247 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar *data() const
248 { return m_storage.data(); }
249
251 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar *data()
252 { return m_storage.data(); }
253
270 EIGEN_DEVICE_FUNC
271 EIGEN_STRONG_INLINE void resize(Index rows, Index cols)
272 {
273 eigen_assert( EIGEN_IMPLIES(RowsAtCompileTime!=Dynamic,rows==RowsAtCompileTime)
274 && EIGEN_IMPLIES(ColsAtCompileTime!=Dynamic,cols==ColsAtCompileTime)
275 && EIGEN_IMPLIES(RowsAtCompileTime==Dynamic && MaxRowsAtCompileTime!=Dynamic,rows<=MaxRowsAtCompileTime)
276 && EIGEN_IMPLIES(ColsAtCompileTime==Dynamic && MaxColsAtCompileTime!=Dynamic,cols<=MaxColsAtCompileTime)
277 && rows>=0 && cols>=0 && "Invalid sizes when resizing a matrix or array.");
278 internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(rows, cols);
279 #ifdef EIGEN_INITIALIZE_COEFFS
280 Index size = rows*cols;
281 bool size_changed = size != this->size();
282 m_storage.resize(size, rows, cols);
283 if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
284 #else
285 m_storage.resize(rows*cols, rows, cols);
286 #endif
287 }
288
300 EIGEN_DEVICE_FUNC
301 inline void resize(Index size)
302 {
303 EIGEN_STATIC_ASSERT_VECTOR_ONLY(PlainObjectBase)
304 eigen_assert(((SizeAtCompileTime == Dynamic && (MaxSizeAtCompileTime==Dynamic || size<=MaxSizeAtCompileTime)) || SizeAtCompileTime == size) && size>=0);
305 #ifdef EIGEN_INITIALIZE_COEFFS
306 bool size_changed = size != this->size();
307 #endif
308 if(RowsAtCompileTime == 1)
309 m_storage.resize(size, 1, size);
310 else
311 m_storage.resize(size, size, 1);
312 #ifdef EIGEN_INITIALIZE_COEFFS
313 if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
314 #endif
315 }
316
325 EIGEN_DEVICE_FUNC
326 inline void resize(NoChange_t, Index cols)
327 {
328 resize(rows(), cols);
329 }
330
339 EIGEN_DEVICE_FUNC
340 inline void resize(Index rows, NoChange_t)
341 {
342 resize(rows, cols());
343 }
344
352 template<typename OtherDerived>
353 EIGEN_DEVICE_FUNC
354 EIGEN_STRONG_INLINE void resizeLike(const EigenBase<OtherDerived>& _other)
355 {
356 const OtherDerived& other = _other.derived();
357 internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(other.rows(), other.cols());
358 const Index othersize = other.rows()*other.cols();
359 if(RowsAtCompileTime == 1)
360 {
361 eigen_assert(other.rows() == 1 || other.cols() == 1);
362 resize(1, othersize);
363 }
364 else if(ColsAtCompileTime == 1)
365 {
366 eigen_assert(other.rows() == 1 || other.cols() == 1);
367 resize(othersize, 1);
368 }
369 else resize(other.rows(), other.cols());
370 }
371
381 EIGEN_DEVICE_FUNC
382 EIGEN_STRONG_INLINE void conservativeResize(Index rows, Index cols)
383 {
384 internal::conservative_resize_like_impl<Derived>::run(*this, rows, cols);
385 }
386
394 EIGEN_DEVICE_FUNC
395 EIGEN_STRONG_INLINE void conservativeResize(Index rows, NoChange_t)
396 {
397 // Note: see the comment in conservativeResize(Index,Index)
398 conservativeResize(rows, cols());
399 }
400
408 EIGEN_DEVICE_FUNC
409 EIGEN_STRONG_INLINE void conservativeResize(NoChange_t, Index cols)
410 {
411 // Note: see the comment in conservativeResize(Index,Index)
412 conservativeResize(rows(), cols);
413 }
414
423 EIGEN_DEVICE_FUNC
424 EIGEN_STRONG_INLINE void conservativeResize(Index size)
425 {
426 internal::conservative_resize_like_impl<Derived>::run(*this, size);
427 }
428
438 template<typename OtherDerived>
439 EIGEN_DEVICE_FUNC
440 EIGEN_STRONG_INLINE void conservativeResizeLike(const DenseBase<OtherDerived>& other)
441 {
442 internal::conservative_resize_like_impl<Derived,OtherDerived>::run(*this, other);
443 }
444
448 EIGEN_DEVICE_FUNC
449 EIGEN_STRONG_INLINE Derived& operator=(const PlainObjectBase& other)
450 {
451 return _set(other);
452 }
453
455 template<typename OtherDerived>
456 EIGEN_DEVICE_FUNC
457 EIGEN_STRONG_INLINE Derived& lazyAssign(const DenseBase<OtherDerived>& other)
458 {
459 _resize_to_match(other);
460 return Base::lazyAssign(other.derived());
461 }
462
463 template<typename OtherDerived>
464 EIGEN_DEVICE_FUNC
465 EIGEN_STRONG_INLINE Derived& operator=(const ReturnByValue<OtherDerived>& func)
466 {
467 resize(func.rows(), func.cols());
468 return Base::operator=(func);
469 }
470
471 // Prevent user from trying to instantiate PlainObjectBase objects
472 // by making all its constructor protected. See bug 1074.
473 protected:
474
475 EIGEN_DEVICE_FUNC
476 EIGEN_STRONG_INLINE PlainObjectBase() : m_storage()
477 {
478// _check_template_params();
479// EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
480 }
481
482#ifndef EIGEN_PARSED_BY_DOXYGEN
483 // FIXME is it still needed ?
485 EIGEN_DEVICE_FUNC
486 explicit PlainObjectBase(internal::constructor_without_unaligned_array_assert)
487 : m_storage(internal::constructor_without_unaligned_array_assert())
488 {
489// _check_template_params(); EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
490 }
491#endif
492
493#if EIGEN_HAS_RVALUE_REFERENCES
494 EIGEN_DEVICE_FUNC
495 PlainObjectBase(PlainObjectBase&& other) EIGEN_NOEXCEPT
496 : m_storage( std::move(other.m_storage) )
497 {
498 }
499
500 EIGEN_DEVICE_FUNC
501 PlainObjectBase& operator=(PlainObjectBase&& other) EIGEN_NOEXCEPT
502 {
503 _check_template_params();
504 m_storage = std::move(other.m_storage);
505 return *this;
506 }
507#endif
508
510 EIGEN_DEVICE_FUNC
511 EIGEN_STRONG_INLINE PlainObjectBase(const PlainObjectBase& other)
512 : Base(), m_storage(other.m_storage) { }
513 EIGEN_DEVICE_FUNC
514 EIGEN_STRONG_INLINE PlainObjectBase(Index size, Index rows, Index cols)
515 : m_storage(size, rows, cols)
516 {
517// _check_template_params();
518// EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
519 }
520
521 #if EIGEN_HAS_CXX11
532 template <typename... ArgTypes>
533 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
534 PlainObjectBase(const Scalar& a0, const Scalar& a1, const Scalar& a2, const Scalar& a3, const ArgTypes&... args)
535 : m_storage()
536 {
537 _check_template_params();
538 EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, sizeof...(args) + 4);
539 m_storage.data()[0] = a0;
540 m_storage.data()[1] = a1;
541 m_storage.data()[2] = a2;
542 m_storage.data()[3] = a3;
543 Index i = 4;
544 auto x = {(m_storage.data()[i++] = args, 0)...};
545 static_cast<void>(x);
546 }
547
551 EIGEN_DEVICE_FUNC
552 explicit EIGEN_STRONG_INLINE PlainObjectBase(const std::initializer_list<std::initializer_list<Scalar>>& list)
553 : m_storage()
554 {
555 _check_template_params();
556
557 size_t list_size = 0;
558 if (list.begin() != list.end()) {
559 list_size = list.begin()->size();
560 }
561
562 // This is to allow syntax like VectorXi {{1, 2, 3, 4}}
563 if (ColsAtCompileTime == 1 && list.size() == 1) {
564 eigen_assert(list_size == static_cast<size_t>(RowsAtCompileTime) || RowsAtCompileTime == Dynamic);
565 resize(list_size, ColsAtCompileTime);
566 std::copy(list.begin()->begin(), list.begin()->end(), m_storage.data());
567 } else {
568 eigen_assert(list.size() == static_cast<size_t>(RowsAtCompileTime) || RowsAtCompileTime == Dynamic);
569 eigen_assert(list_size == static_cast<size_t>(ColsAtCompileTime) || ColsAtCompileTime == Dynamic);
570 resize(list.size(), list_size);
571
572 Index row_index = 0;
573 for (const std::initializer_list<Scalar>& row : list) {
574 eigen_assert(list_size == row.size());
575 Index col_index = 0;
576 for (const Scalar& e : row) {
577 coeffRef(row_index, col_index) = e;
578 ++col_index;
579 }
580 ++row_index;
581 }
582 }
583 }
584 #endif // end EIGEN_HAS_CXX11
585
587 template<typename OtherDerived>
588 EIGEN_DEVICE_FUNC
589 EIGEN_STRONG_INLINE PlainObjectBase(const DenseBase<OtherDerived> &other)
590 : m_storage()
591 {
592 _check_template_params();
593 resizeLike(other);
594 _set_noalias(other);
595 }
596
598 template<typename OtherDerived>
599 EIGEN_DEVICE_FUNC
600 EIGEN_STRONG_INLINE PlainObjectBase(const EigenBase<OtherDerived> &other)
601 : m_storage()
602 {
603 _check_template_params();
604 resizeLike(other);
605 *this = other.derived();
606 }
608 template<typename OtherDerived>
609 EIGEN_DEVICE_FUNC
610 EIGEN_STRONG_INLINE PlainObjectBase(const ReturnByValue<OtherDerived>& other)
611 {
612 _check_template_params();
613 // FIXME this does not automatically transpose vectors if necessary
614 resize(other.rows(), other.cols());
615 other.evalTo(this->derived());
616 }
617
618 public:
619
623 template<typename OtherDerived>
624 EIGEN_DEVICE_FUNC
625 EIGEN_STRONG_INLINE Derived& operator=(const EigenBase<OtherDerived> &other)
626 {
627 _resize_to_match(other);
628 Base::operator=(other.derived());
629 return this->derived();
630 }
631
644 static inline ConstMapType Map(const Scalar* data)
645 { return ConstMapType(data); }
646 static inline MapType Map(Scalar* data)
647 { return MapType(data); }
648 static inline ConstMapType Map(const Scalar* data, Index size)
649 { return ConstMapType(data, size); }
650 static inline MapType Map(Scalar* data, Index size)
651 { return MapType(data, size); }
652 static inline ConstMapType Map(const Scalar* data, Index rows, Index cols)
653 { return ConstMapType(data, rows, cols); }
654 static inline MapType Map(Scalar* data, Index rows, Index cols)
655 { return MapType(data, rows, cols); }
656
657 static inline ConstAlignedMapType MapAligned(const Scalar* data)
658 { return ConstAlignedMapType(data); }
659 static inline AlignedMapType MapAligned(Scalar* data)
660 { return AlignedMapType(data); }
661 static inline ConstAlignedMapType MapAligned(const Scalar* data, Index size)
662 { return ConstAlignedMapType(data, size); }
663 static inline AlignedMapType MapAligned(Scalar* data, Index size)
664 { return AlignedMapType(data, size); }
665 static inline ConstAlignedMapType MapAligned(const Scalar* data, Index rows, Index cols)
666 { return ConstAlignedMapType(data, rows, cols); }
667 static inline AlignedMapType MapAligned(Scalar* data, Index rows, Index cols)
668 { return AlignedMapType(data, rows, cols); }
669
670 template<int Outer, int Inner>
671 static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, const Stride<Outer, Inner>& stride)
672 { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, stride); }
673 template<int Outer, int Inner>
674 static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, const Stride<Outer, Inner>& stride)
675 { return typename StridedMapType<Stride<Outer, Inner> >::type(data, stride); }
676 template<int Outer, int Inner>
677 static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, Index size, const Stride<Outer, Inner>& stride)
678 { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, size, stride); }
679 template<int Outer, int Inner>
680 static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, Index size, const Stride<Outer, Inner>& stride)
681 { return typename StridedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
682 template<int Outer, int Inner>
683 static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
684 { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
685 template<int Outer, int Inner>
686 static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
687 { return typename StridedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
688
689 template<int Outer, int Inner>
690 static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, const Stride<Outer, Inner>& stride)
691 { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, stride); }
692 template<int Outer, int Inner>
693 static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, const Stride<Outer, Inner>& stride)
694 { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, stride); }
695 template<int Outer, int Inner>
696 static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, Index size, const Stride<Outer, Inner>& stride)
697 { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
698 template<int Outer, int Inner>
699 static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, Index size, const Stride<Outer, Inner>& stride)
700 { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
701 template<int Outer, int Inner>
702 static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
703 { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
704 template<int Outer, int Inner>
705 static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
706 { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
708
709 using Base::setConstant;
710 EIGEN_DEVICE_FUNC Derived& setConstant(Index size, const Scalar& val);
711 EIGEN_DEVICE_FUNC Derived& setConstant(Index rows, Index cols, const Scalar& val);
712 EIGEN_DEVICE_FUNC Derived& setConstant(NoChange_t, Index cols, const Scalar& val);
713 EIGEN_DEVICE_FUNC Derived& setConstant(Index rows, NoChange_t, const Scalar& val);
714
715 using Base::setZero;
716 EIGEN_DEVICE_FUNC Derived& setZero(Index size);
717 EIGEN_DEVICE_FUNC Derived& setZero(Index rows, Index cols);
718 EIGEN_DEVICE_FUNC Derived& setZero(NoChange_t, Index cols);
719 EIGEN_DEVICE_FUNC Derived& setZero(Index rows, NoChange_t);
720
721 using Base::setOnes;
722 EIGEN_DEVICE_FUNC Derived& setOnes(Index size);
723 EIGEN_DEVICE_FUNC Derived& setOnes(Index rows, Index cols);
724 EIGEN_DEVICE_FUNC Derived& setOnes(NoChange_t, Index cols);
725 EIGEN_DEVICE_FUNC Derived& setOnes(Index rows, NoChange_t);
726
727 using Base::setRandom;
728 Derived& setRandom(Index size);
729 Derived& setRandom(Index rows, Index cols);
730 Derived& setRandom(NoChange_t, Index cols);
731 Derived& setRandom(Index rows, NoChange_t);
732
733 #ifdef EIGEN_PLAINOBJECTBASE_PLUGIN
734 #include EIGEN_PLAINOBJECTBASE_PLUGIN
735 #endif
736
737 protected:
745 template<typename OtherDerived>
746 EIGEN_DEVICE_FUNC
747 EIGEN_STRONG_INLINE void _resize_to_match(const EigenBase<OtherDerived>& other)
748 {
749 #ifdef EIGEN_NO_AUTOMATIC_RESIZING
750 eigen_assert((this->size()==0 || (IsVectorAtCompileTime ? (this->size() == other.size())
751 : (rows() == other.rows() && cols() == other.cols())))
752 && "Size mismatch. Automatic resizing is disabled because EIGEN_NO_AUTOMATIC_RESIZING is defined");
753 EIGEN_ONLY_USED_FOR_DEBUG(other);
754 #else
755 resizeLike(other);
756 #endif
757 }
758
773 // aliasing is dealt once in internal::call_assignment
774 // so at this stage we have to assume aliasing... and resising has to be done later.
775 template<typename OtherDerived>
776 EIGEN_DEVICE_FUNC
777 EIGEN_STRONG_INLINE Derived& _set(const DenseBase<OtherDerived>& other)
778 {
779 internal::call_assignment(this->derived(), other.derived());
780 return this->derived();
781 }
782
788 template<typename OtherDerived>
789 EIGEN_DEVICE_FUNC
790 EIGEN_STRONG_INLINE Derived& _set_noalias(const DenseBase<OtherDerived>& other)
791 {
792 // I don't think we need this resize call since the lazyAssign will anyways resize
793 // and lazyAssign will be called by the assign selector.
794 //_resize_to_match(other);
795 // the 'false' below means to enforce lazy evaluation. We don't use lazyAssign() because
796 // it wouldn't allow to copy a row-vector into a column-vector.
797 internal::call_assignment_no_alias(this->derived(), other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
798 return this->derived();
799 }
800
801 template<typename T0, typename T1>
802 EIGEN_DEVICE_FUNC
803 EIGEN_STRONG_INLINE void _init2(Index rows, Index cols, typename internal::enable_if<Base::SizeAtCompileTime!=2,T0>::type* = 0)
804 {
805 const bool t0_is_integer_alike = internal::is_valid_index_type<T0>::value;
806 const bool t1_is_integer_alike = internal::is_valid_index_type<T1>::value;
807 EIGEN_STATIC_ASSERT(t0_is_integer_alike &&
808 t1_is_integer_alike,
809 FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
810 resize(rows,cols);
811 }
812
813 template<typename T0, typename T1>
814 EIGEN_DEVICE_FUNC
815 EIGEN_STRONG_INLINE void _init2(const T0& val0, const T1& val1, typename internal::enable_if<Base::SizeAtCompileTime==2,T0>::type* = 0)
816 {
817 EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
818 m_storage.data()[0] = Scalar(val0);
819 m_storage.data()[1] = Scalar(val1);
820 }
821
822 template<typename T0, typename T1>
823 EIGEN_DEVICE_FUNC
824 EIGEN_STRONG_INLINE void _init2(const Index& val0, const Index& val1,
825 typename internal::enable_if< (!internal::is_same<Index,Scalar>::value)
826 && (internal::is_same<T0,Index>::value)
827 && (internal::is_same<T1,Index>::value)
828 && Base::SizeAtCompileTime==2,T1>::type* = 0)
829 {
830 EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
831 m_storage.data()[0] = Scalar(val0);
832 m_storage.data()[1] = Scalar(val1);
833 }
834
835 // The argument is convertible to the Index type and we either have a non 1x1 Matrix, or a dynamic-sized Array,
836 // then the argument is meant to be the size of the object.
837 template<typename T>
838 EIGEN_DEVICE_FUNC
839 EIGEN_STRONG_INLINE void _init1(Index size, typename internal::enable_if< (Base::SizeAtCompileTime!=1 || !internal::is_convertible<T, Scalar>::value)
840 && ((!internal::is_same<typename internal::traits<Derived>::XprKind,ArrayXpr>::value || Base::SizeAtCompileTime==Dynamic)),T>::type* = 0)
841 {
842 // NOTE MSVC 2008 complains if we directly put bool(NumTraits<T>::IsInteger) as the EIGEN_STATIC_ASSERT argument.
843 const bool is_integer_alike = internal::is_valid_index_type<T>::value;
844 EIGEN_UNUSED_VARIABLE(is_integer_alike);
845 EIGEN_STATIC_ASSERT(is_integer_alike,
846 FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
847 resize(size);
848 }
849
850 // We have a 1x1 matrix/array => the argument is interpreted as the value of the unique coefficient (case where scalar type can be implicitly converted)
851 template<typename T>
852 EIGEN_DEVICE_FUNC
853 EIGEN_STRONG_INLINE void _init1(const Scalar& val0, typename internal::enable_if<Base::SizeAtCompileTime==1 && internal::is_convertible<T, Scalar>::value,T>::type* = 0)
854 {
855 EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 1)
856 m_storage.data()[0] = val0;
857 }
858
859 // 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)
860 template<typename T>
861 EIGEN_DEVICE_FUNC
862 EIGEN_STRONG_INLINE void _init1(const Index& val0,
863 typename internal::enable_if< (!internal::is_same<Index,Scalar>::value)
864 && (internal::is_same<Index,T>::value)
865 && Base::SizeAtCompileTime==1
866 && internal::is_convertible<T, Scalar>::value,T*>::type* = 0)
867 {
868 EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 1)
869 m_storage.data()[0] = Scalar(val0);
870 }
871
872 // Initialize a fixed size matrix from a pointer to raw data
873 template<typename T>
874 EIGEN_DEVICE_FUNC
875 EIGEN_STRONG_INLINE void _init1(const Scalar* data){
876 this->_set_noalias(ConstMapType(data));
877 }
878
879 // Initialize an arbitrary matrix from a dense expression
880 template<typename T, typename OtherDerived>
881 EIGEN_DEVICE_FUNC
882 EIGEN_STRONG_INLINE void _init1(const DenseBase<OtherDerived>& other){
883 this->_set_noalias(other);
884 }
885
886 // Initialize an arbitrary matrix from an object convertible to the Derived type.
887 template<typename T>
888 EIGEN_DEVICE_FUNC
889 EIGEN_STRONG_INLINE void _init1(const Derived& other){
890 this->_set_noalias(other);
891 }
892
893 // Initialize an arbitrary matrix from a generic Eigen expression
894 template<typename T, typename OtherDerived>
895 EIGEN_DEVICE_FUNC
896 EIGEN_STRONG_INLINE void _init1(const EigenBase<OtherDerived>& other){
897 this->derived() = other;
898 }
899
900 template<typename T, typename OtherDerived>
901 EIGEN_DEVICE_FUNC
902 EIGEN_STRONG_INLINE void _init1(const ReturnByValue<OtherDerived>& other)
903 {
904 resize(other.rows(), other.cols());
905 other.evalTo(this->derived());
906 }
907
908 template<typename T, typename OtherDerived, int ColsAtCompileTime>
909 EIGEN_DEVICE_FUNC
910 EIGEN_STRONG_INLINE void _init1(const RotationBase<OtherDerived,ColsAtCompileTime>& r)
911 {
912 this->derived() = r;
913 }
914
915 // For fixed-size Array<Scalar,...>
916 template<typename T>
917 EIGEN_DEVICE_FUNC
918 EIGEN_STRONG_INLINE void _init1(const Scalar& val0,
919 typename internal::enable_if< Base::SizeAtCompileTime!=Dynamic
920 && Base::SizeAtCompileTime!=1
921 && internal::is_convertible<T, Scalar>::value
922 && internal::is_same<typename internal::traits<Derived>::XprKind,ArrayXpr>::value,T>::type* = 0)
923 {
924 Base::setConstant(val0);
925 }
926
927 // For fixed-size Array<Index,...>
928 template<typename T>
929 EIGEN_DEVICE_FUNC
930 EIGEN_STRONG_INLINE void _init1(const Index& val0,
931 typename internal::enable_if< (!internal::is_same<Index,Scalar>::value)
932 && (internal::is_same<Index,T>::value)
933 && Base::SizeAtCompileTime!=Dynamic
934 && Base::SizeAtCompileTime!=1
935 && internal::is_convertible<T, Scalar>::value
936 && internal::is_same<typename internal::traits<Derived>::XprKind,ArrayXpr>::value,T*>::type* = 0)
937 {
938 Base::setConstant(val0);
939 }
940
941 template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers>
942 friend struct internal::matrix_swap_impl;
943
944 public:
945
946#ifndef EIGEN_PARSED_BY_DOXYGEN
951 template<typename OtherDerived>
952 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
953 void swap(DenseBase<OtherDerived> & other)
954 {
955 enum { SwapPointers = internal::is_same<Derived, OtherDerived>::value && Base::SizeAtCompileTime==Dynamic };
956 internal::matrix_swap_impl<Derived, OtherDerived, bool(SwapPointers)>::run(this->derived(), other.derived());
957 }
958
962 template<typename OtherDerived>
963 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
964 void swap(DenseBase<OtherDerived> const & other)
965 { Base::swap(other.derived()); }
966
967 EIGEN_DEVICE_FUNC
968 static EIGEN_STRONG_INLINE void _check_template_params()
969 {
970 EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, (int(Options)&RowMajor)==RowMajor)
971 && EIGEN_IMPLIES(MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1, (int(Options)&RowMajor)==0)
972 && ((RowsAtCompileTime == Dynamic) || (RowsAtCompileTime >= 0))
973 && ((ColsAtCompileTime == Dynamic) || (ColsAtCompileTime >= 0))
974 && ((MaxRowsAtCompileTime == Dynamic) || (MaxRowsAtCompileTime >= 0))
975 && ((MaxColsAtCompileTime == Dynamic) || (MaxColsAtCompileTime >= 0))
976 && (MaxRowsAtCompileTime == RowsAtCompileTime || RowsAtCompileTime==Dynamic)
977 && (MaxColsAtCompileTime == ColsAtCompileTime || ColsAtCompileTime==Dynamic)
978 && (Options & (DontAlign|RowMajor)) == Options),
979 INVALID_MATRIX_TEMPLATE_PARAMETERS)
980 }
981
982 enum { IsPlainObjectBase = 1 };
983#endif
984 public:
985 // These apparently need to be down here for nvcc+icc to prevent duplicate
986 // Map symbol.
987 template<typename PlainObjectType, int MapOptions, typename StrideType> friend class Eigen::Map;
988 friend class Eigen::Map<Derived, Unaligned>;
989 friend class Eigen::Map<const Derived, Unaligned>;
990#if EIGEN_MAX_ALIGN_BYTES>0
991 // for EIGEN_MAX_ALIGN_BYTES==0, AlignedMax==Unaligned, and many compilers generate warnings for friend-ing a class twice.
992 friend class Eigen::Map<Derived, AlignedMax>;
993 friend class Eigen::Map<const Derived, AlignedMax>;
994#endif
995};
996
997namespace internal {
998
999template <typename Derived, typename OtherDerived, bool IsVector>
1000struct conservative_resize_like_impl
1001{
1002 #if EIGEN_HAS_TYPE_TRAITS
1003 static const bool IsRelocatable = std::is_trivially_copyable<typename Derived::Scalar>::value;
1004 #else
1005 static const bool IsRelocatable = !NumTraits<typename Derived::Scalar>::RequireInitialization;
1006 #endif
1007 static void run(DenseBase<Derived>& _this, Index rows, Index cols)
1008 {
1009 if (_this.rows() == rows && _this.cols() == cols) return;
1010 EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
1011
1012 if ( IsRelocatable
1013 && (( Derived::IsRowMajor && _this.cols() == cols) || // row-major and we change only the number of rows
1014 (!Derived::IsRowMajor && _this.rows() == rows) )) // column-major and we change only the number of columns
1015 {
1016 internal::check_rows_cols_for_overflow<Derived::MaxSizeAtCompileTime>::run(rows, cols);
1017 _this.derived().m_storage.conservativeResize(rows*cols,rows,cols);
1018 }
1019 else
1020 {
1021 // The storage order does not allow us to use reallocation.
1022 Derived tmp(rows,cols);
1023 const Index common_rows = numext::mini(rows, _this.rows());
1024 const Index common_cols = numext::mini(cols, _this.cols());
1025 tmp.block(0,0,common_rows,common_cols) = _this.block(0,0,common_rows,common_cols);
1026 _this.derived().swap(tmp);
1027 }
1028 }
1029
1030 static void run(DenseBase<Derived>& _this, const DenseBase<OtherDerived>& other)
1031 {
1032 if (_this.rows() == other.rows() && _this.cols() == other.cols()) return;
1033
1034 // Note: Here is space for improvement. Basically, for conservativeResize(Index,Index),
1035 // neither RowsAtCompileTime or ColsAtCompileTime must be Dynamic. If only one of the
1036 // dimensions is dynamic, one could use either conservativeResize(Index rows, NoChange_t) or
1037 // conservativeResize(NoChange_t, Index cols). For these methods new static asserts like
1038 // EIGEN_STATIC_ASSERT_DYNAMIC_ROWS and EIGEN_STATIC_ASSERT_DYNAMIC_COLS would be good.
1039 EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
1040 EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(OtherDerived)
1041
1042 if ( IsRelocatable &&
1043 (( Derived::IsRowMajor && _this.cols() == other.cols()) || // row-major and we change only the number of rows
1044 (!Derived::IsRowMajor && _this.rows() == other.rows()) )) // column-major and we change only the number of columns
1045 {
1046 const Index new_rows = other.rows() - _this.rows();
1047 const Index new_cols = other.cols() - _this.cols();
1048 _this.derived().m_storage.conservativeResize(other.size(),other.rows(),other.cols());
1049 if (new_rows>0)
1050 _this.bottomRightCorner(new_rows, other.cols()) = other.bottomRows(new_rows);
1051 else if (new_cols>0)
1052 _this.bottomRightCorner(other.rows(), new_cols) = other.rightCols(new_cols);
1053 }
1054 else
1055 {
1056 // The storage order does not allow us to use reallocation.
1057 Derived tmp(other);
1058 const Index common_rows = numext::mini(tmp.rows(), _this.rows());
1059 const Index common_cols = numext::mini(tmp.cols(), _this.cols());
1060 tmp.block(0,0,common_rows,common_cols) = _this.block(0,0,common_rows,common_cols);
1061 _this.derived().swap(tmp);
1062 }
1063 }
1064};
1065
1066// Here, the specialization for vectors inherits from the general matrix case
1067// to allow calling .conservativeResize(rows,cols) on vectors.
1068template <typename Derived, typename OtherDerived>
1069struct conservative_resize_like_impl<Derived,OtherDerived,true>
1070 : conservative_resize_like_impl<Derived,OtherDerived,false>
1071{
1072 typedef conservative_resize_like_impl<Derived,OtherDerived,false> Base;
1073 using Base::run;
1074 using Base::IsRelocatable;
1075
1076 static void run(DenseBase<Derived>& _this, Index size)
1077 {
1078 const Index new_rows = Derived::RowsAtCompileTime==1 ? 1 : size;
1079 const Index new_cols = Derived::RowsAtCompileTime==1 ? size : 1;
1080 if(IsRelocatable)
1081 _this.derived().m_storage.conservativeResize(size,new_rows,new_cols);
1082 else
1083 Base::run(_this.derived(), new_rows, new_cols);
1084 }
1085
1086 static void run(DenseBase<Derived>& _this, const DenseBase<OtherDerived>& other)
1087 {
1088 if (_this.rows() == other.rows() && _this.cols() == other.cols()) return;
1089
1090 const Index num_new_elements = other.size() - _this.size();
1091
1092 const Index new_rows = Derived::RowsAtCompileTime==1 ? 1 : other.rows();
1093 const Index new_cols = Derived::RowsAtCompileTime==1 ? other.cols() : 1;
1094 if(IsRelocatable)
1095 _this.derived().m_storage.conservativeResize(other.size(),new_rows,new_cols);
1096 else
1097 Base::run(_this.derived(), new_rows, new_cols);
1098
1099 if (num_new_elements > 0)
1100 _this.tail(num_new_elements) = other.tail(num_new_elements);
1101 }
1102};
1103
1104template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers>
1105struct matrix_swap_impl
1106{
1107 EIGEN_DEVICE_FUNC
1108 static EIGEN_STRONG_INLINE void run(MatrixTypeA& a, MatrixTypeB& b)
1109 {
1110 a.base().swap(b);
1111 }
1112};
1113
1114template<typename MatrixTypeA, typename MatrixTypeB>
1115struct matrix_swap_impl<MatrixTypeA, MatrixTypeB, true>
1116{
1117 EIGEN_DEVICE_FUNC
1118 static inline void run(MatrixTypeA& a, MatrixTypeB& b)
1119 {
1120 static_cast<typename MatrixTypeA::Base&>(a).m_storage.swap(static_cast<typename MatrixTypeB::Base&>(b).m_storage);
1121 }
1122};
1123
1124} // end namespace internal
1125
1126} // end namespace Eigen
1127
1128#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
EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT
Definition: EigenBase.h:63
Derived & derived()
Definition: EigenBase.h:46
EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT
Definition: EigenBase.h:60
A matrix or vector expression mapping an existing array of data.
Definition: Map.h:96
Base class for all dense matrices, vectors, and expressions.
Definition: MatrixBase.h:50
The matrix class, also used for vectors and row-vectors.
Definition: Matrix.h:180
Dense storage base class for matrices and arrays.
Definition: PlainObjectBase.h:100
Scalar & coeffRef(Index rowId, Index colId)
Definition: PlainObjectBase.h:175
void resize(NoChange_t, Index cols)
Definition: PlainObjectBase.h:326
const Scalar & coeff(Index index) const
Definition: PlainObjectBase.h:165
PlainObjectBase(const ReturnByValue< OtherDerived > &other)
Copy constructor with in-place evaluation.
Definition: PlainObjectBase.h:610
static StridedMapType< Stride< Outer, Inner > >::type Map(Scalar *data, Index size, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:680
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:918
void _init2(const T0 &val0, const T1 &val1, typename internal::enable_if< Base::SizeAtCompileTime==2, T0 >::type *=0)
Definition: PlainObjectBase.h:815
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:930
static StridedMapType< Stride< Outer, Inner > >::type Map(Scalar *data, Index rows, Index cols, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:686
const Scalar & coeffRef(Index rowId, Index colId) const
Definition: PlainObjectBase.h:196
void _resize_to_match(const EigenBase< OtherDerived > &other)
Definition: PlainObjectBase.h:747
Derived & lazyAssign(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:457
static StridedAlignedMapType< Stride< Outer, Inner > >::type MapAligned(Scalar *data, Index rows, Index cols, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:705
static StridedConstAlignedMapType< Stride< Outer, Inner > >::type MapAligned(const Scalar *data, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:690
void _init1(const EigenBase< OtherDerived > &other)
Definition: PlainObjectBase.h:896
void conservativeResizeLike(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:440
void _init1(const RotationBase< OtherDerived, ColsAtCompileTime > &r)
Definition: PlainObjectBase.h:910
PlainObjectBase(const PlainObjectBase &other)
Definition: PlainObjectBase.h:511
void _init2(Index rows, Index cols, typename internal::enable_if< Base::SizeAtCompileTime!=2, T0 >::type *=0)
Definition: PlainObjectBase.h:803
PlainObjectBase(const Scalar &a0, const Scalar &a1, const Scalar &a2, const Scalar &a3, const ArgTypes &... args)
Construct a row of column vector with fixed size from an arbitrary number of coefficients....
Definition: PlainObjectBase.h:534
const Scalar & coeff(Index rowId, Index colId) const
Definition: PlainObjectBase.h:152
Derived & setRandom(Index size)
Definition: Random.h:151
static AlignedMapType MapAligned(Scalar *data, Index size)
Definition: PlainObjectBase.h:663
void _init1(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:882
void conservativeResize(Index rows, Index cols)
Definition: PlainObjectBase.h:382
static ConstAlignedMapType MapAligned(const Scalar *data, Index size)
Definition: PlainObjectBase.h:661
PlainObjectBase(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:589
void conservativeResize(Index size)
Definition: PlainObjectBase.h:424
const Scalar & coeffRef(Index index) const
Definition: PlainObjectBase.h:207
static StridedMapType< Stride< Outer, Inner > >::type Map(Scalar *data, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:674
PlainObjectBase(const std::initializer_list< std::initializer_list< Scalar > > &list)
Constructs a Matrix or Array and initializes it by elements given by an initializer list of initializ...
Definition: PlainObjectBase.h:552
Derived & _set_noalias(const DenseBase< OtherDerived > &other)
Definition: PlainObjectBase.h:790
void _init1(const Scalar &val0, typename internal::enable_if< Base::SizeAtCompileTime==1 &&internal::is_convertible< T, Scalar >::value, T >::type *=0)
Definition: PlainObjectBase.h:853
Derived & setOnes(Index size)
Definition: CwiseNullaryOp.h:714
static StridedAlignedMapType< Stride< Outer, Inner > >::type MapAligned(Scalar *data, Index size, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:699
static ConstAlignedMapType MapAligned(const Scalar *data, Index rows, Index cols)
Definition: PlainObjectBase.h:665
void resize(Index size)
Definition: PlainObjectBase.h:301
Scalar * data()
Definition: PlainObjectBase.h:251
void conservativeResize(Index rows, NoChange_t)
Definition: PlainObjectBase.h:395
PlainObjectBase(const EigenBase< OtherDerived > &other)
Definition: PlainObjectBase.h:600
Derived & _set(const DenseBase< OtherDerived > &other)
Copies the value of the expression other into *this with automatic resizing.
Definition: PlainObjectBase.h:777
static AlignedMapType MapAligned(Scalar *data, Index rows, Index cols)
Definition: PlainObjectBase.h:667
void resize(Index rows, Index cols)
Definition: PlainObjectBase.h:271
static AlignedMapType MapAligned(Scalar *data)
Definition: PlainObjectBase.h:659
Scalar & coeffRef(Index index)
Definition: PlainObjectBase.h:188
void _init1(const Scalar *data)
Definition: PlainObjectBase.h:875
void resizeLike(const EigenBase< OtherDerived > &_other)
Definition: PlainObjectBase.h:354
static StridedAlignedMapType< Stride< Outer, Inner > >::type MapAligned(Scalar *data, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:693
Derived & setConstant(Index size, const Scalar &val)
Definition: CwiseNullaryOp.h:361
void _init1(const ReturnByValue< OtherDerived > &other)
Definition: PlainObjectBase.h:902
static ConstMapType Map(const Scalar *data)
Definition: PlainObjectBase.h:644
static MapType Map(Scalar *data, Index size)
Definition: PlainObjectBase.h:650
void _init1(const Derived &other)
Definition: PlainObjectBase.h:889
static MapType Map(Scalar *data)
Definition: PlainObjectBase.h:646
static StridedConstMapType< Stride< Outer, Inner > >::type Map(const Scalar *data, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:671
static ConstMapType Map(const Scalar *data, Index size)
Definition: PlainObjectBase.h:648
static StridedConstMapType< Stride< Outer, Inner > >::type Map(const Scalar *data, Index size, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:677
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:824
Derived & setZero(Index size)
Definition: CwiseNullaryOp.h:562
static StridedConstAlignedMapType< Stride< Outer, Inner > >::type MapAligned(const Scalar *data, Index rows, Index cols, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:702
static MapType Map(Scalar *data, Index rows, Index cols)
Definition: PlainObjectBase.h:654
Derived & operator=(const PlainObjectBase &other)
Definition: PlainObjectBase.h:449
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:862
static StridedConstAlignedMapType< Stride< Outer, Inner > >::type MapAligned(const Scalar *data, Index size, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:696
static ConstMapType Map(const Scalar *data, Index rows, Index cols)
Definition: PlainObjectBase.h:652
static StridedConstMapType< Stride< Outer, Inner > >::type Map(const Scalar *data, Index rows, Index cols, const Stride< Outer, Inner > &stride)
Definition: PlainObjectBase.h:683
void resize(Index rows, NoChange_t)
Definition: PlainObjectBase.h:340
static ConstAlignedMapType MapAligned(const Scalar *data)
Definition: PlainObjectBase.h:657
const Scalar * data() const
Definition: PlainObjectBase.h:247
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:839
Derived & operator=(const EigenBase< OtherDerived > &other)
Copies the generic expression other into *this.
Definition: PlainObjectBase.h:625
void conservativeResize(NoChange_t, Index cols)
Definition: PlainObjectBase.h:409
Common base class for compact rotation representations.
Definition: RotationBase.h:30
Holds strides information for Map.
Definition: Stride.h:49
@ Unaligned
Definition: Constants.h:233
@ DontAlign
Definition: Constants.h:325
@ RowMajor
Definition: Constants.h:321
const unsigned int RowMajorBit
Definition: Constants.h:66
Namespace containing all symbols from the Eigen library.
Definition: Core:141
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:74
const int Dynamic
Definition: Constants.h:22
Definition: Constants.h:525
Definition: EigenBase.h:30
EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT
Definition: EigenBase.h:63
Derived & derived()
Definition: EigenBase.h:46
EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT
Definition: EigenBase.h:60
EIGEN_CONSTEXPR Index size() const EIGEN_NOEXCEPT
Definition: EigenBase.h:67
Holds information about the various numeric (i.e. scalar) types allowed by Eigen.
Definition: NumTraits.h:233
Definition: PlainObjectBase.h:71