dense_storage.cpp (7256B)
1 // This file is part of Eigen, a lightweight C++ template library 2 // for linear algebra. 3 // 4 // Copyright (C) 2013 Hauke Heibel <hauke.heibel@gmail.com> 5 // 6 // This Source Code Form is subject to the terms of the Mozilla 7 // Public License v. 2.0. If a copy of the MPL was not distributed 8 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 10 #include "main.h" 11 #include "AnnoyingScalar.h" 12 #include "SafeScalar.h" 13 14 #include <Eigen/Core> 15 16 #if EIGEN_HAS_TYPE_TRAITS && EIGEN_HAS_CXX11 17 using DenseStorageD3x3 = Eigen::DenseStorage<double, 3, 3, 3, 3>; 18 static_assert(std::is_trivially_move_constructible<DenseStorageD3x3>::value, "DenseStorage not trivially_move_constructible"); 19 static_assert(std::is_trivially_move_assignable<DenseStorageD3x3>::value, "DenseStorage not trivially_move_assignable"); 20 #if !defined(EIGEN_DENSE_STORAGE_CTOR_PLUGIN) 21 static_assert(std::is_trivially_copy_constructible<DenseStorageD3x3>::value, "DenseStorage not trivially_copy_constructible"); 22 static_assert(std::is_trivially_copy_assignable<DenseStorageD3x3>::value, "DenseStorage not trivially_copy_assignable"); 23 static_assert(std::is_trivially_copyable<DenseStorageD3x3>::value, "DenseStorage not trivially_copyable"); 24 #endif 25 #endif 26 27 template <typename T, int Size, int Rows, int Cols> 28 void dense_storage_copy(int rows, int cols) 29 { 30 typedef DenseStorage<T, Size, Rows, Cols, 0> DenseStorageType; 31 32 const int size = rows*cols; 33 DenseStorageType reference(size, rows, cols); 34 T* raw_reference = reference.data(); 35 for (int i=0; i<size; ++i) 36 raw_reference[i] = static_cast<T>(i); 37 38 DenseStorageType copied_reference(reference); 39 const T* raw_copied_reference = copied_reference.data(); 40 for (int i=0; i<size; ++i) 41 VERIFY_IS_EQUAL(raw_reference[i], raw_copied_reference[i]); 42 } 43 44 template <typename T, int Size, int Rows, int Cols> 45 void dense_storage_assignment(int rows, int cols) 46 { 47 typedef DenseStorage<T, Size, Rows, Cols, 0> DenseStorageType; 48 49 const int size = rows*cols; 50 DenseStorageType reference(size, rows, cols); 51 T* raw_reference = reference.data(); 52 for (int i=0; i<size; ++i) 53 raw_reference[i] = static_cast<T>(i); 54 55 DenseStorageType copied_reference; 56 copied_reference = reference; 57 const T* raw_copied_reference = copied_reference.data(); 58 for (int i=0; i<size; ++i) 59 VERIFY_IS_EQUAL(raw_reference[i], raw_copied_reference[i]); 60 } 61 62 template <typename T, int Size, int Rows, int Cols> 63 void dense_storage_swap(int rows0, int cols0, int rows1, int cols1) 64 { 65 typedef DenseStorage<T, Size, Rows, Cols, 0> DenseStorageType; 66 67 const int size0 = rows0*cols0; 68 DenseStorageType a(size0, rows0, cols0); 69 for (int i=0; i<size0; ++i) { 70 a.data()[i] = static_cast<T>(i); 71 } 72 73 const int size1 = rows1*cols1; 74 DenseStorageType b(size1, rows1, cols1); 75 for (int i=0; i<size1; ++i) { 76 b.data()[i] = static_cast<T>(-i); 77 } 78 79 a.swap(b); 80 81 for (int i=0; i<size0; ++i) { 82 VERIFY_IS_EQUAL(b.data()[i], static_cast<T>(i)); 83 } 84 85 for (int i=0; i<size1; ++i) { 86 VERIFY_IS_EQUAL(a.data()[i], static_cast<T>(-i)); 87 } 88 } 89 90 template<typename T, int Size, std::size_t Alignment> 91 void dense_storage_alignment() 92 { 93 #if EIGEN_HAS_ALIGNAS 94 95 struct alignas(Alignment) Empty1 {}; 96 VERIFY_IS_EQUAL(std::alignment_of<Empty1>::value, Alignment); 97 98 struct EIGEN_ALIGN_TO_BOUNDARY(Alignment) Empty2 {}; 99 VERIFY_IS_EQUAL(std::alignment_of<Empty2>::value, Alignment); 100 101 struct Nested1 { EIGEN_ALIGN_TO_BOUNDARY(Alignment) T data[Size]; }; 102 VERIFY_IS_EQUAL(std::alignment_of<Nested1>::value, Alignment); 103 104 VERIFY_IS_EQUAL( (std::alignment_of<internal::plain_array<T,Size,AutoAlign,Alignment> >::value), Alignment); 105 106 const std::size_t default_alignment = internal::compute_default_alignment<T,Size>::value; 107 108 VERIFY_IS_EQUAL( (std::alignment_of<DenseStorage<T,Size,1,1,AutoAlign> >::value), default_alignment); 109 VERIFY_IS_EQUAL( (std::alignment_of<Matrix<T,Size,1,AutoAlign> >::value), default_alignment); 110 struct Nested2 { Matrix<T,Size,1,AutoAlign> mat; }; 111 VERIFY_IS_EQUAL(std::alignment_of<Nested2>::value, default_alignment); 112 113 #endif 114 } 115 116 template<typename T> 117 void dense_storage_tests() { 118 // Dynamic Storage. 119 dense_storage_copy<T,Dynamic,Dynamic,Dynamic>(4, 3); 120 dense_storage_copy<T,Dynamic,Dynamic,3>(4, 3); 121 dense_storage_copy<T,Dynamic,4,Dynamic>(4, 3); 122 // Fixed Storage. 123 dense_storage_copy<T,12,4,3>(4, 3); 124 dense_storage_copy<T,12,Dynamic,Dynamic>(4, 3); 125 dense_storage_copy<T,12,4,Dynamic>(4, 3); 126 dense_storage_copy<T,12,Dynamic,3>(4, 3); 127 // Fixed Storage with Uninitialized Elements. 128 dense_storage_copy<T,18,Dynamic,Dynamic>(4, 3); 129 dense_storage_copy<T,18,4,Dynamic>(4, 3); 130 dense_storage_copy<T,18,Dynamic,3>(4, 3); 131 132 // Dynamic Storage. 133 dense_storage_assignment<T,Dynamic,Dynamic,Dynamic>(4, 3); 134 dense_storage_assignment<T,Dynamic,Dynamic,3>(4, 3); 135 dense_storage_assignment<T,Dynamic,4,Dynamic>(4, 3); 136 // Fixed Storage. 137 dense_storage_assignment<T,12,4,3>(4, 3); 138 dense_storage_assignment<T,12,Dynamic,Dynamic>(4, 3); 139 dense_storage_assignment<T,12,4,Dynamic>(4, 3); 140 dense_storage_assignment<T,12,Dynamic,3>(4, 3); 141 // Fixed Storage with Uninitialized Elements. 142 dense_storage_assignment<T,18,Dynamic,Dynamic>(4, 3); 143 dense_storage_assignment<T,18,4,Dynamic>(4, 3); 144 dense_storage_assignment<T,18,Dynamic,3>(4, 3); 145 146 // Dynamic Storage. 147 dense_storage_swap<T,Dynamic,Dynamic,Dynamic>(4, 3, 4, 3); 148 dense_storage_swap<T,Dynamic,Dynamic,Dynamic>(4, 3, 2, 1); 149 dense_storage_swap<T,Dynamic,Dynamic,Dynamic>(2, 1, 4, 3); 150 dense_storage_swap<T,Dynamic,Dynamic,3>(4, 3, 4, 3); 151 dense_storage_swap<T,Dynamic,Dynamic,3>(4, 3, 2, 3); 152 dense_storage_swap<T,Dynamic,Dynamic,3>(2, 3, 4, 3); 153 dense_storage_swap<T,Dynamic,4,Dynamic>(4, 3, 4, 3); 154 dense_storage_swap<T,Dynamic,4,Dynamic>(4, 3, 4, 1); 155 dense_storage_swap<T,Dynamic,4,Dynamic>(4, 1, 4, 3); 156 // Fixed Storage. 157 dense_storage_swap<T,12,4,3>(4, 3, 4, 3); 158 dense_storage_swap<T,12,Dynamic,Dynamic>(4, 3, 4, 3); 159 dense_storage_swap<T,12,Dynamic,Dynamic>(4, 3, 2, 1); 160 dense_storage_swap<T,12,Dynamic,Dynamic>(2, 1, 4, 3); 161 dense_storage_swap<T,12,4,Dynamic>(4, 3, 4, 3); 162 dense_storage_swap<T,12,4,Dynamic>(4, 3, 4, 1); 163 dense_storage_swap<T,12,4,Dynamic>(4, 1, 4, 3); 164 dense_storage_swap<T,12,Dynamic,3>(4, 3, 4, 3); 165 dense_storage_swap<T,12,Dynamic,3>(4, 3, 2, 3); 166 dense_storage_swap<T,12,Dynamic,3>(2, 3, 4, 3); 167 // Fixed Storage with Uninitialized Elements. 168 dense_storage_swap<T,18,Dynamic,Dynamic>(4, 3, 4, 3); 169 dense_storage_swap<T,18,Dynamic,Dynamic>(4, 3, 2, 1); 170 dense_storage_swap<T,18,Dynamic,Dynamic>(2, 1, 4, 3); 171 dense_storage_swap<T,18,4,Dynamic>(4, 3, 4, 3); 172 dense_storage_swap<T,18,4,Dynamic>(4, 3, 4, 1); 173 dense_storage_swap<T,18,4,Dynamic>(4, 1, 4, 3); 174 dense_storage_swap<T,18,Dynamic,3>(4, 3, 4, 3); 175 dense_storage_swap<T,18,Dynamic,3>(4, 3, 2, 3); 176 dense_storage_swap<T,18,Dynamic,3>(2, 3, 4, 3); 177 178 dense_storage_alignment<T,16,8>(); 179 dense_storage_alignment<T,16,16>(); 180 dense_storage_alignment<T,16,32>(); 181 dense_storage_alignment<T,16,64>(); 182 } 183 184 EIGEN_DECLARE_TEST(dense_storage) 185 { 186 dense_storage_tests<int>(); 187 dense_storage_tests<float>(); 188 dense_storage_tests<SafeScalar<float> >(); 189 dense_storage_tests<AnnoyingScalar>(); 190 }