1 // This file is part of Eigen, a lightweight C++ template library 2 // for linear algebra. 3 // 4 // Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1 (at) 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 #ifndef EIGEN_NO_STATIC_ASSERT 11 #define EIGEN_NO_STATIC_ASSERT // turn static asserts into runtime asserts in order to check them 12 #endif 13 14 #include "main.h" 15 16 template<typename VectorType> void map_class_vector(const VectorType& m) 17 { 18 typedef typename VectorType::Index Index; 19 typedef typename VectorType::Scalar Scalar; 20 21 Index size = m.size(); 22 23 // test Map.h 24 Scalar* array1 = internal::aligned_new<Scalar>(size); 25 Scalar* array2 = internal::aligned_new<Scalar>(size); 26 Scalar* array3 = new Scalar[size+1]; 27 Scalar* array3unaligned = size_t(array3)%16 == 0 ? array3+1 : array3; 28 29 Map<VectorType, Aligned>(array1, size) = VectorType::Random(size); 30 Map<VectorType, Aligned>(array2, size) = Map<VectorType,Aligned>(array1, size); 31 Map<VectorType>(array3unaligned, size) = Map<VectorType>(array1, size); 32 VectorType ma1 = Map<VectorType, Aligned>(array1, size); 33 VectorType ma2 = Map<VectorType, Aligned>(array2, size); 34 VectorType ma3 = Map<VectorType>(array3unaligned, size); 35 VERIFY_IS_EQUAL(ma1, ma2); 36 VERIFY_IS_EQUAL(ma1, ma3); 37 #ifdef EIGEN_VECTORIZE 38 if(internal::packet_traits<Scalar>::Vectorizable) 39 VERIFY_RAISES_ASSERT((Map<VectorType,Aligned>(array3unaligned, size))) 40 #endif 41 42 internal::aligned_delete(array1, size); 43 internal::aligned_delete(array2, size); 44 delete[] array3; 45 } 46 47 template<typename MatrixType> void map_class_matrix(const MatrixType& m) 48 { 49 typedef typename MatrixType::Index Index; 50 typedef typename MatrixType::Scalar Scalar; 51 52 Index rows = m.rows(), cols = m.cols(), size = rows*cols; 53 54 // test Map.h 55 Scalar* array1 = internal::aligned_new<Scalar>(size); 56 for(int i = 0; i < size; i++) array1[i] = Scalar(1); 57 Scalar* array2 = internal::aligned_new<Scalar>(size); 58 for(int i = 0; i < size; i++) array2[i] = Scalar(1); 59 Scalar* array3 = new Scalar[size+1]; 60 for(int i = 0; i < size+1; i++) array3[i] = Scalar(1); 61 Scalar* array3unaligned = size_t(array3)%16 == 0 ? array3+1 : array3; 62 Map<MatrixType, Aligned>(array1, rows, cols) = MatrixType::Ones(rows,cols); 63 Map<MatrixType>(array2, rows, cols) = Map<MatrixType>(array1, rows, cols); 64 Map<MatrixType>(array3unaligned, rows, cols) = Map<MatrixType>(array1, rows, cols); 65 MatrixType ma1 = Map<MatrixType>(array1, rows, cols); 66 MatrixType ma2 = Map<MatrixType, Aligned>(array2, rows, cols); 67 VERIFY_IS_EQUAL(ma1, ma2); 68 MatrixType ma3 = Map<MatrixType>(array3unaligned, rows, cols); 69 VERIFY_IS_EQUAL(ma1, ma3); 70 71 internal::aligned_delete(array1, size); 72 internal::aligned_delete(array2, size); 73 delete[] array3; 74 } 75 76 template<typename VectorType> void map_static_methods(const VectorType& m) 77 { 78 typedef typename VectorType::Index Index; 79 typedef typename VectorType::Scalar Scalar; 80 81 Index size = m.size(); 82 83 // test Map.h 84 Scalar* array1 = internal::aligned_new<Scalar>(size); 85 Scalar* array2 = internal::aligned_new<Scalar>(size); 86 Scalar* array3 = new Scalar[size+1]; 87 Scalar* array3unaligned = size_t(array3)%16 == 0 ? array3+1 : array3; 88 89 VectorType::MapAligned(array1, size) = VectorType::Random(size); 90 VectorType::Map(array2, size) = VectorType::Map(array1, size); 91 VectorType::Map(array3unaligned, size) = VectorType::Map(array1, size); 92 VectorType ma1 = VectorType::Map(array1, size); 93 VectorType ma2 = VectorType::MapAligned(array2, size); 94 VectorType ma3 = VectorType::Map(array3unaligned, size); 95 VERIFY_IS_EQUAL(ma1, ma2); 96 VERIFY_IS_EQUAL(ma1, ma3); 97 98 internal::aligned_delete(array1, size); 99 internal::aligned_delete(array2, size); 100 delete[] array3; 101 } 102 103 template<typename PlainObjectType> void check_const_correctness(const PlainObjectType&) 104 { 105 // there's a lot that we can't test here while still having this test compile! 106 // the only possible approach would be to run a script trying to compile stuff and checking that it fails. 107 // CMake can help with that. 108 109 // verify that map-to-const don't have LvalueBit 110 typedef typename internal::add_const<PlainObjectType>::type ConstPlainObjectType; 111 VERIFY( !(internal::traits<Map<ConstPlainObjectType> >::Flags & LvalueBit) ); 112 VERIFY( !(internal::traits<Map<ConstPlainObjectType, Aligned> >::Flags & LvalueBit) ); 113 VERIFY( !(Map<ConstPlainObjectType>::Flags & LvalueBit) ); 114 VERIFY( !(Map<ConstPlainObjectType, Aligned>::Flags & LvalueBit) ); 115 } 116 117 void test_mapped_matrix() 118 { 119 for(int i = 0; i < g_repeat; i++) { 120 CALL_SUBTEST_1( map_class_vector(Matrix<float, 1, 1>()) ); 121 CALL_SUBTEST_1( check_const_correctness(Matrix<float, 1, 1>()) ); 122 CALL_SUBTEST_2( map_class_vector(Vector4d()) ); 123 CALL_SUBTEST_2( check_const_correctness(Matrix4d()) ); 124 CALL_SUBTEST_3( map_class_vector(RowVector4f()) ); 125 CALL_SUBTEST_4( map_class_vector(VectorXcf(8)) ); 126 CALL_SUBTEST_5( map_class_vector(VectorXi(12)) ); 127 CALL_SUBTEST_5( check_const_correctness(VectorXi(12)) ); 128 129 CALL_SUBTEST_1( map_class_matrix(Matrix<float, 1, 1>()) ); 130 CALL_SUBTEST_2( map_class_matrix(Matrix4d()) ); 131 CALL_SUBTEST_11( map_class_matrix(Matrix<float,3,5>()) ); 132 CALL_SUBTEST_4( map_class_matrix(MatrixXcf(internal::random<int>(1,10),internal::random<int>(1,10))) ); 133 CALL_SUBTEST_5( map_class_matrix(MatrixXi(internal::random<int>(1,10),internal::random<int>(1,10))) ); 134 135 CALL_SUBTEST_6( map_static_methods(Matrix<double, 1, 1>()) ); 136 CALL_SUBTEST_7( map_static_methods(Vector3f()) ); 137 CALL_SUBTEST_8( map_static_methods(RowVector3d()) ); 138 CALL_SUBTEST_9( map_static_methods(VectorXcd(8)) ); 139 CALL_SUBTEST_10( map_static_methods(VectorXf(12)) ); 140 } 141 } 142
