source: pacpussensors/trunk/Vislab/lib3dv/eigen/Eigen/src/Core/PlainObjectBase.h@ 136

Last change on this file since 136 was 136, checked in by ldecherf, 7 years ago

Doc
File size: 35.1 KB
Line 
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 static EIGEN_ALWAYS_INLINE void run(Index, Index)
32 {
33 }
34};
35
36template<> struct check_rows_cols_for_overflow<Dynamic> {
37 template<typename Index>
38 static EIGEN_ALWAYS_INLINE void run(Index rows, Index cols)
39 {
40 // http://hg.mozilla.org/mozilla-central/file/6c8a909977d3/xpcom/ds/CheckedInt.h#l242
41 // we assume Index is signed
42 Index max_index = (size_t(1) << (8 * sizeof(Index) - 1)) - 1; // assume Index is signed
43 bool error = (rows == 0 || cols == 0) ? false
44 : (rows > max_index / cols);
45 if (error)
46 throw_std_bad_alloc();
47 }
48};
49
50template <typename Derived,
51 typename OtherDerived = Derived,
52 bool IsVector = bool(Derived::IsVectorAtCompileTime) && bool(OtherDerived::IsVectorAtCompileTime)>
53struct conservative_resize_like_impl;
54
55template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers> struct matrix_swap_impl;
56
57} // end namespace internal
58
59/** \class PlainObjectBase
60 * \brief %Dense storage base class for matrices and arrays.
61 *
62 * This class can be extended with the help of the plugin mechanism described on the page
63 * \ref TopicCustomizingEigen by defining the preprocessor symbol \c EIGEN_PLAINOBJECTBASE_PLUGIN.
64 *
65 * \sa \ref TopicClassHierarchy
66 */
67#ifdef EIGEN_PARSED_BY_DOXYGEN
68namespace internal {
69
70// this is a warkaround to doxygen not being able to understand the inheritence logic
71// when it is hidden by the dense_xpr_base helper struct.
72template<typename Derived> struct dense_xpr_base_dispatcher_for_doxygen;// : public MatrixBase<Derived> {};
73/** This class is just a workaround for Doxygen and it does not not actually exist. */
74template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
75struct dense_xpr_base_dispatcher_for_doxygen<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
76 : public MatrixBase<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > {};
77/** This class is just a workaround for Doxygen and it does not not actually exist. */
78template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
79struct dense_xpr_base_dispatcher_for_doxygen<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
80 : public ArrayBase<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > {};
81
82} // namespace internal
83
84template<typename Derived>
85class PlainObjectBase : public internal::dense_xpr_base_dispatcher_for_doxygen<Derived>
86#else
87template<typename Derived>
88class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
89#endif
90{
91 public:
92 enum { Options = internal::traits<Derived>::Options };
93 typedef typename internal::dense_xpr_base<Derived>::type Base;
94
95 typedef typename internal::traits<Derived>::StorageKind StorageKind;
96 typedef typename internal::traits<Derived>::Index Index;
97 typedef typename internal::traits<Derived>::Scalar Scalar;
98 typedef typename internal::packet_traits<Scalar>::type PacketScalar;
99 typedef typename NumTraits<Scalar>::Real RealScalar;
100 typedef Derived DenseType;
101
102 using Base::RowsAtCompileTime;
103 using Base::ColsAtCompileTime;
104 using Base::SizeAtCompileTime;
105 using Base::MaxRowsAtCompileTime;
106 using Base::MaxColsAtCompileTime;
107 using Base::MaxSizeAtCompileTime;
108 using Base::IsVectorAtCompileTime;
109 using Base::Flags;
110
111 template<typename PlainObjectType, int MapOptions, typename StrideType> friend class Eigen::Map;
112 friend class Eigen::Map<Derived, Unaligned>;
113 typedef Eigen::Map<Derived, Unaligned> MapType;
114 friend class Eigen::Map<const Derived, Unaligned>;
115 typedef const Eigen::Map<const Derived, Unaligned> ConstMapType;
116 friend class Eigen::Map<Derived, Aligned>;
117 typedef Eigen::Map<Derived, Aligned> AlignedMapType;
118 friend class Eigen::Map<const Derived, Aligned>;
119 typedef const Eigen::Map<const Derived, Aligned> ConstAlignedMapType;
120 template<typename StrideType> struct StridedMapType { typedef Eigen::Map<Derived, Unaligned, StrideType> type; };
121 template<typename StrideType> struct StridedConstMapType { typedef Eigen::Map<const Derived, Unaligned, StrideType> type; };
122 template<typename StrideType> struct StridedAlignedMapType { typedef Eigen::Map<Derived, Aligned, StrideType> type; };
123 template<typename StrideType> struct StridedConstAlignedMapType { typedef Eigen::Map<const Derived, Aligned, StrideType> type; };
124
125 protected:
126 DenseStorage<Scalar, Base::MaxSizeAtCompileTime, Base::RowsAtCompileTime, Base::ColsAtCompileTime, Options> m_storage;
127
128 public:
129 enum { NeedsToAlign = SizeAtCompileTime != Dynamic && (internal::traits<Derived>::Flags & AlignedBit) != 0 };
130 EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign)
131
132 Base& base() { return *static_cast<Base*>(this); }
133 const Base& base() const { return *static_cast<const Base*>(this); }
134
135 EIGEN_STRONG_INLINE Index rows() const { return m_storage.rows(); }
136 EIGEN_STRONG_INLINE Index cols() const { return m_storage.cols(); }
137
138 EIGEN_STRONG_INLINE const Scalar& coeff(Index rowId, Index colId) const
139 {
140 if(Flags & RowMajorBit)
141 return m_storage.data()[colId + rowId * m_storage.cols()];
142 else // column-major
143 return m_storage.data()[rowId + colId * m_storage.rows()];
144 }
145
146 EIGEN_STRONG_INLINE const Scalar& coeff(Index index) const
147 {
148 return m_storage.data()[index];
149 }
150
151 EIGEN_STRONG_INLINE Scalar& coeffRef(Index rowId, Index colId)
152 {
153 if(Flags & RowMajorBit)
154 return m_storage.data()[colId + rowId * m_storage.cols()];
155 else // column-major
156 return m_storage.data()[rowId + colId * m_storage.rows()];
157 }
158
159 EIGEN_STRONG_INLINE Scalar& coeffRef(Index index)
160 {
161 return m_storage.data()[index];
162 }
163
164 EIGEN_STRONG_INLINE const Scalar& coeffRef(Index rowId, Index colId) const
165 {
166 if(Flags & RowMajorBit)
167 return m_storage.data()[colId + rowId * m_storage.cols()];
168 else // column-major
169 return m_storage.data()[rowId + colId * m_storage.rows()];
170 }
171
172 EIGEN_STRONG_INLINE const Scalar& coeffRef(Index index) const
173 {
174 return m_storage.data()[index];
175 }
176
177 /** \internal */
178 template<int LoadMode>
179 EIGEN_STRONG_INLINE PacketScalar packet(Index rowId, Index colId) const
180 {
181 return internal::ploadt<PacketScalar, LoadMode>
182 (m_storage.data() + (Flags & RowMajorBit
183 ? colId + rowId * m_storage.cols()
184 : rowId + colId * m_storage.rows()));
185 }
186
187 /** \internal */
188 template<int LoadMode>
189 EIGEN_STRONG_INLINE PacketScalar packet(Index index) const
190 {
191 return internal::ploadt<PacketScalar, LoadMode>(m_storage.data() + index);
192 }
193
194 /** \internal */
195 template<int StoreMode>
196 EIGEN_STRONG_INLINE void writePacket(Index rowId, Index colId, const PacketScalar& val)
197 {
198 internal::pstoret<Scalar, PacketScalar, StoreMode>
199 (m_storage.data() + (Flags & RowMajorBit
200 ? colId + rowId * m_storage.cols()
201 : rowId + colId * m_storage.rows()), val);
202 }
203
204 /** \internal */
205 template<int StoreMode>
206 EIGEN_STRONG_INLINE void writePacket(Index index, const PacketScalar& val)
207 {
208 internal::pstoret<Scalar, PacketScalar, StoreMode>(m_storage.data() + index, val);
209 }
210
211 /** \returns a const pointer to the data array of this matrix */
212 EIGEN_STRONG_INLINE const Scalar *data() const
213 { return m_storage.data(); }
214
215 /** \returns a pointer to the data array of this matrix */
216 EIGEN_STRONG_INLINE Scalar *data()
217 { return m_storage.data(); }
218
219 /** Resizes \c *this to a \a rows x \a cols matrix.
220 *
221 * This method is intended for dynamic-size matrices, although it is legal to call it on any
222 * matrix as long as fixed dimensions are left unchanged. If you only want to change the number
223 * of rows and/or of columns, you can use resize(NoChange_t, Index), resize(Index, NoChange_t).
224 *
225 * If the current number of coefficients of \c *this exactly matches the
226 * product \a rows * \a cols, then no memory allocation is performed and
227 * the current values are left unchanged. In all other cases, including
228 * shrinking, the data is reallocated and all previous values are lost.
229 *
230 * Example: \include Matrix_resize_int_int.cpp
231 * Output: \verbinclude Matrix_resize_int_int.out
232 *
233 * \sa resize(Index) for vectors, resize(NoChange_t, Index), resize(Index, NoChange_t)
234 */
235 EIGEN_STRONG_INLINE void resize(Index nbRows, Index nbCols)
236 {
237 eigen_assert( EIGEN_IMPLIES(RowsAtCompileTime!=Dynamic,nbRows==RowsAtCompileTime)
238 && EIGEN_IMPLIES(ColsAtCompileTime!=Dynamic,nbCols==ColsAtCompileTime)
239 && EIGEN_IMPLIES(RowsAtCompileTime==Dynamic && MaxRowsAtCompileTime!=Dynamic,nbRows<=MaxRowsAtCompileTime)
240 && EIGEN_IMPLIES(ColsAtCompileTime==Dynamic && MaxColsAtCompileTime!=Dynamic,nbCols<=MaxColsAtCompileTime)
241 && nbRows>=0 && nbCols>=0 && "Invalid sizes when resizing a matrix or array.");
242 internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(nbRows, nbCols);
243 #ifdef EIGEN_INITIALIZE_COEFFS
244 Index size = nbRows*nbCols;
245 bool size_changed = size != this->size();
246 m_storage.resize(size, nbRows, nbCols);
247 if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
248 #else
249 internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(nbRows, nbCols);
250 m_storage.resize(nbRows*nbCols, nbRows, nbCols);
251 #endif
252 }
253
254 /** Resizes \c *this to a vector of length \a size
255 *
256 * \only_for_vectors. This method does not work for
257 * partially dynamic matrices when the static dimension is anything other
258 * than 1. For example it will not work with Matrix<double, 2, Dynamic>.
259 *
260 * Example: \include Matrix_resize_int.cpp
261 * Output: \verbinclude Matrix_resize_int.out
262 *
263 * \sa resize(Index,Index), resize(NoChange_t, Index), resize(Index, NoChange_t)
264 */
265 inline void resize(Index size)
266 {
267 EIGEN_STATIC_ASSERT_VECTOR_ONLY(PlainObjectBase)
268 eigen_assert(((SizeAtCompileTime == Dynamic && (MaxSizeAtCompileTime==Dynamic || size<=MaxSizeAtCompileTime)) || SizeAtCompileTime == size) && size>=0);
269 #ifdef EIGEN_INITIALIZE_COEFFS
270 bool size_changed = size != this->size();
271 #endif
272 if(RowsAtCompileTime == 1)
273 m_storage.resize(size, 1, size);
274 else
275 m_storage.resize(size, size, 1);
276 #ifdef EIGEN_INITIALIZE_COEFFS
277 if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
278 #endif
279 }
280
281 /** Resizes the matrix, changing only the number of columns. For the parameter of type NoChange_t, just pass the special value \c NoChange
282 * as in the example below.
283 *
284 * Example: \include Matrix_resize_NoChange_int.cpp
285 * Output: \verbinclude Matrix_resize_NoChange_int.out
286 *
287 * \sa resize(Index,Index)
288 */
289 inline void resize(NoChange_t, Index nbCols)
290 {
291 resize(rows(), nbCols);
292 }
293
294 /** Resizes the matrix, changing only the number of rows. For the parameter of type NoChange_t, just pass the special value \c NoChange
295 * as in the example below.
296 *
297 * Example: \include Matrix_resize_int_NoChange.cpp
298 * Output: \verbinclude Matrix_resize_int_NoChange.out
299 *
300 * \sa resize(Index,Index)
301 */
302 inline void resize(Index nbRows, NoChange_t)
303 {
304 resize(nbRows, cols());
305 }
306
307 /** Resizes \c *this to have the same dimensions as \a other.
308 * Takes care of doing all the checking that's needed.
309 *
310 * Note that copying a row-vector into a vector (and conversely) is allowed.
311 * The resizing, if any, is then done in the appropriate way so that row-vectors
312 * remain row-vectors and vectors remain vectors.
313 */
314 template<typename OtherDerived>
315 EIGEN_STRONG_INLINE void resizeLike(const EigenBase<OtherDerived>& _other)
316 {
317 const OtherDerived& other = _other.derived();
318 internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(Index(other.rows()), Index(other.cols()));
319 const Index othersize = Index(other.rows())*Index(other.cols());
320 if(RowsAtCompileTime == 1)
321 {
322 eigen_assert(other.rows() == 1 || other.cols() == 1);
323 resize(1, othersize);
324 }
325 else if(ColsAtCompileTime == 1)
326 {
327 eigen_assert(other.rows() == 1 || other.cols() == 1);
328 resize(othersize, 1);
329 }
330 else resize(other.rows(), other.cols());
331 }
332
333 /** Resizes the matrix to \a rows x \a cols while leaving old values untouched.
334 *
335 * The method is intended for matrices of dynamic size. If you only want to change the number
336 * of rows and/or of columns, you can use conservativeResize(NoChange_t, Index) or
337 * conservativeResize(Index, NoChange_t).
338 *
339 * Matrices are resized relative to the top-left element. In case values need to be
340 * appended to the matrix they will be uninitialized.
341 */
342 EIGEN_STRONG_INLINE void conservativeResize(Index nbRows, Index nbCols)
343 {
344 internal::conservative_resize_like_impl<Derived>::run(*this, nbRows, nbCols);
345 }
346
347 /** Resizes the matrix to \a rows x \a cols while leaving old values untouched.
348 *
349 * As opposed to conservativeResize(Index rows, Index cols), this version leaves
350 * the number of columns unchanged.
351 *
352 * In case the matrix is growing, new rows will be uninitialized.
353 */
354 EIGEN_STRONG_INLINE void conservativeResize(Index nbRows, NoChange_t)
355 {
356 // Note: see the comment in conservativeResize(Index,Index)
357 conservativeResize(nbRows, cols());
358 }
359
360 /** Resizes the matrix to \a rows x \a cols while leaving old values untouched.
361 *
362 * As opposed to conservativeResize(Index rows, Index cols), this version leaves
363 * the number of rows unchanged.
364 *
365 * In case the matrix is growing, new columns will be uninitialized.
366 */
367 EIGEN_STRONG_INLINE void conservativeResize(NoChange_t, Index nbCols)
368 {
369 // Note: see the comment in conservativeResize(Index,Index)
370 conservativeResize(rows(), nbCols);
371 }
372
373 /** Resizes the vector to \a size while retaining old values.
374 *
375 * \only_for_vectors. This method does not work for
376 * partially dynamic matrices when the static dimension is anything other
377 * than 1. For example it will not work with Matrix<double, 2, Dynamic>.
378 *
379 * When values are appended, they will be uninitialized.
380 */
381 EIGEN_STRONG_INLINE void conservativeResize(Index size)
382 {
383 internal::conservative_resize_like_impl<Derived>::run(*this, size);
384 }
385
386 /** Resizes the matrix to \a rows x \a cols of \c other, while leaving old values untouched.
387 *
388 * The method is intended for matrices of dynamic size. If you only want to change the number
389 * of rows and/or of columns, you can use conservativeResize(NoChange_t, Index) or
390 * conservativeResize(Index, NoChange_t).
391 *
392 * Matrices are resized relative to the top-left element. In case values need to be
393 * appended to the matrix they will copied from \c other.
394 */
395 template<typename OtherDerived>
396 EIGEN_STRONG_INLINE void conservativeResizeLike(const DenseBase<OtherDerived>& other)
397 {
398 internal::conservative_resize_like_impl<Derived,OtherDerived>::run(*this, other);
399 }
400
401 /** This is a special case of the templated operator=. Its purpose is to
402 * prevent a default operator= from hiding the templated operator=.
403 */
404 EIGEN_STRONG_INLINE Derived& operator=(const PlainObjectBase& other)
405 {
406 return _set(other);
407 }
408
409 /** \sa MatrixBase::lazyAssign() */
410 template<typename OtherDerived>
411 EIGEN_STRONG_INLINE Derived& lazyAssign(const DenseBase<OtherDerived>& other)
412 {
413 _resize_to_match(other);
414 return Base::lazyAssign(other.derived());
415 }
416
417 template<typename OtherDerived>
418 EIGEN_STRONG_INLINE Derived& operator=(const ReturnByValue<OtherDerived>& func)
419 {
420 resize(func.rows(), func.cols());
421 return Base::operator=(func);
422 }
423
424 EIGEN_STRONG_INLINE PlainObjectBase() : m_storage()
425 {
426// _check_template_params();
427// EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
428 }
429
430#ifndef EIGEN_PARSED_BY_DOXYGEN
431 // FIXME is it still needed ?
432 /** \internal */
433 PlainObjectBase(internal::constructor_without_unaligned_array_assert)
434 : m_storage(internal::constructor_without_unaligned_array_assert())
435 {
436// _check_template_params(); EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
437 }
438#endif
439
440#ifdef EIGEN_HAVE_RVALUE_REFERENCES
441 PlainObjectBase(PlainObjectBase&& other)
442 : m_storage( std::move(other.m_storage) )
443 {
444 }
445
446 PlainObjectBase& operator=(PlainObjectBase&& other)
447 {
448 using std::swap;
449 swap(m_storage, other.m_storage);
450 return *this;
451 }
452#endif
453
454 /** Copy constructor */
455 EIGEN_STRONG_INLINE PlainObjectBase(const PlainObjectBase& other)
456 : m_storage()
457 {
458 _check_template_params();
459 lazyAssign(other);
460 }
461
462 template<typename OtherDerived>
463 EIGEN_STRONG_INLINE PlainObjectBase(const DenseBase<OtherDerived> &other)
464 : m_storage()
465 {
466 _check_template_params();
467 lazyAssign(other);
468 }
469
470 EIGEN_STRONG_INLINE PlainObjectBase(Index a_size, Index nbRows, Index nbCols)
471 : m_storage(a_size, nbRows, nbCols)
472 {
473// _check_template_params();
474// EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
475 }
476
477 /** \copydoc MatrixBase::operator=(const EigenBase<OtherDerived>&)
478 */
479 template<typename OtherDerived>
480 EIGEN_STRONG_INLINE Derived& operator=(const EigenBase<OtherDerived> &other)
481 {
482 _resize_to_match(other);
483 Base::operator=(other.derived());
484 return this->derived();
485 }
486
487 /** \sa MatrixBase::operator=(const EigenBase<OtherDerived>&) */
488 template<typename OtherDerived>
489 EIGEN_STRONG_INLINE PlainObjectBase(const EigenBase<OtherDerived> &other)
490 : m_storage(Index(other.derived().rows()) * Index(other.derived().cols()), other.derived().rows(), other.derived().cols())
491 {
492 _check_template_params();
493 internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(other.derived().rows(), other.derived().cols());
494 Base::operator=(other.derived());
495 }
496
497 /** \name Map
498 * These are convenience functions returning Map objects. The Map() static functions return unaligned Map objects,
499 * while the AlignedMap() functions return aligned Map objects and thus should be called only with 16-byte-aligned
500 * \a data pointers.
501 *
502 * \see class Map
503 */
504 //@{
505 static inline ConstMapType Map(const Scalar* data)
506 { return ConstMapType(data); }
507 static inline MapType Map(Scalar* data)
508 { return MapType(data); }
509 static inline ConstMapType Map(const Scalar* data, Index size)
510 { return ConstMapType(data, size); }
511 static inline MapType Map(Scalar* data, Index size)
512 { return MapType(data, size); }
513 static inline ConstMapType Map(const Scalar* data, Index rows, Index cols)
514 { return ConstMapType(data, rows, cols); }
515 static inline MapType Map(Scalar* data, Index rows, Index cols)
516 { return MapType(data, rows, cols); }
517
518 static inline ConstAlignedMapType MapAligned(const Scalar* data)
519 { return ConstAlignedMapType(data); }
520 static inline AlignedMapType MapAligned(Scalar* data)
521 { return AlignedMapType(data); }
522 static inline ConstAlignedMapType MapAligned(const Scalar* data, Index size)
523 { return ConstAlignedMapType(data, size); }
524 static inline AlignedMapType MapAligned(Scalar* data, Index size)
525 { return AlignedMapType(data, size); }
526 static inline ConstAlignedMapType MapAligned(const Scalar* data, Index rows, Index cols)
527 { return ConstAlignedMapType(data, rows, cols); }
528 static inline AlignedMapType MapAligned(Scalar* data, Index rows, Index cols)
529 { return AlignedMapType(data, rows, cols); }
530
531 template<int Outer, int Inner>
532 static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, const Stride<Outer, Inner>& stride)
533 { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, stride); }
534 template<int Outer, int Inner>
535 static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, const Stride<Outer, Inner>& stride)
536 { return typename StridedMapType<Stride<Outer, Inner> >::type(data, stride); }
537 template<int Outer, int Inner>
538 static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, Index size, const Stride<Outer, Inner>& stride)
539 { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, size, stride); }
540 template<int Outer, int Inner>
541 static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, Index size, const Stride<Outer, Inner>& stride)
542 { return typename StridedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
543 template<int Outer, int Inner>
544 static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
545 { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
546 template<int Outer, int Inner>
547 static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
548 { return typename StridedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
549
550 template<int Outer, int Inner>
551 static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, const Stride<Outer, Inner>& stride)
552 { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, stride); }
553 template<int Outer, int Inner>
554 static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, const Stride<Outer, Inner>& stride)
555 { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, stride); }
556 template<int Outer, int Inner>
557 static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, Index size, const Stride<Outer, Inner>& stride)
558 { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
559 template<int Outer, int Inner>
560 static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, Index size, const Stride<Outer, Inner>& stride)
561 { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
562 template<int Outer, int Inner>
563 static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
564 { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
565 template<int Outer, int Inner>
566 static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
567 { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
568 //@}
569
570 using Base::setConstant;
571 Derived& setConstant(Index size, const Scalar& value);
572 Derived& setConstant(Index rows, Index cols, const Scalar& value);
573
574 using Base::setZero;
575 Derived& setZero(Index size);
576 Derived& setZero(Index rows, Index cols);
577
578 using Base::setOnes;
579 Derived& setOnes(Index size);
580 Derived& setOnes(Index rows, Index cols);
581
582 using Base::setRandom;
583 Derived& setRandom(Index size);
584 Derived& setRandom(Index rows, Index cols);
585
586 #ifdef EIGEN_PLAINOBJECTBASE_PLUGIN
587 #include EIGEN_PLAINOBJECTBASE_PLUGIN
588 #endif
589
590 protected:
591 /** \internal Resizes *this in preparation for assigning \a other to it.
592 * Takes care of doing all the checking that's needed.
593 *
594 * Note that copying a row-vector into a vector (and conversely) is allowed.
595 * The resizing, if any, is then done in the appropriate way so that row-vectors
596 * remain row-vectors and vectors remain vectors.
597 */
598 template<typename OtherDerived>
599 EIGEN_STRONG_INLINE void _resize_to_match(const EigenBase<OtherDerived>& other)
600 {
601 #ifdef EIGEN_NO_AUTOMATIC_RESIZING
602 eigen_assert((this->size()==0 || (IsVectorAtCompileTime ? (this->size() == other.size())
603 : (rows() == other.rows() && cols() == other.cols())))
604 && "Size mismatch. Automatic resizing is disabled because EIGEN_NO_AUTOMATIC_RESIZING is defined");
605 EIGEN_ONLY_USED_FOR_DEBUG(other);
606 if(this->size()==0)
607 resizeLike(other);
608 #else
609 resizeLike(other);
610 #endif
611 }
612
613 /**
614 * \brief Copies the value of the expression \a other into \c *this with automatic resizing.
615 *
616 * *this might be resized to match the dimensions of \a other. If *this was a null matrix (not already initialized),
617 * it will be initialized.
618 *
619 * Note that copying a row-vector into a vector (and conversely) is allowed.
620 * The resizing, if any, is then done in the appropriate way so that row-vectors
621 * remain row-vectors and vectors remain vectors.
622 *
623 * \sa operator=(const MatrixBase<OtherDerived>&), _set_noalias()
624 *
625 * \internal
626 */
627 template<typename OtherDerived>
628 EIGEN_STRONG_INLINE Derived& _set(const DenseBase<OtherDerived>& other)
629 {
630 _set_selector(other.derived(), typename internal::conditional<static_cast<bool>(int(OtherDerived::Flags) & EvalBeforeAssigningBit), internal::true_type, internal::false_type>::type());
631 return this->derived();
632 }
633
634 template<typename OtherDerived>
635 EIGEN_STRONG_INLINE void _set_selector(const OtherDerived& other, const internal::true_type&) { _set_noalias(other.eval()); }
636
637 template<typename OtherDerived>
638 EIGEN_STRONG_INLINE void _set_selector(const OtherDerived& other, const internal::false_type&) { _set_noalias(other); }
639
640 /** \internal Like _set() but additionally makes the assumption that no aliasing effect can happen (which
641 * is the case when creating a new matrix) so one can enforce lazy evaluation.
642 *
643 * \sa operator=(const MatrixBase<OtherDerived>&), _set()
644 */
645 template<typename OtherDerived>
646 EIGEN_STRONG_INLINE Derived& _set_noalias(const DenseBase<OtherDerived>& other)
647 {
648 // I don't think we need this resize call since the lazyAssign will anyways resize
649 // and lazyAssign will be called by the assign selector.
650 //_resize_to_match(other);
651 // the 'false' below means to enforce lazy evaluation. We don't use lazyAssign() because
652 // it wouldn't allow to copy a row-vector into a column-vector.
653 return internal::assign_selector<Derived,OtherDerived,false>::run(this->derived(), other.derived());
654 }
655
656 template<typename T0, typename T1>
657 EIGEN_STRONG_INLINE void _init2(Index nbRows, Index nbCols, typename internal::enable_if<Base::SizeAtCompileTime!=2,T0>::type* = 0)
658 {
659 EIGEN_STATIC_ASSERT(bool(NumTraits<T0>::IsInteger) &&
660 bool(NumTraits<T1>::IsInteger),
661 FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
662 resize(nbRows,nbCols);
663 }
664 template<typename T0, typename T1>
665 EIGEN_STRONG_INLINE void _init2(const Scalar& val0, const Scalar& val1, typename internal::enable_if<Base::SizeAtCompileTime==2,T0>::type* = 0)
666 {
667 EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
668 m_storage.data()[0] = val0;
669 m_storage.data()[1] = val1;
670 }
671
672 template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers>
673 friend struct internal::matrix_swap_impl;
674
675 /** \internal generic implementation of swap for dense storage since for dynamic-sized matrices of same type it is enough to swap the
676 * data pointers.
677 */
678 template<typename OtherDerived>
679 void _swap(DenseBase<OtherDerived> const & other)
680 {
681 enum { SwapPointers = internal::is_same<Derived, OtherDerived>::value && Base::SizeAtCompileTime==Dynamic };
682 internal::matrix_swap_impl<Derived, OtherDerived, bool(SwapPointers)>::run(this->derived(), other.const_cast_derived());
683 }
684
685 public:
686#ifndef EIGEN_PARSED_BY_DOXYGEN
687 static EIGEN_STRONG_INLINE void _check_template_params()
688 {
689 EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, (Options&RowMajor)==RowMajor)
690 && EIGEN_IMPLIES(MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1, (Options&RowMajor)==0)
691 && ((RowsAtCompileTime == Dynamic) || (RowsAtCompileTime >= 0))
692 && ((ColsAtCompileTime == Dynamic) || (ColsAtCompileTime >= 0))
693 && ((MaxRowsAtCompileTime == Dynamic) || (MaxRowsAtCompileTime >= 0))
694 && ((MaxColsAtCompileTime == Dynamic) || (MaxColsAtCompileTime >= 0))
695 && (MaxRowsAtCompileTime == RowsAtCompileTime || RowsAtCompileTime==Dynamic)
696 && (MaxColsAtCompileTime == ColsAtCompileTime || ColsAtCompileTime==Dynamic)
697 && (Options & (DontAlign|RowMajor)) == Options),
698 INVALID_MATRIX_TEMPLATE_PARAMETERS)
699 }
700#endif
701
702private:
703 enum { ThisConstantIsPrivateInPlainObjectBase };
704};
705
706namespace internal {
707
708template <typename Derived, typename OtherDerived, bool IsVector>
709struct conservative_resize_like_impl
710{
711 typedef typename Derived::Index Index;
712 static void run(DenseBase<Derived>& _this, Index rows, Index cols)
713 {
714 if (_this.rows() == rows && _this.cols() == cols) return;
715 EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
716
717 if ( ( Derived::IsRowMajor && _this.cols() == cols) || // row-major and we change only the number of rows
718 (!Derived::IsRowMajor && _this.rows() == rows) ) // column-major and we change only the number of columns
719 {
720 internal::check_rows_cols_for_overflow<Derived::MaxSizeAtCompileTime>::run(rows, cols);
721 _this.derived().m_storage.conservativeResize(rows*cols,rows,cols);
722 }
723 else
724 {
725 // The storage order does not allow us to use reallocation.
726 typename Derived::PlainObject tmp(rows,cols);
727 const Index common_rows = (std::min)(rows, _this.rows());
728 const Index common_cols = (std::min)(cols, _this.cols());
729 tmp.block(0,0,common_rows,common_cols) = _this.block(0,0,common_rows,common_cols);
730 _this.derived().swap(tmp);
731 }
732 }
733
734 static void run(DenseBase<Derived>& _this, const DenseBase<OtherDerived>& other)
735 {
736 if (_this.rows() == other.rows() && _this.cols() == other.cols()) return;
737
738 // Note: Here is space for improvement. Basically, for conservativeResize(Index,Index),
739 // neither RowsAtCompileTime or ColsAtCompileTime must be Dynamic. If only one of the
740 // dimensions is dynamic, one could use either conservativeResize(Index rows, NoChange_t) or
741 // conservativeResize(NoChange_t, Index cols). For these methods new static asserts like
742 // EIGEN_STATIC_ASSERT_DYNAMIC_ROWS and EIGEN_STATIC_ASSERT_DYNAMIC_COLS would be good.
743 EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
744 EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(OtherDerived)
745
746 if ( ( Derived::IsRowMajor && _this.cols() == other.cols()) || // row-major and we change only the number of rows
747 (!Derived::IsRowMajor && _this.rows() == other.rows()) ) // column-major and we change only the number of columns
748 {
749 const Index new_rows = other.rows() - _this.rows();
750 const Index new_cols = other.cols() - _this.cols();
751 _this.derived().m_storage.conservativeResize(other.size(),other.rows(),other.cols());
752 if (new_rows>0)
753 _this.bottomRightCorner(new_rows, other.cols()) = other.bottomRows(new_rows);
754 else if (new_cols>0)
755 _this.bottomRightCorner(other.rows(), new_cols) = other.rightCols(new_cols);
756 }
757 else
758 {
759 // The storage order does not allow us to use reallocation.
760 typename Derived::PlainObject tmp(other);
761 const Index common_rows = (std::min)(tmp.rows(), _this.rows());
762 const Index common_cols = (std::min)(tmp.cols(), _this.cols());
763 tmp.block(0,0,common_rows,common_cols) = _this.block(0,0,common_rows,common_cols);
764 _this.derived().swap(tmp);
765 }
766 }
767};
768
769// Here, the specialization for vectors inherits from the general matrix case
770// to allow calling .conservativeResize(rows,cols) on vectors.
771template <typename Derived, typename OtherDerived>
772struct conservative_resize_like_impl<Derived,OtherDerived,true>
773 : conservative_resize_like_impl<Derived,OtherDerived,false>
774{
775 using conservative_resize_like_impl<Derived,OtherDerived,false>::run;
776
777 typedef typename Derived::Index Index;
778 static void run(DenseBase<Derived>& _this, Index size)
779 {
780 const Index new_rows = Derived::RowsAtCompileTime==1 ? 1 : size;
781 const Index new_cols = Derived::RowsAtCompileTime==1 ? size : 1;
782 _this.derived().m_storage.conservativeResize(size,new_rows,new_cols);
783 }
784
785 static void run(DenseBase<Derived>& _this, const DenseBase<OtherDerived>& other)
786 {
787 if (_this.rows() == other.rows() && _this.cols() == other.cols()) return;
788
789 const Index num_new_elements = other.size() - _this.size();
790
791 const Index new_rows = Derived::RowsAtCompileTime==1 ? 1 : other.rows();
792 const Index new_cols = Derived::RowsAtCompileTime==1 ? other.cols() : 1;
793 _this.derived().m_storage.conservativeResize(other.size(),new_rows,new_cols);
794
795 if (num_new_elements > 0)
796 _this.tail(num_new_elements) = other.tail(num_new_elements);
797 }
798};
799
800template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers>
801struct matrix_swap_impl
802{
803 static inline void run(MatrixTypeA& a, MatrixTypeB& b)
804 {
805 a.base().swap(b);
806 }
807};
808
809template<typename MatrixTypeA, typename MatrixTypeB>
810struct matrix_swap_impl<MatrixTypeA, MatrixTypeB, true>
811{
812 static inline void run(MatrixTypeA& a, MatrixTypeB& b)
813 {
814 static_cast<typename MatrixTypeA::Base&>(a).m_storage.swap(static_cast<typename MatrixTypeB::Base&>(b).m_storage);
815 }
816};
817
818} // end namespace internal
819
820} // end namespace Eigen
821
822#endif // EIGEN_DENSESTORAGEBASE_H
Note: See TracBrowser for help on using the repository browser.