src/Core/PlainObjectBase.h

0001 // This file is part of Eigen, a lightweight C++ template library
0002 // for linear algebra.
0003 //
0004 // Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
0005 // Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
0006 //
0007 // This Source Code Form is subject to the terms of the Mozilla
0008 // Public License v. 2.0. If a copy of the MPL was not distributed
0009 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
0010
0011 #ifndef EIGEN_DENSESTORAGEBASE_H
0012 #define EIGEN_DENSESTORAGEBASE_H
0013
0014 #if defined(EIGEN_INITIALIZE_MATRICES_BY_ZERO)
0015 # define EIGEN_INITIALIZE_COEFFS
0016 # define EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED for(Index i=0;i<base().size();++i) coeffRef(i)=Scalar(0);
0017 #elif defined(EIGEN_INITIALIZE_MATRICES_BY_NAN)
0018 # define EIGEN_INITIALIZE_COEFFS
0019 # 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();
0020 #else
0021 # undef EIGEN_INITIALIZE_COEFFS
0022 # define EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
0023 #endif
0024
0025 namespace Eigen {
0026
0027 namespace internal {
0028
0029 template<int MaxSizeAtCompileTime> struct check_rows_cols_for_overflow {
0030   template<typename Index>
0031   EIGEN_DEVICE_FUNC
0032   static EIGEN_ALWAYS_INLINE void run(Index, Index)
0033   {
0034   }
0035 };
0036
0037 template<> struct check_rows_cols_for_overflow<Dynamic> {
0038   template<typename Index>
0039   EIGEN_DEVICE_FUNC
0040   static EIGEN_ALWAYS_INLINE void run(Index rows, Index cols)
0041   {
0042     // http://hg.mozilla.org/mozilla-central/file/6c8a909977d3/xpcom/ds/CheckedInt.h#l242
0043     // we assume Index is signed
0044     Index max_index = (std::size_t(1) << (8 * sizeof(Index) - 1)) - 1; // assume Index is signed
0045     bool error = (rows == 0 || cols == 0) ? false
0046                : (rows > max_index / cols);
0047     if (error)
0048       throw_std_bad_alloc();
0049   }
0050 };
0051
0052 template <typename Derived,
0053           typename OtherDerived = Derived,
0054           bool IsVector = bool(Derived::IsVectorAtCompileTime) && bool(OtherDerived::IsVectorAtCompileTime)>
0055 struct conservative_resize_like_impl;
0056
0057 template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers> struct matrix_swap_impl;
0058
0059 } // end namespace internal
0060
0061 #ifdef EIGEN_PARSED_BY_DOXYGEN
0062 namespace doxygen {
0063
0064 // This is a workaround to doxygen not being able to understand the inheritance logic
0065 // when it is hidden by the dense_xpr_base helper struct.
0066 // Moreover, doxygen fails to include members that are not documented in the declaration body of
0067 // MatrixBase if we inherits MatrixBase<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >,
0068 // this is why we simply inherits MatrixBase, though this does not make sense.
0069
0070 /** This class is just a workaround for Doxygen and it does not not actually exist. */
0071 template<typename Derived> struct dense_xpr_base_dispatcher;
0072 /** This class is just a workaround for Doxygen and it does not not actually exist. */
0073 template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
0074 struct dense_xpr_base_dispatcher<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
0075     : public MatrixBase {};
0076 /** This class is just a workaround for Doxygen and it does not not actually exist. */
0077 template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
0078 struct dense_xpr_base_dispatcher<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
0079     : public ArrayBase {};
0080
0081 } // namespace doxygen
0082
0083 /** \class PlainObjectBase
0084   * \ingroup Core_Module
0085   * \brief %Dense storage base class for matrices and arrays.
0086   *
0087   * This class can be extended with the help of the plugin mechanism described on the page
0088   * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_PLAINOBJECTBASE_PLUGIN.
0089   *
0090   * \tparam Derived is the derived type, e.g., a Matrix or Array
0091   *
0092   * \sa \ref TopicClassHierarchy
0093   */
0094 template<typename Derived>
0095 class PlainObjectBase : public doxygen::dense_xpr_base_dispatcher<Derived>
0096 #else
0097 template<typename Derived>
0098 class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
0099 #endif
0100 {
0101   public:
0102     enum { Options = internal::traits<Derived>::Options };
0103     typedef typename internal::dense_xpr_base<Derived>::type Base;
0104
0105     typedef typename internal::traits<Derived>::StorageKind StorageKind;
0106     typedef typename internal::traits<Derived>::Scalar Scalar;
0107
0108     typedef typename internal::packet_traits<Scalar>::type PacketScalar;
0109     typedef typename NumTraits<Scalar>::Real RealScalar;
0110     typedef Derived DenseType;
0111
0112     using Base::RowsAtCompileTime;
0113     using Base::ColsAtCompileTime;
0114     using Base::SizeAtCompileTime;
0115     using Base::MaxRowsAtCompileTime;
0116     using Base::MaxColsAtCompileTime;
0117     using Base::MaxSizeAtCompileTime;
0118     using Base::IsVectorAtCompileTime;
0119     using Base::Flags;
0120
0121     typedef Eigen::Map<Derived, Unaligned>  MapType;
0122     typedef const Eigen::Map<const Derived, Unaligned> ConstMapType;
0123     typedef Eigen::Map<Derived, AlignedMax> AlignedMapType;
0124     typedef const Eigen::Map<const Derived, AlignedMax> ConstAlignedMapType;
0125     template<typename StrideType> struct StridedMapType { typedef Eigen::Map<Derived, Unaligned, StrideType> type; };
0126     template<typename StrideType> struct StridedConstMapType { typedef Eigen::Map<const Derived, Unaligned, StrideType> type; };
0127     template<typename StrideType> struct StridedAlignedMapType { typedef Eigen::Map<Derived, AlignedMax, StrideType> type; };
0128     template<typename StrideType> struct StridedConstAlignedMapType { typedef Eigen::Map<const Derived, AlignedMax, StrideType> type; };
0129
0130   protected:
0131     DenseStorage<Scalar, Base::MaxSizeAtCompileTime, Base::RowsAtCompileTime, Base::ColsAtCompileTime, Options> m_storage;
0132
0133   public:
0134     enum { NeedsToAlign = (SizeAtCompileTime != Dynamic) && (internal::traits<Derived>::Alignment>0) };
0135     EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign)
0136
0137     EIGEN_DEVICE_FUNC
0138     Base& base() { return *static_cast<Base*>(this); }
0139     EIGEN_DEVICE_FUNC
0140     const Base& base() const { return *static_cast<const Base*>(this); }
0141
0142     EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
0143     Index rows() const EIGEN_NOEXCEPT { return m_storage.rows(); }
0144     EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
0145     Index cols() const EIGEN_NOEXCEPT { return m_storage.cols(); }
0146
0147     /** This is an overloaded version of DenseCoeffsBase<Derived,ReadOnlyAccessors>::coeff(Index,Index) const
0148       * provided to by-pass the creation of an evaluator of the expression, thus saving compilation efforts.
0149       *
0150       * See DenseCoeffsBase<Derived,ReadOnlyAccessors>::coeff(Index) const for details. */
0151     EIGEN_DEVICE_FUNC
0152     EIGEN_STRONG_INLINE const Scalar& coeff(Index rowId, Index colId) const
0153     {
0154       if(Flags & RowMajorBit)
0155         return m_storage.data()[colId + rowId * m_storage.cols()];
0156       else // column-major
0157         return m_storage.data()[rowId + colId * m_storage.rows()];
0158     }
0159
0160     /** This is an overloaded version of DenseCoeffsBase<Derived,ReadOnlyAccessors>::coeff(Index) const
0161       * provided to by-pass the creation of an evaluator of the expression, thus saving compilation efforts.
0162       *
0163       * See DenseCoeffsBase<Derived,ReadOnlyAccessors>::coeff(Index) const for details. */
0164     EIGEN_DEVICE_FUNC
0165     EIGEN_STRONG_INLINE const Scalar& coeff(Index index) const
0166     {
0167       return m_storage.data()[index];
0168     }
0169
0170     /** This is an overloaded version of DenseCoeffsBase<Derived,WriteAccessors>::coeffRef(Index,Index) const
0171       * provided to by-pass the creation of an evaluator of the expression, thus saving compilation efforts.
0172       *
0173       * See DenseCoeffsBase<Derived,WriteAccessors>::coeffRef(Index,Index) const for details. */
0174     EIGEN_DEVICE_FUNC
0175     EIGEN_STRONG_INLINE Scalar& coeffRef(Index rowId, Index colId)
0176     {
0177       if(Flags & RowMajorBit)
0178         return m_storage.data()[colId + rowId * m_storage.cols()];
0179       else // column-major
0180         return m_storage.data()[rowId + colId * m_storage.rows()];
0181     }
0182
0183     /** This is an overloaded version of DenseCoeffsBase<Derived,WriteAccessors>::coeffRef(Index) const
0184       * provided to by-pass the creation of an evaluator of the expression, thus saving compilation efforts.
0185       *
0186       * See DenseCoeffsBase<Derived,WriteAccessors>::coeffRef(Index) const for details. */
0187     EIGEN_DEVICE_FUNC
0188     EIGEN_STRONG_INLINE Scalar& coeffRef(Index index)
0189     {
0190       return m_storage.data()[index];
0191     }
0192
0193     /** This is the const version of coeffRef(Index,Index) which is thus synonym of coeff(Index,Index).
0194       * It is provided for convenience. */
0195     EIGEN_DEVICE_FUNC
0196     EIGEN_STRONG_INLINE const Scalar& coeffRef(Index rowId, Index colId) const
0197     {
0198       if(Flags & RowMajorBit)
0199         return m_storage.data()[colId + rowId * m_storage.cols()];
0200       else // column-major
0201         return m_storage.data()[rowId + colId * m_storage.rows()];
0202     }
0203
0204     /** This is the const version of coeffRef(Index) which is thus synonym of coeff(Index).
0205       * It is provided for convenience. */
0206     EIGEN_DEVICE_FUNC
0207     EIGEN_STRONG_INLINE const Scalar& coeffRef(Index index) const
0208     {
0209       return m_storage.data()[index];
0210     }
0211
0212     /** \internal */
0213     template<int LoadMode>
0214     EIGEN_STRONG_INLINE PacketScalar packet(Index rowId, Index colId) const
0215     {
0216       return internal::ploadt<PacketScalar, LoadMode>
0217                (m_storage.data() + (Flags & RowMajorBit
0218                                    ? colId + rowId * m_storage.cols()
0219                                    : rowId + colId * m_storage.rows()));
0220     }
0221
0222     /** \internal */
0223     template<int LoadMode>
0224     EIGEN_STRONG_INLINE PacketScalar packet(Index index) const
0225     {
0226       return internal::ploadt<PacketScalar, LoadMode>(m_storage.data() + index);
0227     }
0228
0229     /** \internal */
0230     template<int StoreMode>
0231     EIGEN_STRONG_INLINE void writePacket(Index rowId, Index colId, const PacketScalar& val)
0232     {
0233       internal::pstoret<Scalar, PacketScalar, StoreMode>
0234               (m_storage.data() + (Flags & RowMajorBit
0235                                    ? colId + rowId * m_storage.cols()
0236                                    : rowId + colId * m_storage.rows()), val);
0237     }
0238
0239     /** \internal */
0240     template<int StoreMode>
0241     EIGEN_STRONG_INLINE void writePacket(Index index, const PacketScalar& val)
0242     {
0243       internal::pstoret<Scalar, PacketScalar, StoreMode>(m_storage.data() + index, val);
0244     }
0245
0246     /** \returns a const pointer to the data array of this matrix */
0247     EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar *data() const
0248     { return m_storage.data(); }
0249
0250     /** \returns a pointer to the data array of this matrix */
0251     EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar *data()
0252     { return m_storage.data(); }
0253
0254     /** Resizes \c *this to a \a rows x \a cols matrix.
0255       *
0256       * This method is intended for dynamic-size matrices, although it is legal to call it on any
0257       * matrix as long as fixed dimensions are left unchanged. If you only want to change the number
0258       * of rows and/or of columns, you can use resize(NoChange_t, Index), resize(Index, NoChange_t).
0259       *
0260       * If the current number of coefficients of \c *this exactly matches the
0261       * product \a rows * \a cols, then no memory allocation is performed and
0262       * the current values are left unchanged. In all other cases, including
0263       * shrinking, the data is reallocated and all previous values are lost.
0264       *
0265       * Example: \include Matrix_resize_int_int.cpp
0266       * Output: \verbinclude Matrix_resize_int_int.out
0267       *
0268       * \sa resize(Index) for vectors, resize(NoChange_t, Index), resize(Index, NoChange_t)
0269       */
0270     EIGEN_DEVICE_FUNC
0271     EIGEN_STRONG_INLINE void resize(Index rows, Index cols)
0272     {
0273       eigen_assert(   EIGEN_IMPLIES(RowsAtCompileTime!=Dynamic,rows==RowsAtCompileTime)
0274                    && EIGEN_IMPLIES(ColsAtCompileTime!=Dynamic,cols==ColsAtCompileTime)
0275                    && EIGEN_IMPLIES(RowsAtCompileTime==Dynamic && MaxRowsAtCompileTime!=Dynamic,rows<=MaxRowsAtCompileTime)
0276                    && EIGEN_IMPLIES(ColsAtCompileTime==Dynamic && MaxColsAtCompileTime!=Dynamic,cols<=MaxColsAtCompileTime)
0277                    && rows>=0 && cols>=0 && "Invalid sizes when resizing a matrix or array.");
0278       internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(rows, cols);
0279       #ifdef EIGEN_INITIALIZE_COEFFS
0280         Index size = rows*cols;
0281         bool size_changed = size != this->size();
0282         m_storage.resize(size, rows, cols);
0283         if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
0284       #else
0285         m_storage.resize(rows*cols, rows, cols);
0286       #endif
0287     }
0288
0289     /** Resizes \c *this to a vector of length \a size
0290       *
0291       * \only_for_vectors. This method does not work for
0292       * partially dynamic matrices when the static dimension is anything other
0293       * than 1. For example it will not work with Matrix<double, 2, Dynamic>.
0294       *
0295       * Example: \include Matrix_resize_int.cpp
0296       * Output: \verbinclude Matrix_resize_int.out
0297       *
0298       * \sa resize(Index,Index), resize(NoChange_t, Index), resize(Index, NoChange_t)
0299       */
0300     EIGEN_DEVICE_FUNC
0301     inline void resize(Index size)
0302     {
0303       EIGEN_STATIC_ASSERT_VECTOR_ONLY(PlainObjectBase)
0304       eigen_assert(((SizeAtCompileTime == Dynamic && (MaxSizeAtCompileTime==Dynamic || size<=MaxSizeAtCompileTime)) || SizeAtCompileTime == size) && size>=0);
0305       #ifdef EIGEN_INITIALIZE_COEFFS
0306         bool size_changed = size != this->size();
0307       #endif
0308       if(RowsAtCompileTime == 1)
0309         m_storage.resize(size, 1, size);
0310       else
0311         m_storage.resize(size, size, 1);
0312       #ifdef EIGEN_INITIALIZE_COEFFS
0313         if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
0314       #endif
0315     }
0316
0317     /** Resizes the matrix, changing only the number of columns. For the parameter of type NoChange_t, just pass the special value \c NoChange
0318       * as in the example below.
0319       *
0320       * Example: \include Matrix_resize_NoChange_int.cpp
0321       * Output: \verbinclude Matrix_resize_NoChange_int.out
0322       *
0323       * \sa resize(Index,Index)
0324       */
0325     EIGEN_DEVICE_FUNC
0326     inline void resize(NoChange_t, Index cols)
0327     {
0328       resize(rows(), cols);
0329     }
0330
0331     /** Resizes the matrix, changing only the number of rows. For the parameter of type NoChange_t, just pass the special value \c NoChange
0332       * as in the example below.
0333       *
0334       * Example: \include Matrix_resize_int_NoChange.cpp
0335       * Output: \verbinclude Matrix_resize_int_NoChange.out
0336       *
0337       * \sa resize(Index,Index)
0338       */
0339     EIGEN_DEVICE_FUNC
0340     inline void resize(Index rows, NoChange_t)
0341     {
0342       resize(rows, cols());
0343     }
0344
0345     /** Resizes \c *this to have the same dimensions as \a other.
0346       * Takes care of doing all the checking that's needed.
0347       *
0348       * Note that copying a row-vector into a vector (and conversely) is allowed.
0349       * The resizing, if any, is then done in the appropriate way so that row-vectors
0350       * remain row-vectors and vectors remain vectors.
0351       */
0352     template<typename OtherDerived>
0353     EIGEN_DEVICE_FUNC
0354     EIGEN_STRONG_INLINE void resizeLike(const EigenBase<OtherDerived>& _other)
0355     {
0356       const OtherDerived& other = _other.derived();
0357       internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(other.rows(), other.cols());
0358       const Index othersize = other.rows()*other.cols();
0359       if(RowsAtCompileTime == 1)
0360       {
0361         eigen_assert(other.rows() == 1 || other.cols() == 1);
0362         resize(1, othersize);
0363       }
0364       else if(ColsAtCompileTime == 1)
0365       {
0366         eigen_assert(other.rows() == 1 || other.cols() == 1);
0367         resize(othersize, 1);
0368       }
0369       else resize(other.rows(), other.cols());
0370     }
0371
0372     /** Resizes the matrix to \a rows x \a cols while leaving old values untouched.
0373       *
0374       * The method is intended for matrices of dynamic size. If you only want to change the number
0375       * of rows and/or of columns, you can use conservativeResize(NoChange_t, Index) or
0376       * conservativeResize(Index, NoChange_t).
0377       *
0378       * Matrices are resized relative to the top-left element. In case values need to be
0379       * appended to the matrix they will be uninitialized.
0380       */
0381     EIGEN_DEVICE_FUNC
0382     EIGEN_STRONG_INLINE void conservativeResize(Index rows, Index cols)
0383     {
0384       internal::conservative_resize_like_impl<Derived>::run(*this, rows, cols);
0385     }
0386
0387     /** Resizes the matrix to \a rows x \a cols while leaving old values untouched.
0388       *
0389       * As opposed to conservativeResize(Index rows, Index cols), this version leaves
0390       * the number of columns unchanged.
0391       *
0392       * In case the matrix is growing, new rows will be uninitialized.
0393       */
0394     EIGEN_DEVICE_FUNC
0395     EIGEN_STRONG_INLINE void conservativeResize(Index rows, NoChange_t)
0396     {
0397       // Note: see the comment in conservativeResize(Index,Index)
0398       conservativeResize(rows, cols());
0399     }
0400
0401     /** Resizes the matrix to \a rows x \a cols while leaving old values untouched.
0402       *
0403       * As opposed to conservativeResize(Index rows, Index cols), this version leaves
0404       * the number of rows unchanged.
0405       *
0406       * In case the matrix is growing, new columns will be uninitialized.
0407       */
0408     EIGEN_DEVICE_FUNC
0409     EIGEN_STRONG_INLINE void conservativeResize(NoChange_t, Index cols)
0410     {
0411       // Note: see the comment in conservativeResize(Index,Index)
0412       conservativeResize(rows(), cols);
0413     }
0414
0415     /** Resizes the vector to \a size while retaining old values.
0416       *
0417       * \only_for_vectors. This method does not work for
0418       * partially dynamic matrices when the static dimension is anything other
0419       * than 1. For example it will not work with Matrix<double, 2, Dynamic>.
0420       *
0421       * When values are appended, they will be uninitialized.
0422       */
0423     EIGEN_DEVICE_FUNC
0424     EIGEN_STRONG_INLINE void conservativeResize(Index size)
0425     {
0426       internal::conservative_resize_like_impl<Derived>::run(*this, size);
0427     }
0428
0429     /** Resizes the matrix to \a rows x \a cols of \c other, while leaving old values untouched.
0430       *
0431       * The method is intended for matrices of dynamic size. If you only want to change the number
0432       * of rows and/or of columns, you can use conservativeResize(NoChange_t, Index) or
0433       * conservativeResize(Index, NoChange_t).
0434       *
0435       * Matrices are resized relative to the top-left element. In case values need to be
0436       * appended to the matrix they will copied from \c other.
0437       */
0438     template<typename OtherDerived>
0439     EIGEN_DEVICE_FUNC
0440     EIGEN_STRONG_INLINE void conservativeResizeLike(const DenseBase<OtherDerived>& other)
0441     {
0442       internal::conservative_resize_like_impl<Derived,OtherDerived>::run(*this, other);
0443     }
0444
0445     /** This is a special case of the templated operator=. Its purpose is to
0446       * prevent a default operator= from hiding the templated operator=.
0447       */
0448     EIGEN_DEVICE_FUNC
0449     EIGEN_STRONG_INLINE Derived& operator=(const PlainObjectBase& other)
0450     {
0451       return _set(other);
0452     }
0453
0454     /** \sa MatrixBase::lazyAssign() */
0455     template<typename OtherDerived>
0456     EIGEN_DEVICE_FUNC
0457     EIGEN_STRONG_INLINE Derived& lazyAssign(const DenseBase<OtherDerived>& other)
0458     {
0459       _resize_to_match(other);
0460       return Base::lazyAssign(other.derived());
0461     }
0462
0463     template<typename OtherDerived>
0464     EIGEN_DEVICE_FUNC
0465     EIGEN_STRONG_INLINE Derived& operator=(const ReturnByValue<OtherDerived>& func)
0466     {
0467       resize(func.rows(), func.cols());
0468       return Base::operator=(func);
0469     }
0470
0471     // Prevent user from trying to instantiate PlainObjectBase objects
0472     // by making all its constructor protected. See bug 1074.
0473   protected:
0474
0475     EIGEN_DEVICE_FUNC
0476     EIGEN_STRONG_INLINE PlainObjectBase() : m_storage()
0477     {
0478 //       _check_template_params();
0479 //       EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
0480     }
0481
0482 #ifndef EIGEN_PARSED_BY_DOXYGEN
0483     // FIXME is it still needed ?
0484     /** \internal */
0485     EIGEN_DEVICE_FUNC
0486     explicit PlainObjectBase(internal::constructor_without_unaligned_array_assert)
0487       : m_storage(internal::constructor_without_unaligned_array_assert())
0488     {
0489 //       _check_template_params(); EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
0490     }
0491 #endif
0492
0493 #if EIGEN_HAS_RVALUE_REFERENCES
0494     EIGEN_DEVICE_FUNC
0495     PlainObjectBase(PlainObjectBase&& other) EIGEN_NOEXCEPT
0496       : m_storage( std::move(other.m_storage) )
0497     {
0498     }
0499
0500     EIGEN_DEVICE_FUNC
0501     PlainObjectBase& operator=(PlainObjectBase&& other) EIGEN_NOEXCEPT
0502     {
0503       _check_template_params();
0504       m_storage = std::move(other.m_storage);
0505       return *this;
0506     }
0507 #endif
0508
0509     /** Copy constructor */
0510     EIGEN_DEVICE_FUNC
0511     EIGEN_STRONG_INLINE PlainObjectBase(const PlainObjectBase& other)
0512       : Base(), m_storage(other.m_storage) { }
0513     EIGEN_DEVICE_FUNC
0514     EIGEN_STRONG_INLINE PlainObjectBase(Index size, Index rows, Index cols)
0515       : m_storage(size, rows, cols)
0516     {
0517 //       _check_template_params();
0518 //       EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
0519     }
0520
0521     #if EIGEN_HAS_CXX11
0522     /** \brief Construct a row of column vector with fixed size from an arbitrary number of coefficients. \cpp11
0523       *
0524       * \only_for_vectors
0525       *
0526       * This constructor is for 1D array or vectors with more than 4 coefficients.
0527       * There exists C++98 analogue constructors for fixed-size array/vector having 1, 2, 3, or 4 coefficients.
0528       *
0529       * \warning To construct a column (resp. row) vector of fixed length, the number of values passed to this
0530       * constructor must match the the fixed number of rows (resp. columns) of \c *this.
0531       */
0532     template <typename... ArgTypes>
0533     EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
0534     PlainObjectBase(const Scalar& a0, const Scalar& a1, const Scalar& a2,  const Scalar& a3, const ArgTypes&... args)
0535       : m_storage()
0536     {
0537       _check_template_params();
0538       EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, sizeof...(args) + 4);
0539       m_storage.data()[0] = a0;
0540       m_storage.data()[1] = a1;
0541       m_storage.data()[2] = a2;
0542       m_storage.data()[3] = a3;
0543       Index i = 4;
0544       auto x = {(m_storage.data()[i++] = args, 0)...};
0545       static_cast<void>(x);
0546     }
0547
0548     /** \brief Constructs a Matrix or Array and initializes it by elements given by an initializer list of initializer
0549       * lists \cpp11
0550       */
0551     EIGEN_DEVICE_FUNC
0552     explicit EIGEN_STRONG_INLINE PlainObjectBase(const std::initializer_list<std::initializer_list<Scalar>>& list)
0553       : m_storage()
0554     {
0555       _check_template_params();
0556
0557       size_t list_size = 0;
0558       if (list.begin() != list.end()) {
0559         list_size = list.begin()->size();
0560       }
0561
0562       // This is to allow syntax like VectorXi {{1, 2, 3, 4}}
0563       if (ColsAtCompileTime == 1 && list.size() == 1) {
0564         eigen_assert(list_size == static_cast<size_t>(RowsAtCompileTime) || RowsAtCompileTime == Dynamic);
0565         resize(list_size, ColsAtCompileTime);
0566         std::copy(list.begin()->begin(), list.begin()->end(), m_storage.data());
0567       } else {
0568         eigen_assert(list.size() == static_cast<size_t>(RowsAtCompileTime) || RowsAtCompileTime == Dynamic);
0569         eigen_assert(list_size == static_cast<size_t>(ColsAtCompileTime) || ColsAtCompileTime == Dynamic);
0570         resize(list.size(), list_size);
0571
0572         Index row_index = 0;
0573         for (const std::initializer_list<Scalar>& row : list) {
0574           eigen_assert(list_size == row.size());
0575           Index col_index = 0;
0576           for (const Scalar& e : row) {
0577             coeffRef(row_index, col_index) = e;
0578             ++col_index;
0579           }
0580           ++row_index;
0581         }
0582       }
0583     }
0584     #endif  // end EIGEN_HAS_CXX11
0585
0586     /** \sa PlainObjectBase::operator=(const EigenBase<OtherDerived>&) */
0587     template<typename OtherDerived>
0588     EIGEN_DEVICE_FUNC
0589     EIGEN_STRONG_INLINE PlainObjectBase(const DenseBase<OtherDerived> &other)
0590       : m_storage()
0591     {
0592       _check_template_params();
0593       resizeLike(other);
0594       _set_noalias(other);
0595     }
0596
0597     /** \sa PlainObjectBase::operator=(const EigenBase<OtherDerived>&) */
0598     template<typename OtherDerived>
0599     EIGEN_DEVICE_FUNC
0600     EIGEN_STRONG_INLINE PlainObjectBase(const EigenBase<OtherDerived> &other)
0601       : m_storage()
0602     {
0603       _check_template_params();
0604       resizeLike(other);
0605       *this = other.derived();
0606     }
0607     /** \brief Copy constructor with in-place evaluation */
0608     template<typename OtherDerived>
0609     EIGEN_DEVICE_FUNC
0610     EIGEN_STRONG_INLINE PlainObjectBase(const ReturnByValue<OtherDerived>& other)
0611     {
0612       _check_template_params();
0613       // FIXME this does not automatically transpose vectors if necessary
0614       resize(other.rows(), other.cols());
0615       other.evalTo(this->derived());
0616     }
0617
0618   public:
0619
0620     /** \brief Copies the generic expression \a other into *this.
0621       * \copydetails DenseBase::operator=(const EigenBase<OtherDerived> &other)
0622       */
0623     template<typename OtherDerived>
0624     EIGEN_DEVICE_FUNC
0625     EIGEN_STRONG_INLINE Derived& operator=(const EigenBase<OtherDerived> &other)
0626     {
0627       _resize_to_match(other);
0628       Base::operator=(other.derived());
0629       return this->derived();
0630     }
0631
0632     /** \name Map
0633       * These are convenience functions returning Map objects. The Map() static functions return unaligned Map objects,
0634       * while the AlignedMap() functions return aligned Map objects and thus should be called only with 16-byte-aligned
0635       * \a data pointers.
0636       *
0637       * Here is an example using strides:
0638       * \include Matrix_Map_stride.cpp
0639       * Output: \verbinclude Matrix_Map_stride.out
0640       *
0641       * \see class Map
0642       */
0643     //@{
0644     static inline ConstMapType Map(const Scalar* data)
0645     { return ConstMapType(data); }
0646     static inline MapType Map(Scalar* data)
0647     { return MapType(data); }
0648     static inline ConstMapType Map(const Scalar* data, Index size)
0649     { return ConstMapType(data, size); }
0650     static inline MapType Map(Scalar* data, Index size)
0651     { return MapType(data, size); }
0652     static inline ConstMapType Map(const Scalar* data, Index rows, Index cols)
0653     { return ConstMapType(data, rows, cols); }
0654     static inline MapType Map(Scalar* data, Index rows, Index cols)
0655     { return MapType(data, rows, cols); }
0656
0657     static inline ConstAlignedMapType MapAligned(const Scalar* data)
0658     { return ConstAlignedMapType(data); }
0659     static inline AlignedMapType MapAligned(Scalar* data)
0660     { return AlignedMapType(data); }
0661     static inline ConstAlignedMapType MapAligned(const Scalar* data, Index size)
0662     { return ConstAlignedMapType(data, size); }
0663     static inline AlignedMapType MapAligned(Scalar* data, Index size)
0664     { return AlignedMapType(data, size); }
0665     static inline ConstAlignedMapType MapAligned(const Scalar* data, Index rows, Index cols)
0666     { return ConstAlignedMapType(data, rows, cols); }
0667     static inline AlignedMapType MapAligned(Scalar* data, Index rows, Index cols)
0668     { return AlignedMapType(data, rows, cols); }
0669
0670     template<int Outer, int Inner>
0671     static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, const Stride<Outer, Inner>& stride)
0672     { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, stride); }
0673     template<int Outer, int Inner>
0674     static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, const Stride<Outer, Inner>& stride)
0675     { return typename StridedMapType<Stride<Outer, Inner> >::type(data, stride); }
0676     template<int Outer, int Inner>
0677     static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, Index size, const Stride<Outer, Inner>& stride)
0678     { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, size, stride); }
0679     template<int Outer, int Inner>
0680     static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, Index size, const Stride<Outer, Inner>& stride)
0681     { return typename StridedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
0682     template<int Outer, int Inner>
0683     static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
0684     { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
0685     template<int Outer, int Inner>
0686     static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
0687     { return typename StridedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
0688
0689     template<int Outer, int Inner>
0690     static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, const Stride<Outer, Inner>& stride)
0691     { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, stride); }
0692     template<int Outer, int Inner>
0693     static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, const Stride<Outer, Inner>& stride)
0694     { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, stride); }
0695     template<int Outer, int Inner>
0696     static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, Index size, const Stride<Outer, Inner>& stride)
0697     { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
0698     template<int Outer, int Inner>
0699     static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, Index size, const Stride<Outer, Inner>& stride)
0700     { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
0701     template<int Outer, int Inner>
0702     static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
0703     { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
0704     template<int Outer, int Inner>
0705     static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
0706     { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
0707     //@}
0708
0709     using Base::setConstant;
0710     EIGEN_DEVICE_FUNC Derived& setConstant(Index size, const Scalar& val);
0711     EIGEN_DEVICE_FUNC Derived& setConstant(Index rows, Index cols, const Scalar& val);
0712     EIGEN_DEVICE_FUNC Derived& setConstant(NoChange_t, Index cols, const Scalar& val);
0713     EIGEN_DEVICE_FUNC Derived& setConstant(Index rows, NoChange_t, const Scalar& val);
0714
0715     using Base::setZero;
0716     EIGEN_DEVICE_FUNC Derived& setZero(Index size);
0717     EIGEN_DEVICE_FUNC Derived& setZero(Index rows, Index cols);
0718     EIGEN_DEVICE_FUNC Derived& setZero(NoChange_t, Index cols);
0719     EIGEN_DEVICE_FUNC Derived& setZero(Index rows, NoChange_t);
0720
0721     using Base::setOnes;
0722     EIGEN_DEVICE_FUNC Derived& setOnes(Index size);
0723     EIGEN_DEVICE_FUNC Derived& setOnes(Index rows, Index cols);
0724     EIGEN_DEVICE_FUNC Derived& setOnes(NoChange_t, Index cols);
0725     EIGEN_DEVICE_FUNC Derived& setOnes(Index rows, NoChange_t);
0726
0727     using Base::setRandom;
0728     Derived& setRandom(Index size);
0729     Derived& setRandom(Index rows, Index cols);
0730     Derived& setRandom(NoChange_t, Index cols);
0731     Derived& setRandom(Index rows, NoChange_t);
0732
0733     #ifdef EIGEN_PLAINOBJECTBASE_PLUGIN
0734     #include EIGEN_PLAINOBJECTBASE_PLUGIN
0735     #endif
0736
0737   protected:
0738     /** \internal Resizes *this in preparation for assigning \a other to it.
0739       * Takes care of doing all the checking that's needed.
0740       *
0741       * Note that copying a row-vector into a vector (and conversely) is allowed.
0742       * The resizing, if any, is then done in the appropriate way so that row-vectors
0743       * remain row-vectors and vectors remain vectors.
0744       */
0745     template<typename OtherDerived>
0746     EIGEN_DEVICE_FUNC
0747     EIGEN_STRONG_INLINE void _resize_to_match(const EigenBase<OtherDerived>& other)
0748     {
0749       #ifdef EIGEN_NO_AUTOMATIC_RESIZING
0750       eigen_assert((this->size()==0 || (IsVectorAtCompileTime ? (this->size() == other.size())
0751                  : (rows() == other.rows() && cols() == other.cols())))
0752         && "Size mismatch. Automatic resizing is disabled because EIGEN_NO_AUTOMATIC_RESIZING is defined");
0753       EIGEN_ONLY_USED_FOR_DEBUG(other);
0754       #else
0755       resizeLike(other);
0756       #endif
0757     }
0758
0759     /**
0760       * \brief Copies the value of the expression \a other into \c *this with automatic resizing.
0761       *
0762       * *this might be resized to match the dimensions of \a other. If *this was a null matrix (not already initialized),
0763       * it will be initialized.
0764       *
0765       * Note that copying a row-vector into a vector (and conversely) is allowed.
0766       * The resizing, if any, is then done in the appropriate way so that row-vectors
0767       * remain row-vectors and vectors remain vectors.
0768       *
0769       * \sa operator=(const MatrixBase<OtherDerived>&), _set_noalias()
0770       *
0771       * \internal
0772       */
0773     // aliasing is dealt once in internal::call_assignment
0774     // so at this stage we have to assume aliasing... and resising has to be done later.
0775     template<typename OtherDerived>
0776     EIGEN_DEVICE_FUNC
0777     EIGEN_STRONG_INLINE Derived& _set(const DenseBase<OtherDerived>& other)
0778     {
0779       internal::call_assignment(this->derived(), other.derived());
0780       return this->derived();
0781     }
0782
0783     /** \internal Like _set() but additionally makes the assumption that no aliasing effect can happen (which
0784       * is the case when creating a new matrix) so one can enforce lazy evaluation.
0785       *
0786       * \sa operator=(const MatrixBase<OtherDerived>&), _set()
0787       */
0788     template<typename OtherDerived>
0789     EIGEN_DEVICE_FUNC
0790     EIGEN_STRONG_INLINE Derived& _set_noalias(const DenseBase<OtherDerived>& other)
0791     {
0792       // I don't think we need this resize call since the lazyAssign will anyways resize
0793       // and lazyAssign will be called by the assign selector.
0794       //_resize_to_match(other);
0795       // the 'false' below means to enforce lazy evaluation. We don't use lazyAssign() because
0796       // it wouldn't allow to copy a row-vector into a column-vector.
0797       internal::call_assignment_no_alias(this->derived(), other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
0798       return this->derived();
0799     }
0800
0801     template<typename T0, typename T1>
0802     EIGEN_DEVICE_FUNC
0803     EIGEN_STRONG_INLINE void _init2(Index rows, Index cols, typename internal::enable_if<Base::SizeAtCompileTime!=2,T0>::type* = 0)
0804     {
0805       const bool t0_is_integer_alike = internal::is_valid_index_type<T0>::value;
0806       const bool t1_is_integer_alike = internal::is_valid_index_type<T1>::value;
0807       EIGEN_STATIC_ASSERT(t0_is_integer_alike &&
0808                           t1_is_integer_alike,
0809                           FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
0810       resize(rows,cols);
0811     }
0812
0813     template<typename T0, typename T1>
0814     EIGEN_DEVICE_FUNC
0815     EIGEN_STRONG_INLINE void _init2(const T0& val0, const T1& val1, typename internal::enable_if<Base::SizeAtCompileTime==2,T0>::type* = 0)
0816     {
0817       EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
0818       m_storage.data()[0] = Scalar(val0);
0819       m_storage.data()[1] = Scalar(val1);
0820     }
0821
0822     template<typename T0, typename T1>
0823     EIGEN_DEVICE_FUNC
0824     EIGEN_STRONG_INLINE void _init2(const Index& val0, const Index& val1,
0825                                     typename internal::enable_if<    (!internal::is_same<Index,Scalar>::value)
0826                                                                   && (internal::is_same<T0,Index>::value)
0827                                                                   && (internal::is_same<T1,Index>::value)
0828                                                                   && Base::SizeAtCompileTime==2,T1>::type* = 0)
0829     {
0830       EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
0831       m_storage.data()[0] = Scalar(val0);
0832       m_storage.data()[1] = Scalar(val1);
0833     }
0834
0835     // The argument is convertible to the Index type and we either have a non 1x1 Matrix, or a dynamic-sized Array,
0836     // then the argument is meant to be the size of the object.
0837     template<typename T>
0838     EIGEN_DEVICE_FUNC
0839     EIGEN_STRONG_INLINE void _init1(Index size, typename internal::enable_if<    (Base::SizeAtCompileTime!=1 || !internal::is_convertible<T, Scalar>::value)
0840                                                                               && ((!internal::is_same<typename internal::traits<Derived>::XprKind,ArrayXpr>::value || Base::SizeAtCompileTime==Dynamic)),T>::type* = 0)
0841     {
0842       // NOTE MSVC 2008 complains if we directly put bool(NumTraits<T>::IsInteger) as the EIGEN_STATIC_ASSERT argument.
0843       const bool is_integer_alike = internal::is_valid_index_type<T>::value;
0844       EIGEN_UNUSED_VARIABLE(is_integer_alike);
0845       EIGEN_STATIC_ASSERT(is_integer_alike,
0846                           FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
0847       resize(size);
0848     }
0849
0850     // 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)
0851     template<typename T>
0852     EIGEN_DEVICE_FUNC
0853     EIGEN_STRONG_INLINE void _init1(const Scalar& val0, typename internal::enable_if<Base::SizeAtCompileTime==1 && internal::is_convertible<T, Scalar>::value,T>::type* = 0)
0854     {
0855       EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 1)
0856       m_storage.data()[0] = val0;
0857     }
0858
0859     // 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)
0860     template<typename T>
0861     EIGEN_DEVICE_FUNC
0862     EIGEN_STRONG_INLINE void _init1(const Index& val0,
0863                                     typename internal::enable_if<    (!internal::is_same<Index,Scalar>::value)
0864                                                                   && (internal::is_same<Index,T>::value)
0865                                                                   && Base::SizeAtCompileTime==1
0866                                                                   && internal::is_convertible<T, Scalar>::value,T*>::type* = 0)
0867     {
0868       EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 1)
0869       m_storage.data()[0] = Scalar(val0);
0870     }
0871
0872     // Initialize a fixed size matrix from a pointer to raw data
0873     template<typename T>
0874     EIGEN_DEVICE_FUNC
0875     EIGEN_STRONG_INLINE void _init1(const Scalar* data){
0876       this->_set_noalias(ConstMapType(data));
0877     }
0878
0879     // Initialize an arbitrary matrix from a dense expression
0880     template<typename T, typename OtherDerived>
0881     EIGEN_DEVICE_FUNC
0882     EIGEN_STRONG_INLINE void _init1(const DenseBase<OtherDerived>& other){
0883       this->_set_noalias(other);
0884     }
0885
0886     // Initialize an arbitrary matrix from an object convertible to the Derived type.
0887     template<typename T>
0888     EIGEN_DEVICE_FUNC
0889     EIGEN_STRONG_INLINE void _init1(const Derived& other){
0890       this->_set_noalias(other);
0891     }
0892
0893     // Initialize an arbitrary matrix from a generic Eigen expression
0894     template<typename T, typename OtherDerived>
0895     EIGEN_DEVICE_FUNC
0896     EIGEN_STRONG_INLINE void _init1(const EigenBase<OtherDerived>& other){
0897       this->derived() = other;
0898     }
0899
0900     template<typename T, typename OtherDerived>
0901     EIGEN_DEVICE_FUNC
0902     EIGEN_STRONG_INLINE void _init1(const ReturnByValue<OtherDerived>& other)
0903     {
0904       resize(other.rows(), other.cols());
0905       other.evalTo(this->derived());
0906     }
0907
0908     template<typename T, typename OtherDerived, int ColsAtCompileTime>
0909     EIGEN_DEVICE_FUNC
0910     EIGEN_STRONG_INLINE void _init1(const RotationBase<OtherDerived,ColsAtCompileTime>& r)
0911     {
0912       this->derived() = r;
0913     }
0914
0915     // For fixed-size Array<Scalar,...>
0916     template<typename T>
0917     EIGEN_DEVICE_FUNC
0918     EIGEN_STRONG_INLINE void _init1(const Scalar& val0,
0919                                     typename internal::enable_if<    Base::SizeAtCompileTime!=Dynamic
0920                                                                   && Base::SizeAtCompileTime!=1
0921                                                                   && internal::is_convertible<T, Scalar>::value
0922                                                                   && internal::is_same<typename internal::traits<Derived>::XprKind,ArrayXpr>::value,T>::type* = 0)
0923     {
0924       Base::setConstant(val0);
0925     }
0926
0927     // For fixed-size Array<Index,...>
0928     template<typename T>
0929     EIGEN_DEVICE_FUNC
0930     EIGEN_STRONG_INLINE void _init1(const Index& val0,
0931                                     typename internal::enable_if<    (!internal::is_same<Index,Scalar>::value)
0932                                                                   && (internal::is_same<Index,T>::value)
0933                                                                   && Base::SizeAtCompileTime!=Dynamic
0934                                                                   && Base::SizeAtCompileTime!=1
0935                                                                   && internal::is_convertible<T, Scalar>::value
0936                                                                   && internal::is_same<typename internal::traits<Derived>::XprKind,ArrayXpr>::value,T*>::type* = 0)
0937     {
0938       Base::setConstant(val0);
0939     }
0940
0941     template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers>
0942     friend struct internal::matrix_swap_impl;
0943
0944   public:
0945
0946 #ifndef EIGEN_PARSED_BY_DOXYGEN
0947     /** \internal
0948       * \brief Override DenseBase::swap() since for dynamic-sized matrices
0949       * of same type it is enough to swap the data pointers.
0950       */
0951     template<typename OtherDerived>
0952     EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
0953     void swap(DenseBase<OtherDerived> & other)
0954     {
0955       enum { SwapPointers = internal::is_same<Derived, OtherDerived>::value && Base::SizeAtCompileTime==Dynamic };
0956       internal::matrix_swap_impl<Derived, OtherDerived, bool(SwapPointers)>::run(this->derived(), other.derived());
0957     }
0958
0959     /** \internal
0960       * \brief const version forwarded to DenseBase::swap
0961       */
0962     template<typename OtherDerived>
0963     EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
0964     void swap(DenseBase<OtherDerived> const & other)
0965     { Base::swap(other.derived()); }
0966
0967     EIGEN_DEVICE_FUNC
0968     static EIGEN_STRONG_INLINE void _check_template_params()
0969     {
0970       EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, (int(Options)&RowMajor)==RowMajor)
0971                         && EIGEN_IMPLIES(MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1, (int(Options)&RowMajor)==0)
0972                         && ((RowsAtCompileTime == Dynamic) || (RowsAtCompileTime >= 0))
0973                         && ((ColsAtCompileTime == Dynamic) || (ColsAtCompileTime >= 0))
0974                         && ((MaxRowsAtCompileTime == Dynamic) || (MaxRowsAtCompileTime >= 0))
0975                         && ((MaxColsAtCompileTime == Dynamic) || (MaxColsAtCompileTime >= 0))
0976                         && (MaxRowsAtCompileTime == RowsAtCompileTime || RowsAtCompileTime==Dynamic)
0977                         && (MaxColsAtCompileTime == ColsAtCompileTime || ColsAtCompileTime==Dynamic)
0978                         && (Options & (DontAlign|RowMajor)) == Options),
0979         INVALID_MATRIX_TEMPLATE_PARAMETERS)
0980     }
0981
0982     enum { IsPlainObjectBase = 1 };
0983 #endif
0984   public:
0985     // These apparently need to be down here for nvcc+icc to prevent duplicate
0986     // Map symbol.
0987     template<typename PlainObjectType, int MapOptions, typename StrideType> friend class Eigen::Map;
0988     friend class Eigen::Map<Derived, Unaligned>;
0989     friend class Eigen::Map<const Derived, Unaligned>;
0990 #if EIGEN_MAX_ALIGN_BYTES>0
0991     // for EIGEN_MAX_ALIGN_BYTES==0, AlignedMax==Unaligned, and many compilers generate warnings for friend-ing a class twice.
0992     friend class Eigen::Map<Derived, AlignedMax>;
0993     friend class Eigen::Map<const Derived, AlignedMax>;
0994 #endif
0995 };
0996
0997 namespace internal {
0998
0999 template <typename Derived, typename OtherDerived, bool IsVector>
1000 struct 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.
1068 template <typename Derived, typename OtherDerived>
1069 struct 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
1104 template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers>
1105 struct 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
1114 template<typename MatrixTypeA, typename MatrixTypeB>
1115 struct 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