| // This file is part of Eigen, a lightweight C++ template library | |
| // for linear algebra. | |
| // | |
| // Copyright (C) 2009 Gael Guennebaud <g.gael@free.fr> | |
| // | |
| // Eigen is free software; you can redistribute it and/or | |
| // modify it under the terms of the GNU Lesser General Public | |
| // License as published by the Free Software Foundation; either | |
| // version 3 of the License, or (at your option) any later version. | |
| // | |
| // Alternatively, you can redistribute it and/or | |
| // modify it under the terms of the GNU General Public License as | |
| // published by the Free Software Foundation; either version 2 of | |
| // the License, or (at your option) any later version. | |
| // | |
| // Eigen is distributed in the hope that it will be useful, but WITHOUT ANY | |
| // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS | |
| // FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the | |
| // GNU General Public License for more details. | |
| // | |
| // You should have received a copy of the GNU Lesser General Public | |
| // License and a copy of the GNU General Public License along with | |
| // Eigen. If not, see <http://www.gnu.org/licenses/>. | |
| #ifndef EIGEN_ARRAY_H | |
| #define EIGEN_ARRAY_H | |
| template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols> | |
| struct ei_traits<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > : ei_traits<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > | |
| { | |
| typedef ArrayXpr XprKind; | |
| typedef ArrayBase<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > XprBase; | |
| }; | |
| template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols> | |
| class Array | |
| : public DenseStorageBase<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > | |
| { | |
| public: | |
| typedef DenseStorageBase<Array> Base; | |
| EIGEN_DENSE_PUBLIC_INTERFACE(Array) | |
| enum { Options = _Options }; | |
| typedef typename Base::PlainObject PlainObject; | |
| protected: | |
| template <typename Derived, typename OtherDerived, bool IsVector> | |
| friend struct ei_conservative_resize_like_impl; | |
| using Base::m_storage; | |
| public: | |
| enum { NeedsToAlign = (!(Options&DontAlign)) | |
| && SizeAtCompileTime!=Dynamic && ((sizeof(Scalar)*SizeAtCompileTime)%16)==0 }; | |
| EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign) | |
| using Base::base; | |
| using Base::coeff; | |
| using Base::coeffRef; | |
| /** | |
| * The usage of | |
| * using Base::operator=; | |
| * fails on MSVC. Since the code below is working with GCC and MSVC, we skipped | |
| * the usage of 'using'. This should be done only for operator=. | |
| */ | |
| template<typename OtherDerived> | |
| EIGEN_STRONG_INLINE Array& operator=(const EigenBase<OtherDerived> &other) | |
| { | |
| return Base::operator=(other); | |
| } | |
| /** Copies the value of the expression \a other into \c *this with automatic resizing. | |
| * | |
| * *this might be resized to match the dimensions of \a other. If *this was a null matrix (not already initialized), | |
| * it will be initialized. | |
| * | |
| * Note that copying a row-vector into a vector (and conversely) is allowed. | |
| * The resizing, if any, is then done in the appropriate way so that row-vectors | |
| * remain row-vectors and vectors remain vectors. | |
| */ | |
| template<typename OtherDerived> | |
| EIGEN_STRONG_INLINE Array& operator=(const ArrayBase<OtherDerived>& other) | |
| { | |
| return Base::_set(other); | |
| } | |
| /** This is a special case of the templated operator=. Its purpose is to | |
| * prevent a default operator= from hiding the templated operator=. | |
| */ | |
| EIGEN_STRONG_INLINE Array& operator=(const Array& other) | |
| { | |
| return Base::_set(other); | |
| } | |
| /** Default constructor. | |
| * | |
| * For fixed-size matrices, does nothing. | |
| * | |
| * For dynamic-size matrices, creates an empty matrix of size 0. Does not allocate any array. Such a matrix | |
| * is called a null matrix. This constructor is the unique way to create null matrices: resizing | |
| * a matrix to 0 is not supported. | |
| * | |
| * \sa resize(int,int) | |
| */ | |
| EIGEN_STRONG_INLINE explicit Array() : Base() | |
| { | |
| Base::_check_template_params(); | |
| EIGEN_INITIALIZE_BY_ZERO_IF_THAT_OPTION_IS_ENABLED | |
| } | |
| #ifndef EIGEN_PARSED_BY_DOXYGEN | |
| // FIXME is it still needed ?? | |
| /** \internal */ | |
| Array(ei_constructor_without_unaligned_array_assert) | |
| : Base(ei_constructor_without_unaligned_array_assert()) | |
| { | |
| Base::_check_template_params(); | |
| EIGEN_INITIALIZE_BY_ZERO_IF_THAT_OPTION_IS_ENABLED | |
| } | |
| #endif | |
| /** Constructs a vector or row-vector with given dimension. \only_for_vectors | |
| * | |
| * Note that this is only useful for dynamic-size vectors. For fixed-size vectors, | |
| * it is redundant to pass the dimension here, so it makes more sense to use the default | |
| * constructor Matrix() instead. | |
| */ | |
| EIGEN_STRONG_INLINE explicit Array(int dim) | |
| : Base(dim, RowsAtCompileTime == 1 ? 1 : dim, ColsAtCompileTime == 1 ? 1 : dim) | |
| { | |
| Base::_check_template_params(); | |
| EIGEN_STATIC_ASSERT_VECTOR_ONLY(Array) | |
| ei_assert(dim > 0); | |
| ei_assert(SizeAtCompileTime == Dynamic || SizeAtCompileTime == dim); | |
| EIGEN_INITIALIZE_BY_ZERO_IF_THAT_OPTION_IS_ENABLED | |
| } | |
| #ifndef EIGEN_PARSED_BY_DOXYGEN | |
| template<typename T0, typename T1> | |
| EIGEN_STRONG_INLINE Array(const T0& x, const T1& y) | |
| { | |
| Base::_check_template_params(); | |
| this->template _init2<T0,T1>(x, y); | |
| } | |
| #else | |
| /** constructs an uninitialized matrix with \a rows rows and \a cols columns. | |
| * | |
| * This is useful for dynamic-size matrices. For fixed-size matrices, | |
| * it is redundant to pass these parameters, so one should use the default constructor | |
| * Matrix() instead. */ | |
| Array(int rows, int cols); | |
| /** constructs an initialized 2D vector with given coefficients */ | |
| Array(const Scalar& x, const Scalar& y); | |
| #endif | |
| /** constructs an initialized 3D vector with given coefficients */ | |
| EIGEN_STRONG_INLINE Array(const Scalar& x, const Scalar& y, const Scalar& z) | |
| { | |
| Base::_check_template_params(); | |
| EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Array, 3) | |
| m_storage.data()[0] = x; | |
| m_storage.data()[1] = y; | |
| m_storage.data()[2] = z; | |
| } | |
| /** constructs an initialized 4D vector with given coefficients */ | |
| EIGEN_STRONG_INLINE Array(const Scalar& x, const Scalar& y, const Scalar& z, const Scalar& w) | |
| { | |
| Base::_check_template_params(); | |
| EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Array, 4) | |
| m_storage.data()[0] = x; | |
| m_storage.data()[1] = y; | |
| m_storage.data()[2] = z; | |
| m_storage.data()[3] = w; | |
| } | |
| explicit Array(const Scalar *data); | |
| /** Constructor copying the value of the expression \a other */ | |
| template<typename OtherDerived> | |
| EIGEN_STRONG_INLINE Array(const ArrayBase<OtherDerived>& other) | |
| : Base(other.rows() * other.cols(), other.rows(), other.cols()) | |
| { | |
| Base::_check_template_params(); | |
| Base::_set_noalias(other); | |
| } | |
| /** Copy constructor */ | |
| EIGEN_STRONG_INLINE Array(const Array& other) | |
| : Base(other.rows() * other.cols(), other.rows(), other.cols()) | |
| { | |
| Base::_check_template_params(); | |
| Base::_set_noalias(other); | |
| } | |
| /** Copy constructor with in-place evaluation */ | |
| template<typename OtherDerived> | |
| EIGEN_STRONG_INLINE Array(const ReturnByValue<OtherDerived>& other) | |
| { | |
| Base::_check_template_params(); | |
| Base::resize(other.rows(), other.cols()); | |
| other.evalTo(*this); | |
| } | |
| /** \sa MatrixBase::operator=(const EigenBase<OtherDerived>&) */ | |
| template<typename OtherDerived> | |
| EIGEN_STRONG_INLINE Array(const EigenBase<OtherDerived> &other) | |
| : Base(other.derived().rows() * other.derived().cols(), other.derived().rows(), other.derived().cols()) | |
| { | |
| Base::_check_template_params(); | |
| Base::resize(other.rows(), other.cols()); | |
| *this = other; | |
| } | |
| /** Override MatrixBase::swap() since for dynamic-sized matrices of same type it is enough to swap the | |
| * data pointers. | |
| */ | |
| template<typename OtherDerived> | |
| void swap(ArrayBase<OtherDerived> EIGEN_REF_TO_TEMPORARY other) | |
| { this->_swap(other.derived()); } | |
| inline int innerStride() const { return 1; } | |
| inline int outerStride() const { return this->innerSize(); } | |
| #ifdef EIGEN_ARRAY_PLUGIN | |
| #include EIGEN_ARRAY_PLUGIN | |
| #endif | |
| private: | |
| template<typename MatrixType, typename OtherDerived, bool SwapPointers> | |
| friend struct ei_matrix_swap_impl; | |
| }; | |
| /** \defgroup arraytypedefs Global array typedefs | |
| * | |
| * \ingroup Array_Module | |
| * | |
| * Eigen defines several typedef shortcuts for most common 1D and 2D array types. | |
| * | |
| * The general patterns are the following: | |
| * | |
| * \c ArrayRowsColsType where \c Rows and \c Cols can be \c 2,\c 3,\c 4 for fixed size square matrices or \c X for dynamic size, | |
| * and where \c Type can be \c i for integer, \c f for float, \c d for double, \c cf for complex float, \c cd | |
| * for complex double. | |
| * | |
| * For example, \c Array33d is a fixed-size 3x3 array type of doubles, and \c ArrayXXf is a dynamic-size matrix of floats. | |
| * | |
| * There are also \c ArraySizeType which are self-explanatory. For example, \c Array4cf is | |
| * a fixed-size 1D array of 4 complex floats. | |
| * | |
| * \sa class Array | |
| */ | |
| #define EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, Size, SizeSuffix) \ | |
| /** \ingroup arraytypedefs */ \ | |
| typedef Array<Type, Size, Size> Array##SizeSuffix##SizeSuffix##TypeSuffix; \ | |
| /** \ingroup matrixtypedefs */ \ | |
| typedef Array<Type, Size, 1> Array##SizeSuffix##TypeSuffix; | |
| #define EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Type, TypeSuffix, Size) \ | |
| /** \ingroup arraytypedefs */ \ | |
| typedef Array<Type, Size, Dynamic> Array##Size##X##TypeSuffix; \ | |
| /** \ingroup arraytypedefs */ \ | |
| typedef Array<Type, Dynamic, Size> Array##X##Size##TypeSuffix; | |
| #define EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(Type, TypeSuffix) \ | |
| EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, 2, 2) \ | |
| EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, 3, 3) \ | |
| EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, 4, 4) \ | |
| EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, Dynamic, X) \ | |
| EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Type, TypeSuffix, 2) \ | |
| EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Type, TypeSuffix, 3) \ | |
| EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Type, TypeSuffix, 4) | |
| EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(int, i) | |
| EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(float, f) | |
| EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(double, d) | |
| EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(std::complex<float>, cf) | |
| EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(std::complex<double>, cd) | |
| #undef EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES | |
| #undef EIGEN_MAKE_ARRAY_TYPEDEFS | |
| #undef EIGEN_MAKE_ARRAY_TYPEDEFS_LARGE | |
| #define EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, SizeSuffix) \ | |
| using Eigen::Matrix##SizeSuffix##TypeSuffix; \ | |
| using Eigen::Vector##SizeSuffix##TypeSuffix; \ | |
| using Eigen::RowVector##SizeSuffix##TypeSuffix; | |
| #define EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(TypeSuffix) \ | |
| EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, 2) \ | |
| EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, 3) \ | |
| EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, 4) \ | |
| EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, X) \ | |
| #define EIGEN_USING_ARRAY_TYPEDEFS \ | |
| EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(i) \ | |
| EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(f) \ | |
| EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(d) \ | |
| EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(cf) \ | |
| EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(cd) | |
| #endif // EIGEN_ARRAY_H |