make fixed size matrices and arrays trivially_default_constructible
diff --git a/.clang-format b/.clang-format index b48874e..1f33cbe 100644 --- a/.clang-format +++ b/.clang-format
@@ -7,6 +7,8 @@ ColumnLimit: 120 StatementMacros: - EIGEN_STATIC_ASSERT + - EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED + - EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN SortIncludes: false AttributeMacros: - EIGEN_STRONG_INLINE
diff --git a/Eigen/src/Core/Array.h b/Eigen/src/Core/Array.h index c808b63..2098749 100644 --- a/Eigen/src/Core/Array.h +++ b/Eigen/src/Core/Array.h
@@ -117,16 +117,12 @@ * * \sa resize(Index,Index) */ - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Array() : Base() { EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED } - -#ifndef EIGEN_PARSED_BY_DOXYGEN - // FIXME is it still needed ?? - /** \internal */ - EIGEN_DEVICE_FUNC Array(internal::constructor_without_unaligned_array_assert) - : Base(internal::constructor_without_unaligned_array_assert()){EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED} +#ifdef EIGEN_INITIALIZE_COEFFS + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Array() : Base() { EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED } +#else + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Array() = default; #endif - - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Array(Array && other) = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Array(Array&&) = default; EIGEN_DEVICE_FUNC Array& operator=(Array&& other) EIGEN_NOEXCEPT_IF(std::is_nothrow_move_assignable<Scalar>::value) { Base::operator=(std::move(other)); return *this; @@ -230,7 +226,7 @@ } /** Copy constructor */ - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Array(const Array& other) = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Array(const Array&) = default; private: struct PrivateType {};
diff --git a/Eigen/src/Core/DenseStorage.h b/Eigen/src/Core/DenseStorage.h index 49c4099..9cc7ee4 100644 --- a/Eigen/src/Core/DenseStorage.h +++ b/Eigen/src/Core/DenseStorage.h
@@ -27,30 +27,11 @@ namespace internal { -struct constructor_without_unaligned_array_assert {}; - template <typename T, int Size> -EIGEN_DEVICE_FUNC constexpr void check_static_allocation_size() { -// if EIGEN_STACK_ALLOCATION_LIMIT is defined to 0, then no limit +struct check_static_allocation_size { #if EIGEN_STACK_ALLOCATION_LIMIT - EIGEN_STATIC_ASSERT(Size * sizeof(T) <= EIGEN_STACK_ALLOCATION_LIMIT, OBJECT_ALLOCATED_ON_STACK_IS_TOO_BIG); + EIGEN_STATIC_ASSERT(Size * sizeof(T) <= EIGEN_STACK_ALLOCATION_LIMIT, OBJECT_ALLOCATED_ON_STACK_IS_TOO_BIG) #endif -} - -/** \internal - * Static array. If the MatrixOrArrayOptions require auto-alignment, the array will be automatically aligned: - * to 16 bytes boundary if the total size is a multiple of 16 bytes. - */ -template <typename T, int Size, int MatrixOrArrayOptions, - int Alignment = (MatrixOrArrayOptions & DontAlign) ? 0 : compute_default_alignment<T, Size>::value> -struct plain_array { - T array[Size]; - - EIGEN_DEVICE_FUNC constexpr plain_array() { check_static_allocation_size<T, Size>(); } - - EIGEN_DEVICE_FUNC constexpr plain_array(constructor_without_unaligned_array_assert) { - check_static_allocation_size<T, Size>(); - } }; #if defined(EIGEN_DISABLE_UNALIGNED_ARRAY_ASSERT) @@ -63,93 +44,112 @@ " **** READ THIS WEB PAGE !!! ****"); #endif -template <typename T, int Size, int MatrixOrArrayOptions> -struct plain_array<T, Size, MatrixOrArrayOptions, 8> { - EIGEN_ALIGN_TO_BOUNDARY(8) T array[Size]; - - EIGEN_DEVICE_FUNC constexpr plain_array() { - EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(7); - check_static_allocation_size<T, Size>(); - } - - EIGEN_DEVICE_FUNC constexpr plain_array(constructor_without_unaligned_array_assert) { - check_static_allocation_size<T, Size>(); - } +/** \internal + * Static array. If the MatrixOrArrayOptions require auto-alignment, the array will be automatically aligned: + * to 16 bytes boundary if the total size is a multiple of 16 bytes. + */ +template <typename T, int Size, int MatrixOrArrayOptions, + int Alignment = (MatrixOrArrayOptions & DontAlign) ? 0 : compute_default_alignment<T, Size>::value> +struct plain_array : check_static_allocation_size<T, Size> { + EIGEN_ALIGN_TO_BOUNDARY(Alignment) T array[Size]; +#if defined(EIGEN_NO_DEBUG) || defined(EIGEN_DISABLE_UNALIGNED_ARRAY_ASSERT) + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr plain_array() = default; +#else + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr plain_array() { EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(Alignment - 1); } +#endif }; template <typename T, int Size, int MatrixOrArrayOptions> -struct plain_array<T, Size, MatrixOrArrayOptions, 16> { - EIGEN_ALIGN_TO_BOUNDARY(16) T array[Size]; - - EIGEN_DEVICE_FUNC constexpr plain_array() { - EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(15); - check_static_allocation_size<T, Size>(); - } - - EIGEN_DEVICE_FUNC constexpr plain_array(constructor_without_unaligned_array_assert) { - check_static_allocation_size<T, Size>(); - } -}; - -template <typename T, int Size, int MatrixOrArrayOptions> -struct plain_array<T, Size, MatrixOrArrayOptions, 32> { - EIGEN_ALIGN_TO_BOUNDARY(32) T array[Size]; - - EIGEN_DEVICE_FUNC constexpr plain_array() { - EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(31); - check_static_allocation_size<T, Size>(); - } - - EIGEN_DEVICE_FUNC constexpr plain_array(constructor_without_unaligned_array_assert) { - check_static_allocation_size<T, Size>(); - } -}; - -template <typename T, int Size, int MatrixOrArrayOptions> -struct plain_array<T, Size, MatrixOrArrayOptions, 64> { - EIGEN_ALIGN_TO_BOUNDARY(64) T array[Size]; - - EIGEN_DEVICE_FUNC constexpr plain_array() { - EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(63); - check_static_allocation_size<T, Size>(); - } - - EIGEN_DEVICE_FUNC constexpr plain_array(constructor_without_unaligned_array_assert) { - check_static_allocation_size<T, Size>(); - } +struct plain_array<T, Size, MatrixOrArrayOptions, 0> : check_static_allocation_size<T, Size> { + T array[Size]; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr plain_array() = default; }; template <typename T, int MatrixOrArrayOptions, int Alignment> struct plain_array<T, 0, MatrixOrArrayOptions, Alignment> { T array[1]; - EIGEN_DEVICE_FUNC constexpr plain_array() {} - EIGEN_DEVICE_FUNC constexpr plain_array(constructor_without_unaligned_array_assert) {} + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr plain_array() = default; }; -struct plain_array_helper { - template <typename T, int Size, int MatrixOrArrayOptions, int Alignment> - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static void copy( - const plain_array<T, Size, MatrixOrArrayOptions, Alignment>& src, const Eigen::Index size, - plain_array<T, Size, MatrixOrArrayOptions, Alignment>& dst) { - smart_copy(src.array, src.array + size, dst.array); - } +// this class is intended to be inherited by DenseStorage to take advantage of empty base optimization +template <int Rows, int Cols> +struct DenseStorageIndices { + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorageIndices() = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorageIndices(const DenseStorageIndices&) = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorageIndices(DenseStorageIndices&&) = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorageIndices& operator=(const DenseStorageIndices&) = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorageIndices& operator=(DenseStorageIndices&&) = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorageIndices(Index /*rows*/, Index /*cols*/) {} + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Index rows() const { return Rows; } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Index cols() const { return Cols; } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Index size() const { return Rows * Cols; } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr void set(Index /*rows*/, Index /*cols*/) {} + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr void swap(DenseStorageIndices& /*other*/) noexcept {} +}; +template <int Rows> +struct DenseStorageIndices<Rows, Dynamic> { + Index m_cols; - template <typename T, int Size, int MatrixOrArrayOptions, int Alignment> - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static void swap(plain_array<T, Size, MatrixOrArrayOptions, Alignment>& a, - const Eigen::Index a_size, - plain_array<T, Size, MatrixOrArrayOptions, Alignment>& b, - const Eigen::Index b_size) { - if (a_size < b_size) { - std::swap_ranges(b.array, b.array + a_size, a.array); - smart_move(b.array + a_size, b.array + b_size, a.array + a_size); - } else if (a_size > b_size) { - std::swap_ranges(a.array, a.array + b_size, b.array); - smart_move(a.array + b_size, a.array + a_size, b.array + b_size); - } else { - std::swap_ranges(a.array, a.array + a_size, b.array); - } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorageIndices() : m_cols(0) {} + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorageIndices(const DenseStorageIndices&) = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorageIndices(DenseStorageIndices&&) = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorageIndices& operator=(const DenseStorageIndices&) = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorageIndices& operator=(DenseStorageIndices&&) = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DenseStorageIndices(Index /*rows*/, Index cols) : m_cols(cols) {} + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Index rows() const { return Rows; } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index cols() const { return m_cols; } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index size() const { return Rows * m_cols; } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void set(Index /*rows*/, Index cols) { m_cols = cols; } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void swap(DenseStorageIndices& other) noexcept { + numext::swap(m_cols, other.m_cols); } }; +template <int Cols> +struct DenseStorageIndices<Dynamic, Cols> { + Index m_rows; + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorageIndices() : m_rows(0) {} + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorageIndices(const DenseStorageIndices&) = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorageIndices(DenseStorageIndices&&) = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorageIndices& operator=(const DenseStorageIndices&) = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorageIndices& operator=(DenseStorageIndices&&) = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DenseStorageIndices(Index rows, Index /*cols*/) : m_rows(rows) {} + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rows() const { return m_rows; } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Index cols() const { return Cols; } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index size() const { return m_rows * Cols; } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void set(Index rows, Index /*cols*/) { m_rows = rows; } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void swap(DenseStorageIndices& other) noexcept { + numext::swap(m_rows, other.m_rows); + } +}; +template <> +struct DenseStorageIndices<Dynamic, Dynamic> { + Index m_rows; + Index m_cols; + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorageIndices() : m_rows(0), m_cols(0) {} + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorageIndices(const DenseStorageIndices&) = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorageIndices(DenseStorageIndices&&) = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorageIndices& operator=(const DenseStorageIndices&) = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorageIndices& operator=(DenseStorageIndices&&) = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DenseStorageIndices(Index rows, Index cols) : m_rows(rows), m_cols(cols) {} + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rows() const { return m_rows; } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index cols() const { return m_cols; } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index size() const { return m_rows * m_cols; } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void set(Index rows, Index cols) { + m_rows = rows; + m_cols = cols; + } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void swap(DenseStorageIndices& other) noexcept { + numext::swap(m_rows, other.m_rows); + numext::swap(m_cols, other.m_cols); + } +}; + +template <int Size, int Rows, int Cols> +struct use_trivial_ctors { + static constexpr bool value = (Size >= 0) && (Rows >= 0) && (Cols >= 0) && (Size == Rows * Cols); +}; } // end namespace internal @@ -165,486 +165,202 @@ * * \sa Matrix */ -template <typename T, int Size, int Rows_, int Cols_, int Options_> +template <typename T, int Size, int Rows, int Cols, int Options, + bool Trivial = internal::use_trivial_ctors<Size, Rows, Cols>::value> class DenseStorage; -// purely fixed-size matrix -template <typename T, int Size, int Rows_, int Cols_, int Options_> -class DenseStorage { - internal::plain_array<T, Size, Options_> m_data; +// fixed-size storage with fixed dimensions +template <typename T, int Size, int Rows, int Cols, int Options> +class DenseStorage<T, Size, Rows, Cols, Options, true> : internal::DenseStorageIndices<Rows, Cols> { + using Base = internal::DenseStorageIndices<Rows, Cols>; + + internal::plain_array<T, Size, Options> m_data; public: - constexpr EIGEN_DEVICE_FUNC DenseStorage(){EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN( - Index size = - Size)} EIGEN_DEVICE_FUNC explicit constexpr DenseStorage(internal::constructor_without_unaligned_array_assert) - : m_data(internal::constructor_without_unaligned_array_assert()) {} -#if defined(EIGEN_DENSE_STORAGE_CTOR_PLUGIN) - EIGEN_DEVICE_FUNC constexpr DenseStorage(const DenseStorage& other) - : m_data(other.m_data){EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(Index size = Size)} + using Base::cols; + using Base::rows; +#ifndef EIGEN_DENSE_STORAGE_CTOR_PLUGIN + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DenseStorage() = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage(const DenseStorage&) = default; #else - EIGEN_DEVICE_FUNC constexpr DenseStorage(const DenseStorage&) = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DenseStorage() { EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(Index size = Size) } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage(const DenseStorage& other) + : Base(other), m_data(other.m_data) { + EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(Index size = Size) + } #endif - EIGEN_DEVICE_FUNC constexpr DenseStorage - & - operator=(const DenseStorage&) = default; - EIGEN_DEVICE_FUNC constexpr DenseStorage(DenseStorage&&) = default; - EIGEN_DEVICE_FUNC constexpr DenseStorage& operator=(DenseStorage&&) = default; - EIGEN_DEVICE_FUNC constexpr DenseStorage(Index size, Index rows, Index cols) { + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage(DenseStorage&&) = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage& operator=(const DenseStorage&) = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage& operator=(DenseStorage&&) = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage(Index size, Index rows, Index cols) : Base(rows, cols) { EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({}) - eigen_internal_assert(size == rows * cols && rows == Rows_ && cols == Cols_); EIGEN_UNUSED_VARIABLE(size); - EIGEN_UNUSED_VARIABLE(rows); - EIGEN_UNUSED_VARIABLE(cols); } - EIGEN_DEVICE_FUNC void swap(DenseStorage& other) { numext::swap(m_data, other.m_data); } - EIGEN_DEVICE_FUNC static constexpr Index rows(void) EIGEN_NOEXCEPT { return Rows_; } - EIGEN_DEVICE_FUNC static constexpr Index cols(void) EIGEN_NOEXCEPT { return Cols_; } - EIGEN_DEVICE_FUNC constexpr void conservativeResize(Index, Index, Index) {} - EIGEN_DEVICE_FUNC constexpr void resize(Index, Index, Index) {} - EIGEN_DEVICE_FUNC constexpr const T* data() const { return m_data.array; } - EIGEN_DEVICE_FUNC constexpr T* data() { return m_data.array; } -}; - -// null matrix -template <typename T, int Rows_, int Cols_, int Options_> -class DenseStorage<T, 0, Rows_, Cols_, Options_> { - public: - static_assert(Rows_ * Cols_ == 0, "The fixed number of rows times columns must equal the storage size."); - EIGEN_DEVICE_FUNC constexpr DenseStorage() {} - EIGEN_DEVICE_FUNC explicit constexpr DenseStorage(internal::constructor_without_unaligned_array_assert) {} - EIGEN_DEVICE_FUNC constexpr DenseStorage(const DenseStorage&) {} - EIGEN_DEVICE_FUNC constexpr DenseStorage& operator=(const DenseStorage&) { return *this; } - EIGEN_DEVICE_FUNC constexpr DenseStorage(Index, Index, Index) {} - EIGEN_DEVICE_FUNC constexpr void swap(DenseStorage&) {} - EIGEN_DEVICE_FUNC static constexpr Index rows(void) EIGEN_NOEXCEPT { return Rows_; } - EIGEN_DEVICE_FUNC static constexpr Index cols(void) EIGEN_NOEXCEPT { return Cols_; } - EIGEN_DEVICE_FUNC constexpr void conservativeResize(Index, Index, Index) {} - EIGEN_DEVICE_FUNC constexpr void resize(Index, Index, Index) {} - EIGEN_DEVICE_FUNC constexpr const T* data() const { return 0; } - EIGEN_DEVICE_FUNC constexpr T* data() { return 0; } -}; - -// more specializations for null matrices; these are necessary to resolve ambiguities -template <typename T, int Options_> -class DenseStorage<T, 0, Dynamic, Dynamic, Options_> { - Index m_rows; - Index m_cols; - - public: - EIGEN_DEVICE_FUNC DenseStorage() : m_rows(0), m_cols(0) {} - EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_unaligned_array_assert) : DenseStorage() {} - EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other) : m_rows(other.m_rows), m_cols(other.m_cols) {} - EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other) { - m_rows = other.m_rows; - m_cols = other.m_cols; - return *this; - } - EIGEN_DEVICE_FUNC DenseStorage(Index, Index rows, Index cols) : m_rows(rows), m_cols(cols) { - eigen_assert(m_rows * m_cols == 0 && "The number of rows times columns must equal the storage size."); - } - EIGEN_DEVICE_FUNC void swap(DenseStorage& other) { - numext::swap(m_rows, other.m_rows); - numext::swap(m_cols, other.m_cols); - } - EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_rows; } - EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_cols; } - EIGEN_DEVICE_FUNC void conservativeResize(Index, Index rows, Index cols) { - m_rows = rows; - m_cols = cols; - eigen_assert(m_rows * m_cols == 0 && "The number of rows times columns must equal the storage size."); - } - EIGEN_DEVICE_FUNC void resize(Index, Index rows, Index cols) { - m_rows = rows; - m_cols = cols; - eigen_assert(m_rows * m_cols == 0 && "The number of rows times columns must equal the storage size."); - } - EIGEN_DEVICE_FUNC constexpr const T* data() const { return nullptr; } - EIGEN_DEVICE_FUNC constexpr T* data() { return nullptr; } -}; - -template <typename T, int Rows_, int Options_> -class DenseStorage<T, 0, Rows_, Dynamic, Options_> { - Index m_cols; - - public: - EIGEN_DEVICE_FUNC DenseStorage() : m_cols(0) {} - EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_unaligned_array_assert) : DenseStorage() {} - EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other) : m_cols(other.m_cols) {} - EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other) { - m_cols = other.m_cols; - return *this; - } - EIGEN_DEVICE_FUNC DenseStorage(Index, Index, Index cols) : m_cols(cols) { - eigen_assert(Rows_ * m_cols == 0 && "The number of rows times columns must equal the storage size."); - } - EIGEN_DEVICE_FUNC void swap(DenseStorage& other) { numext::swap(m_cols, other.m_cols); } - EIGEN_DEVICE_FUNC static EIGEN_CONSTEXPR Index rows(void) EIGEN_NOEXCEPT { return Rows_; } - EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index cols(void) const EIGEN_NOEXCEPT { return m_cols; } - EIGEN_DEVICE_FUNC void conservativeResize(Index, Index, Index cols) { - m_cols = cols; - eigen_assert(Rows_ * m_cols == 0 && "The number of rows times columns must equal the storage size."); - } - EIGEN_DEVICE_FUNC void resize(Index, Index, Index cols) { - m_cols = cols; - eigen_assert(Rows_ * m_cols == 0 && "The number of rows times columns must equal the storage size."); - } - EIGEN_DEVICE_FUNC constexpr const T* data() const { return nullptr; } - EIGEN_DEVICE_FUNC constexpr T* data() { return nullptr; } -}; - -template <typename T, int Cols_, int Options_> -class DenseStorage<T, 0, Dynamic, Cols_, Options_> { - Index m_rows; - - public: - EIGEN_DEVICE_FUNC DenseStorage() : m_rows(0) {} - EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_unaligned_array_assert) : DenseStorage() {} - EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other) : m_rows(other.m_rows) {} - EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other) { - m_rows = other.m_rows; - return *this; - } - EIGEN_DEVICE_FUNC DenseStorage(Index, Index rows, Index) : m_rows(rows) { - eigen_assert(m_rows * Cols_ == 0 && "The number of rows times columns must equal the storage size."); - } - EIGEN_DEVICE_FUNC void swap(DenseStorage& other) { numext::swap(m_rows, other.m_rows); } - EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index rows(void) const EIGEN_NOEXCEPT { return m_rows; } - EIGEN_DEVICE_FUNC static EIGEN_CONSTEXPR Index cols(void) EIGEN_NOEXCEPT { return Cols_; } - EIGEN_DEVICE_FUNC void conservativeResize(Index, Index rows, Index) { - m_rows = rows; - eigen_assert(m_rows * Cols_ == 0 && "The number of rows times columns must equal the storage size."); - } - EIGEN_DEVICE_FUNC void resize(Index, Index rows, Index) { - m_rows = rows; - eigen_assert(m_rows * Cols_ == 0 && "The number of rows times columns must equal the storage size."); - } - EIGEN_DEVICE_FUNC constexpr const T* data() const { return nullptr; } - EIGEN_DEVICE_FUNC constexpr T* data() { return nullptr; } -}; - -// dynamic-size matrix with fixed-size storage -template <typename T, int Size, int Options_> -class DenseStorage<T, Size, Dynamic, Dynamic, Options_> { - internal::plain_array<T, Size, Options_> m_data; - Index m_rows; - Index m_cols; - - public: - EIGEN_DEVICE_FUNC constexpr DenseStorage() : m_data(), m_rows(0), m_cols(0) {} - EIGEN_DEVICE_FUNC explicit constexpr DenseStorage(internal::constructor_without_unaligned_array_assert) - : m_data(internal::constructor_without_unaligned_array_assert()), m_rows(0), m_cols(0) {} - EIGEN_DEVICE_FUNC constexpr DenseStorage(const DenseStorage& other) - : m_data(internal::constructor_without_unaligned_array_assert()), m_rows(other.m_rows), m_cols(other.m_cols) { - internal::plain_array_helper::copy(other.m_data, m_rows * m_cols, m_data); - } - EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other) { - if (this != &other) { - m_rows = other.m_rows; - m_cols = other.m_cols; - internal::plain_array_helper::copy(other.m_data, m_rows * m_cols, m_data); - } - return *this; - } - EIGEN_DEVICE_FUNC constexpr DenseStorage(Index, Index rows, Index cols) : m_rows(rows), m_cols(cols) {} - EIGEN_DEVICE_FUNC void swap(DenseStorage& other) { - internal::plain_array_helper::swap(m_data, m_rows * m_cols, other.m_data, other.m_rows * other.m_cols); - numext::swap(m_rows, other.m_rows); - numext::swap(m_cols, other.m_cols); - } - EIGEN_DEVICE_FUNC constexpr Index rows() const { return m_rows; } - EIGEN_DEVICE_FUNC constexpr Index cols() const { return m_cols; } - EIGEN_DEVICE_FUNC constexpr void conservativeResize(Index, Index rows, Index cols) { - m_rows = rows; - m_cols = cols; - } - EIGEN_DEVICE_FUNC constexpr void resize(Index, Index rows, Index cols) { - m_rows = rows; - m_cols = cols; - } - EIGEN_DEVICE_FUNC constexpr const T* data() const { return m_data.array; } - EIGEN_DEVICE_FUNC constexpr T* data() { return m_data.array; } -}; - -// dynamic-size matrix with fixed-size storage and fixed width -template <typename T, int Size, int Cols_, int Options_> -class DenseStorage<T, Size, Dynamic, Cols_, Options_> { - internal::plain_array<T, Size, Options_> m_data; - Index m_rows; - - public: - EIGEN_DEVICE_FUNC constexpr DenseStorage() : m_rows(0) {} - EIGEN_DEVICE_FUNC explicit constexpr DenseStorage(internal::constructor_without_unaligned_array_assert) - : m_data(internal::constructor_without_unaligned_array_assert()), m_rows(0) {} - EIGEN_DEVICE_FUNC constexpr DenseStorage(const DenseStorage& other) - : m_data(internal::constructor_without_unaligned_array_assert()), m_rows(other.m_rows) { - internal::plain_array_helper::copy(other.m_data, m_rows * Cols_, m_data); - } - - EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other) { - if (this != &other) { - m_rows = other.m_rows; - internal::plain_array_helper::copy(other.m_data, m_rows * Cols_, m_data); - } - return *this; - } - EIGEN_DEVICE_FUNC constexpr DenseStorage(Index, Index rows, Index) : m_rows(rows) {} - EIGEN_DEVICE_FUNC void swap(DenseStorage& other) { - internal::plain_array_helper::swap(m_data, m_rows * Cols_, other.m_data, other.m_rows * Cols_); - numext::swap(m_rows, other.m_rows); - } - EIGEN_DEVICE_FUNC constexpr Index rows(void) const EIGEN_NOEXCEPT { return m_rows; } - EIGEN_DEVICE_FUNC constexpr Index cols(void) const EIGEN_NOEXCEPT { return Cols_; } - EIGEN_DEVICE_FUNC constexpr void conservativeResize(Index, Index rows, Index) { m_rows = rows; } - EIGEN_DEVICE_FUNC constexpr void resize(Index, Index rows, Index) { m_rows = rows; } - EIGEN_DEVICE_FUNC constexpr const T* data() const { return m_data.array; } - EIGEN_DEVICE_FUNC constexpr T* data() { return m_data.array; } -}; - -// dynamic-size matrix with fixed-size storage and fixed height -template <typename T, int Size, int Rows_, int Options_> -class DenseStorage<T, Size, Rows_, Dynamic, Options_> { - internal::plain_array<T, Size, Options_> m_data; - Index m_cols; - - public: - EIGEN_DEVICE_FUNC constexpr DenseStorage() : m_cols(0) {} - EIGEN_DEVICE_FUNC explicit constexpr DenseStorage(internal::constructor_without_unaligned_array_assert) - : m_data(internal::constructor_without_unaligned_array_assert()), m_cols(0) {} - EIGEN_DEVICE_FUNC constexpr DenseStorage(const DenseStorage& other) - : m_data(internal::constructor_without_unaligned_array_assert()), m_cols(other.m_cols) { - internal::plain_array_helper::copy(other.m_data, Rows_ * m_cols, m_data); - } - EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other) { - if (this != &other) { - m_cols = other.m_cols; - internal::plain_array_helper::copy(other.m_data, Rows_ * m_cols, m_data); - } - return *this; - } - EIGEN_DEVICE_FUNC DenseStorage(Index, Index, Index cols) : m_cols(cols) {} - EIGEN_DEVICE_FUNC void swap(DenseStorage& other) { - internal::plain_array_helper::swap(m_data, Rows_ * m_cols, other.m_data, Rows_ * other.m_cols); - numext::swap(m_cols, other.m_cols); - } - EIGEN_DEVICE_FUNC constexpr Index rows(void) const EIGEN_NOEXCEPT { return Rows_; } - EIGEN_DEVICE_FUNC constexpr Index cols(void) const EIGEN_NOEXCEPT { return m_cols; } - EIGEN_DEVICE_FUNC constexpr void conservativeResize(Index, Index, Index cols) { m_cols = cols; } - EIGEN_DEVICE_FUNC constexpr void resize(Index, Index, Index cols) { m_cols = cols; } - EIGEN_DEVICE_FUNC constexpr const T* data() const { return m_data.array; } - EIGEN_DEVICE_FUNC constexpr T* data() { return m_data.array; } -}; - -// purely dynamic matrix. -template <typename T, int Options_> -class DenseStorage<T, Dynamic, Dynamic, Dynamic, Options_> { - T* m_data; - Index m_rows; - Index m_cols; - - public: - EIGEN_DEVICE_FUNC constexpr DenseStorage() : m_data(0), m_rows(0), m_cols(0) {} - EIGEN_DEVICE_FUNC explicit constexpr DenseStorage(internal::constructor_without_unaligned_array_assert) - : m_data(0), m_rows(0), m_cols(0) {} - EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) - : m_data(internal::conditional_aligned_new_auto<T, (Options_ & DontAlign) == 0>(size)), - m_rows(rows), - m_cols(cols) { - EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({}) - eigen_internal_assert(size == rows * cols && rows >= 0 && cols >= 0); - } - EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other) - : m_data(internal::conditional_aligned_new_auto<T, (Options_ & DontAlign) == 0>(other.m_rows * other.m_cols)), - m_rows(other.m_rows), - m_cols(other.m_cols) { - EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(Index size = m_rows * m_cols) - internal::smart_copy(other.m_data, other.m_data + other.m_rows * other.m_cols, m_data); - } - EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other) { - if (this != &other) { - DenseStorage tmp(other); - this->swap(tmp); - } - return *this; - } - EIGEN_DEVICE_FUNC DenseStorage(DenseStorage&& other) EIGEN_NOEXCEPT : m_data(std::move(other.m_data)), - m_rows(std::move(other.m_rows)), - m_cols(std::move(other.m_cols)) { - other.m_data = nullptr; - other.m_rows = 0; - other.m_cols = 0; - } - EIGEN_DEVICE_FUNC DenseStorage& operator=(DenseStorage&& other) EIGEN_NOEXCEPT { + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr void swap(DenseStorage& other) { numext::swap(m_data, other.m_data); - numext::swap(m_rows, other.m_rows); - numext::swap(m_cols, other.m_cols); + Base::swap(other); + } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr void conservativeResize(Index /*size*/, Index rows, Index cols) { + Base::set(rows, cols); + } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr void resize(Index /*size*/, Index rows, Index cols) { + Base::set(rows, cols); + } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr T* data() { return m_data.array; } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr const T* data() const { return m_data.array; } +}; +// fixed-size storage with dynamic dimensions +template <typename T, int Size, int Rows, int Cols, int Options> +class DenseStorage<T, Size, Rows, Cols, Options, false> : internal::DenseStorageIndices<Rows, Cols> { + using Base = internal::DenseStorageIndices<Rows, Cols>; + + internal::plain_array<T, Size, Options> m_data; + + public: + using Base::cols; + using Base::rows; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DenseStorage() = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage(const DenseStorage& other) : Base(other), m_data() { + Index size = other.size(); + EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({}) + internal::smart_copy(other.m_data.array, other.m_data.array + size, m_data.array); + } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage(DenseStorage&& other) : Base(other), m_data() { + Index size = other.size(); + internal::smart_move(other.m_data.array, other.m_data.array + size, m_data.array); + other.resize(Size, 0, 0); + } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage& operator=(const DenseStorage& other) { + Base::set(other.rows(), other.cols()); + Index size = other.size(); + internal::smart_copy(other.m_data.array, other.m_data.array + size, m_data.array); return *this; } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage& operator=(DenseStorage&& other) { + Base::set(other.rows(), other.cols()); + Index size = other.size(); + internal::smart_move(other.m_data.array, other.m_data.array + size, m_data.array); + other.resize(Size, 0, 0); + return *this; + } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage(Index size, Index rows, Index cols) : Base(rows, cols) { + EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({}) + EIGEN_UNUSED_VARIABLE(size); + } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr void swap(DenseStorage& other) { + Index thisSize = this->size(); + Index otherSize = other.size(); + Index commonSize = numext::mini(thisSize, otherSize); + std::swap_ranges(m_data.array, m_data.array + commonSize, other.m_data.array); + if (thisSize > otherSize) + internal::smart_move(m_data.array + commonSize, m_data.array + thisSize, other.m_data.array + commonSize); + else if (otherSize > thisSize) + internal::smart_move(other.m_data.array + commonSize, other.m_data.array + otherSize, m_data.array + commonSize); + Base::swap(other); + } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr void conservativeResize(Index /*size*/, Index rows, Index cols) { + Base::set(rows, cols); + } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr void resize(Index /*size*/, Index rows, Index cols) { + Base::set(rows, cols); + } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr T* data() { return m_data.array; } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr const T* data() const { return m_data.array; } +}; +// null matrix specialization +template <typename T, int Rows, int Cols, int Options> +class DenseStorage<T, 0, Rows, Cols, Options, true> : internal::DenseStorageIndices<Rows, Cols> { + using Base = internal::DenseStorageIndices<Rows, Cols>; + + public: + using Base::cols; + using Base::rows; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage() = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage(const DenseStorage&) = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage(DenseStorage&&) = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage& operator=(const DenseStorage&) = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage& operator=(DenseStorage&&) = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage(Index /*size*/, Index rows, Index cols) + : Base(rows, cols) {} + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr void swap(DenseStorage& other) noexcept { Base::swap(other); } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr void conservativeResize(Index /*size*/, Index rows, Index cols) { + Base::set(rows, cols); + } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr void resize(Index /*size*/, Index rows, Index cols) { + Base::set(rows, cols); + } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr T* data() { return nullptr; } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr const T* data() const { return nullptr; } +}; +// dynamic matrix specialization +template <typename T, int Rows, int Cols, int Options> +class DenseStorage<T, Dynamic, Rows, Cols, Options, false> : internal::DenseStorageIndices<Rows, Cols> { + using Base = internal::DenseStorageIndices<Rows, Cols>; + static constexpr int Size = Dynamic; + static constexpr bool Align = (Options & DontAlign) == 0; + + T* m_data; + + public: + using Base::cols; + using Base::rows; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage() : m_data(nullptr) {} + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage(const DenseStorage& other) + : Base(other), m_data(internal::conditional_aligned_new_auto<T, Align>(other.size())) { + Index size = other.size(); + EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({}) + internal::smart_copy(other.m_data, other.m_data + size, m_data); + } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage(DenseStorage&& other) noexcept + : Base(other), m_data(other.m_data) { + other.set(0, 0); + other.m_data = nullptr; + } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage& operator=(const DenseStorage& other) { + Base::set(other.rows(), other.cols()); + Index size = other.size(); + m_data = internal::conditional_aligned_new_auto<T, Align>(size); + EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({}) + internal::smart_copy(other.m_data, other.m_data + size, m_data); + return *this; + } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage& operator=(DenseStorage&& other) noexcept { + this->swap(other); + return *this; + } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage(Index size, Index rows, Index cols) + : Base(rows, cols), m_data(internal::conditional_aligned_new_auto<T, Align>(size)) { + EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({}) + } EIGEN_DEVICE_FUNC ~DenseStorage() { - internal::conditional_aligned_delete_auto<T, (Options_ & DontAlign) == 0>(m_data, m_rows * m_cols); + Index size = this->size(); + internal::conditional_aligned_delete_auto<T, Align>(m_data, size); } - EIGEN_DEVICE_FUNC void swap(DenseStorage& other) { + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr void swap(DenseStorage& other) noexcept { numext::swap(m_data, other.m_data); - numext::swap(m_rows, other.m_rows); - numext::swap(m_cols, other.m_cols); + Base::swap(other); } - EIGEN_DEVICE_FUNC Index rows(void) const EIGEN_NOEXCEPT { return m_rows; } - EIGEN_DEVICE_FUNC Index cols(void) const EIGEN_NOEXCEPT { return m_cols; } - void conservativeResize(Index size, Index rows, Index cols) { - m_data = - internal::conditional_aligned_realloc_new_auto<T, (Options_ & DontAlign) == 0>(m_data, size, m_rows * m_cols); - m_rows = rows; - m_cols = cols; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr void conservativeResize(Index size, Index rows, Index cols) { + Index oldSize = this->size(); + m_data = internal::conditional_aligned_realloc_new_auto<T, Align>(m_data, size, oldSize); + Base::set(rows, cols); } - EIGEN_DEVICE_FUNC void resize(Index size, Index rows, Index cols) { - if (size != m_rows * m_cols) { - internal::conditional_aligned_delete_auto<T, (Options_ & DontAlign) == 0>(m_data, m_rows * m_cols); + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr void resize(Index size, Index rows, Index cols) { + Index oldSize = this->size(); + if (size != oldSize) { + internal::conditional_aligned_delete_auto<T, Align>(m_data, oldSize); if (size > 0) // >0 and not simply !=0 to let the compiler knows that size cannot be negative - m_data = internal::conditional_aligned_new_auto<T, (Options_ & DontAlign) == 0>(size); - else - m_data = 0; - EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({}) + { + m_data = internal::conditional_aligned_new_auto<T, Align>(size); + EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({}) + } else + m_data = nullptr; } - m_rows = rows; - m_cols = cols; + Base::set(rows, cols); } - EIGEN_DEVICE_FUNC constexpr const T* data() const { return m_data; } - EIGEN_DEVICE_FUNC constexpr T* data() { return m_data; } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr T* data() { return m_data; } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr const T* data() const { return m_data; } }; - -// matrix with dynamic width and fixed height (so that matrix has dynamic size). -template <typename T, int Rows_, int Options_> -class DenseStorage<T, Dynamic, Rows_, Dynamic, Options_> { - T* m_data; - Index m_cols; - - public: - EIGEN_DEVICE_FUNC constexpr DenseStorage() : m_data(0), m_cols(0) {} - explicit constexpr DenseStorage(internal::constructor_without_unaligned_array_assert) : m_data(0), m_cols(0) {} - EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) - : m_data(internal::conditional_aligned_new_auto<T, (Options_ & DontAlign) == 0>(size)), m_cols(cols) { - EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({}) - eigen_internal_assert(size == rows * cols && rows == Rows_ && cols >= 0); - EIGEN_UNUSED_VARIABLE(rows); - } - EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other) - : m_data(internal::conditional_aligned_new_auto<T, (Options_ & DontAlign) == 0>(Rows_ * other.m_cols)), - m_cols(other.m_cols) { - EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(Index size = m_cols * Rows_) - internal::smart_copy(other.m_data, other.m_data + Rows_ * m_cols, m_data); - } - EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other) { - if (this != &other) { - DenseStorage tmp(other); - this->swap(tmp); - } - return *this; - } - EIGEN_DEVICE_FUNC DenseStorage(DenseStorage&& other) EIGEN_NOEXCEPT : m_data(std::move(other.m_data)), - m_cols(std::move(other.m_cols)) { - other.m_data = nullptr; - other.m_cols = 0; - } - EIGEN_DEVICE_FUNC DenseStorage& operator=(DenseStorage&& other) EIGEN_NOEXCEPT { - numext::swap(m_data, other.m_data); - numext::swap(m_cols, other.m_cols); - return *this; - } - EIGEN_DEVICE_FUNC ~DenseStorage() { - internal::conditional_aligned_delete_auto<T, (Options_ & DontAlign) == 0>(m_data, Rows_ * m_cols); - } - EIGEN_DEVICE_FUNC void swap(DenseStorage& other) { - numext::swap(m_data, other.m_data); - numext::swap(m_cols, other.m_cols); - } - EIGEN_DEVICE_FUNC static constexpr Index rows(void) EIGEN_NOEXCEPT { return Rows_; } - EIGEN_DEVICE_FUNC Index cols(void) const EIGEN_NOEXCEPT { return m_cols; } - EIGEN_DEVICE_FUNC void conservativeResize(Index size, Index, Index cols) { - m_data = - internal::conditional_aligned_realloc_new_auto<T, (Options_ & DontAlign) == 0>(m_data, size, Rows_ * m_cols); - m_cols = cols; - } - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resize(Index size, Index, Index cols) { - if (size != Rows_ * m_cols) { - internal::conditional_aligned_delete_auto<T, (Options_ & DontAlign) == 0>(m_data, Rows_ * m_cols); - if (size > 0) // >0 and not simply !=0 to let the compiler knows that size cannot be negative - m_data = internal::conditional_aligned_new_auto<T, (Options_ & DontAlign) == 0>(size); - else - m_data = 0; - EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({}) - } - m_cols = cols; - } - EIGEN_DEVICE_FUNC constexpr const T* data() const { return m_data; } - EIGEN_DEVICE_FUNC constexpr T* data() { return m_data; } -}; - -// matrix with dynamic height and fixed width (so that matrix has dynamic size). -template <typename T, int Cols_, int Options_> -class DenseStorage<T, Dynamic, Dynamic, Cols_, Options_> { - T* m_data; - Index m_rows; - - public: - EIGEN_DEVICE_FUNC constexpr DenseStorage() : m_data(0), m_rows(0) {} - explicit constexpr DenseStorage(internal::constructor_without_unaligned_array_assert) : m_data(0), m_rows(0) {} - EIGEN_DEVICE_FUNC constexpr DenseStorage(Index size, Index rows, Index cols) - : m_data(internal::conditional_aligned_new_auto<T, (Options_ & DontAlign) == 0>(size)), m_rows(rows) { - EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({}) - eigen_internal_assert(size == rows * cols && rows >= 0 && cols == Cols_); - EIGEN_UNUSED_VARIABLE(cols); - } - EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other) - : m_data(internal::conditional_aligned_new_auto<T, (Options_ & DontAlign) == 0>(other.m_rows * Cols_)), - m_rows(other.m_rows) { - EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(Index size = m_rows * Cols_) - internal::smart_copy(other.m_data, other.m_data + other.m_rows * Cols_, m_data); - } - EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other) { - if (this != &other) { - DenseStorage tmp(other); - this->swap(tmp); - } - return *this; - } - EIGEN_DEVICE_FUNC DenseStorage(DenseStorage&& other) EIGEN_NOEXCEPT : m_data(std::move(other.m_data)), - m_rows(std::move(other.m_rows)) { - other.m_data = nullptr; - other.m_rows = 0; - } - EIGEN_DEVICE_FUNC DenseStorage& operator=(DenseStorage&& other) EIGEN_NOEXCEPT { - numext::swap(m_data, other.m_data); - numext::swap(m_rows, other.m_rows); - return *this; - } - EIGEN_DEVICE_FUNC ~DenseStorage() { - internal::conditional_aligned_delete_auto<T, (Options_ & DontAlign) == 0>(m_data, Cols_ * m_rows); - } - EIGEN_DEVICE_FUNC void swap(DenseStorage& other) { - numext::swap(m_data, other.m_data); - numext::swap(m_rows, other.m_rows); - } - EIGEN_DEVICE_FUNC Index rows(void) const EIGEN_NOEXCEPT { return m_rows; } - EIGEN_DEVICE_FUNC static constexpr Index cols(void) { return Cols_; } - void conservativeResize(Index size, Index rows, Index) { - m_data = - internal::conditional_aligned_realloc_new_auto<T, (Options_ & DontAlign) == 0>(m_data, size, m_rows * Cols_); - m_rows = rows; - } - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resize(Index size, Index rows, Index) { - if (size != m_rows * Cols_) { - internal::conditional_aligned_delete_auto<T, (Options_ & DontAlign) == 0>(m_data, Cols_ * m_rows); - if (size > 0) // >0 and not simply !=0 to let the compiler knows that size cannot be negative - m_data = internal::conditional_aligned_new_auto<T, (Options_ & DontAlign) == 0>(size); - else - m_data = 0; - EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({}) - } - m_rows = rows; - } - EIGEN_DEVICE_FUNC constexpr const T* data() const { return m_data; } - EIGEN_DEVICE_FUNC constexpr T* data() { return m_data; } -}; - } // end namespace Eigen #endif // EIGEN_MATRIX_H
diff --git a/Eigen/src/Core/GeneralProduct.h b/Eigen/src/Core/GeneralProduct.h index dc12481..e4c51d2 100644 --- a/Eigen/src/Core/GeneralProduct.h +++ b/Eigen/src/Core/GeneralProduct.h
@@ -327,6 +327,7 @@ if (!evalToDest) { #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN + constexpr int Size = Dest::SizeAtCompileTime; Index size = dest.size(); EIGEN_DENSE_STORAGE_CTOR_PLUGIN #endif @@ -391,6 +392,7 @@ if (!DirectlyUseRhs) { #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN + constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime; Index size = actualRhs.size(); EIGEN_DENSE_STORAGE_CTOR_PLUGIN #endif
diff --git a/Eigen/src/Core/Matrix.h b/Eigen/src/Core/Matrix.h index 2c64936..8b7f70c 100644 --- a/Eigen/src/Core/Matrix.h +++ b/Eigen/src/Core/Matrix.h
@@ -250,15 +250,12 @@ * * \sa resize(Index,Index) */ - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Matrix() - : Base(){EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED} - - // FIXME is it still needed - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr explicit Matrix( - internal::constructor_without_unaligned_array_assert) - : Base(internal::constructor_without_unaligned_array_assert()){EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED} - - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Matrix(Matrix && other) = default; +#if defined(EIGEN_INITIALIZE_COEFFS) + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Matrix() { EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED } +#else + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Matrix() = default; +#endif + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Matrix(Matrix&&) = default; EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Matrix& operator=(Matrix&& other) EIGEN_NOEXCEPT_IF(std::is_nothrow_move_assignable<Scalar>::value) { Base::operator=(std::move(other)); @@ -377,7 +374,7 @@ } /** \brief Copy constructor */ - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Matrix(const Matrix& other) = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Matrix(const Matrix&) = default; /** \brief Copy constructor for generic expressions. * \sa MatrixBase::operator=(const EigenBase<OtherDerived>&)
diff --git a/Eigen/src/Core/PlainObjectBase.h b/Eigen/src/Core/PlainObjectBase.h index 62195f4..8720c44 100644 --- a/Eigen/src/Core/PlainObjectBase.h +++ b/Eigen/src/Core/PlainObjectBase.h
@@ -472,32 +472,17 @@ // Prevent user from trying to instantiate PlainObjectBase objects // by making all its constructor protected. See bug 1074. protected: - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr PlainObjectBase() : m_storage() { - // EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED - } - -#ifndef EIGEN_PARSED_BY_DOXYGEN - // FIXME is it still needed ? - /** \internal */ - EIGEN_DEVICE_FUNC constexpr explicit PlainObjectBase(internal::constructor_without_unaligned_array_assert) - : m_storage(internal::constructor_without_unaligned_array_assert()) { - // EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED - } -#endif - - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr PlainObjectBase(PlainObjectBase&& other) = default; - + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr PlainObjectBase() = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr PlainObjectBase(PlainObjectBase&&) = default; EIGEN_DEVICE_FUNC constexpr PlainObjectBase& operator=(PlainObjectBase&& other) EIGEN_NOEXCEPT { m_storage = std::move(other.m_storage); return *this; } /** Copy constructor */ - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr PlainObjectBase(const PlainObjectBase& other) = default; + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr PlainObjectBase(const PlainObjectBase&) = default; EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PlainObjectBase(Index size, Index rows, Index cols) - : m_storage(size, rows, cols) { - // EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED - } + : m_storage(size, rows, cols) {} /** \brief Construct a row of column vector with fixed size from an arbitrary number of coefficients. *
diff --git a/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h b/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h index ac94b3f..09cda54 100644 --- a/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h +++ b/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
@@ -157,7 +157,7 @@ gebp_kernel<LhsScalar, RhsScalar, Index, ResMapper, mr, nr, ConjLhs, ConjRhs> gebp_kernel1; gebp_kernel<LhsScalar, RhsScalar, Index, BufferMapper, mr, nr, ConjLhs, ConjRhs> gebp_kernel2; - Matrix<ResScalar, BlockSize, BlockSize, ColMajor> buffer((internal::constructor_without_unaligned_array_assert())); + Matrix<ResScalar, BlockSize, BlockSize, ColMajor> buffer; // let's process the block per panel of actual_mc x BlockSize, // again, each is split into three parts, etc.
diff --git a/Eigen/src/Core/products/SelfadjointMatrixVector.h b/Eigen/src/Core/products/SelfadjointMatrixVector.h index 9333d16..10f6026 100644 --- a/Eigen/src/Core/products/SelfadjointMatrixVector.h +++ b/Eigen/src/Core/products/SelfadjointMatrixVector.h
@@ -197,6 +197,7 @@ if (!EvalToDest) { #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN + constexpr int Size = Dest::SizeAtCompileTime; Index size = dest.size(); EIGEN_DENSE_STORAGE_CTOR_PLUGIN #endif @@ -205,6 +206,7 @@ if (!UseRhs) { #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN + constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime; Index size = rhs.size(); EIGEN_DENSE_STORAGE_CTOR_PLUGIN #endif
diff --git a/Eigen/src/Core/products/TriangularMatrixMatrix.h b/Eigen/src/Core/products/TriangularMatrixMatrix.h index c541909..a0d05ef 100644 --- a/Eigen/src/Core/products/TriangularMatrixMatrix.h +++ b/Eigen/src/Core/products/TriangularMatrixMatrix.h
@@ -113,13 +113,7 @@ ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA()); ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB()); - // To work around an "error: member reference base type 'Matrix<...> - // (Eigen::internal::constructor_without_unaligned_array_assert (*)())' is - // not a structure or union" compilation error in nvcc (tested V8.0.61), - // create a dummy internal::constructor_without_unaligned_array_assert - // object to pass to the Matrix constructor. - internal::constructor_without_unaligned_array_assert a; - Matrix<Scalar, SmallPanelWidth, SmallPanelWidth, LhsStorageOrder> triangularBuffer(a); + Matrix<Scalar, SmallPanelWidth, SmallPanelWidth, LhsStorageOrder> triangularBuffer; triangularBuffer.setZero(); if ((Mode & ZeroDiag) == ZeroDiag) triangularBuffer.diagonal().setZero(); @@ -245,8 +239,7 @@ ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA()); ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB()); - internal::constructor_without_unaligned_array_assert a; - Matrix<Scalar, SmallPanelWidth, SmallPanelWidth, RhsStorageOrder> triangularBuffer(a); + Matrix<Scalar, SmallPanelWidth, SmallPanelWidth, RhsStorageOrder> triangularBuffer; triangularBuffer.setZero(); if ((Mode & ZeroDiag) == ZeroDiag) triangularBuffer.diagonal().setZero();
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h index 05a5827..bef4cba 100644 --- a/Eigen/src/Core/products/TriangularMatrixVector.h +++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -230,6 +230,7 @@ if (!evalToDest) { #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN + constexpr int Size = Dest::SizeAtCompileTime; Index size = dest.size(); EIGEN_DENSE_STORAGE_CTOR_PLUGIN #endif @@ -310,6 +311,7 @@ #endif } #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN + constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime; Index size = actualRhs.size(); EIGEN_DENSE_STORAGE_CTOR_PLUGIN #endif
diff --git a/test/dense_storage.cpp b/test/dense_storage.cpp index 8d61e92..fa62363 100644 --- a/test/dense_storage.cpp +++ b/test/dense_storage.cpp
@@ -7,13 +7,20 @@ // Public License v. 2.0. If a copy of the MPL was not distributed // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. +#define EIGEN_TESTING_PLAINOBJECT_CTOR + +#ifndef EIGEN_DISABLE_UNALIGNED_ARRAY_ASSERT +#define EIGEN_DISABLE_UNALIGNED_ARRAY_ASSERT +#define EIGEN_TEST_REENABLE_UNALIGNED_ARRAY_ASSERT +#endif + #include "main.h" #include "AnnoyingScalar.h" #include "SafeScalar.h" #include <Eigen/Core> -using DenseStorageD3x3 = Eigen::DenseStorage<double, 3, 3, 3, 3>; +using DenseStorageD3x3 = Eigen::DenseStorage<double, 9, 3, 3, 0>; static_assert(std::is_trivially_move_constructible<DenseStorageD3x3>::value, "DenseStorage not trivially_move_constructible"); static_assert(std::is_trivially_move_assignable<DenseStorageD3x3>::value, "DenseStorage not trivially_move_assignable"); @@ -24,6 +31,14 @@ static_assert(std::is_trivially_copyable<DenseStorageD3x3>::value, "DenseStorage not trivially_copyable"); #endif +static_assert(std::is_trivially_move_constructible<Matrix4f>::value, "Matrix4f not trivially_move_constructible"); +#if !defined(EIGEN_DENSE_STORAGE_CTOR_PLUGIN) +static_assert(std::is_trivially_copy_constructible<Matrix4f>::value, "Matrix4f not trivially_copy_constructible"); +#endif +#if defined(EIGEN_DISABLE_UNALIGNED_ARRAY_ASSERT) +static_assert(std::is_trivially_default_constructible<Matrix4f>::value, "Matrix4f not trivially_default_constructible"); +#endif + template <typename T, int Size, int Rows, int Cols> void dense_storage_copy(int rows, int cols) { typedef DenseStorage<T, Size, Rows, Cols, 0> DenseStorageType; @@ -180,3 +195,9 @@ dense_storage_tests<SafeScalar<float> >(); dense_storage_tests<AnnoyingScalar>(); } + +#undef EIGEN_TESTING_PLAINOBJECT_CTOR +#ifdef EIGEN_TEST_REENABLE_UNALIGNED_ARRAY_ASSERT +#undef EIGEN_DISABLE_UNALIGNED_ARRAY_ASSERT +#undef EIGEN_TEST_REENABLE_UNALIGNED_ARRAY_ASSERT +#endif
diff --git a/test/main.h b/test/main.h index c7cc531..cde1e88 100644 --- a/test/main.h +++ b/test/main.h
@@ -142,14 +142,20 @@ static long int nb_temporaries; static long int nb_temporaries_on_assert = -1; -inline void on_temporary_creation(long int size) { +#ifdef TEST_IGNORE_STACK_ALLOCATED_TEMPORARY +inline void on_temporary_creation(long int size, int SizeAtCompileTime) { + // ignore stack-allocated temporaries + if (SizeAtCompileTime != -1) return; +#else +inline void on_temporary_creation(long int size, int) { +#endif // here's a great place to set a breakpoint when debugging failures in this test! if (size != 0) nb_temporaries++; if (nb_temporaries_on_assert > 0) assert(nb_temporaries < nb_temporaries_on_assert); } #define EIGEN_DENSE_STORAGE_CTOR_PLUGIN \ - { on_temporary_creation(size); } + { on_temporary_creation(size, Size); } #define VERIFY_EVALUATION_COUNT(XPR, N) \ { \ @@ -333,7 +339,7 @@ #endif // EIGEN_NO_ASSERTION_CHECKING -#ifndef EIGEN_TESTING_CONSTEXPR +#if !defined(EIGEN_TESTING_CONSTEXPR) && !defined(EIGEN_TESTING_PLAINOBJECT_CTOR) #define EIGEN_INTERNAL_DEBUGGING #endif #include <Eigen/QR> // required for createRandomPIMatrixOfRank and generateRandomMatrixSvs
diff --git a/test/product_notemporary.cpp b/test/product_notemporary.cpp index c22ea13..84ce3c6 100644 --- a/test/product_notemporary.cpp +++ b/test/product_notemporary.cpp
@@ -8,6 +8,7 @@ // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. #define TEST_ENABLE_TEMPORARY_TRACKING +#define TEST_IGNORE_STACK_ALLOCATED_TEMPORARY #include "main.h"
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorStorage.h b/unsupported/Eigen/CXX11/src/Tensor/TensorStorage.h index fde1b82..9647976 100644 --- a/unsupported/Eigen/CXX11/src/Tensor/TensorStorage.h +++ b/unsupported/Eigen/CXX11/src/Tensor/TensorStorage.h
@@ -71,8 +71,6 @@ m_data = internal::conditional_aligned_new_auto<T, (Options_ & DontAlign) == 0>(1); } } - EIGEN_DEVICE_FUNC TensorStorage(internal::constructor_without_unaligned_array_assert) - : m_data(0), m_dimensions(internal::template repeat<NumIndices_, Index>(0)) {} EIGEN_DEVICE_FUNC TensorStorage(Index size, const array<Index, NumIndices_>& dimensions) : m_data(internal::conditional_aligned_new_auto<T, (Options_ & DontAlign) == 0>(size)), m_dimensions(dimensions) { EIGEN_INTERNAL_TENSOR_STORAGE_CTOR_PLUGIN