Home | History | Annotate | Download | only in test
      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   typedef typename PlainObjectType::Index Index;
    106   typedef typename PlainObjectType::Scalar Scalar;
    107 
    108   // there's a lot that we can't test here while still having this test compile!
    109   // the only possible approach would be to run a script trying to compile stuff and checking that it fails.
    110   // CMake can help with that.
    111 
    112   // verify that map-to-const don't have LvalueBit
    113   typedef typename internal::add_const<PlainObjectType>::type ConstPlainObjectType;
    114   VERIFY( !(internal::traits<Map<ConstPlainObjectType> >::Flags & LvalueBit) );
    115   VERIFY( !(internal::traits<Map<ConstPlainObjectType, Aligned> >::Flags & LvalueBit) );
    116   VERIFY( !(Map<ConstPlainObjectType>::Flags & LvalueBit) );
    117   VERIFY( !(Map<ConstPlainObjectType, Aligned>::Flags & LvalueBit) );
    118 }
    119 
    120 void test_map()
    121 {
    122   for(int i = 0; i < g_repeat; i++) {
    123     CALL_SUBTEST_1( map_class_vector(Matrix<float, 1, 1>()) );
    124     CALL_SUBTEST_1( check_const_correctness(Matrix<float, 1, 1>()) );
    125     CALL_SUBTEST_2( map_class_vector(Vector4d()) );
    126     CALL_SUBTEST_2( check_const_correctness(Matrix4d()) );
    127     CALL_SUBTEST_3( map_class_vector(RowVector4f()) );
    128     CALL_SUBTEST_4( map_class_vector(VectorXcf(8)) );
    129     CALL_SUBTEST_5( map_class_vector(VectorXi(12)) );
    130     CALL_SUBTEST_5( check_const_correctness(VectorXi(12)) );
    131 
    132     CALL_SUBTEST_1( map_class_matrix(Matrix<float, 1, 1>()) );
    133     CALL_SUBTEST_2( map_class_matrix(Matrix4d()) );
    134     CALL_SUBTEST_11( map_class_matrix(Matrix<float,3,5>()) );
    135     CALL_SUBTEST_4( map_class_matrix(MatrixXcf(internal::random<int>(1,10),internal::random<int>(1,10))) );
    136     CALL_SUBTEST_5( map_class_matrix(MatrixXi(internal::random<int>(1,10),internal::random<int>(1,10))) );
    137 
    138     CALL_SUBTEST_6( map_static_methods(Matrix<double, 1, 1>()) );
    139     CALL_SUBTEST_7( map_static_methods(Vector3f()) );
    140     CALL_SUBTEST_8( map_static_methods(RowVector3d()) );
    141     CALL_SUBTEST_9( map_static_methods(VectorXcd(8)) );
    142     CALL_SUBTEST_10( map_static_methods(VectorXf(12)) );
    143   }
    144 }
    145