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
