• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2010 Benoit Jacob <jacob.benoit.1@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 #define EIGEN_NO_STATIC_ASSERT
11 
12 #include "main.h"
13 
14 #undef VERIFY_IS_APPROX
15 #define VERIFY_IS_APPROX(a, b) VERIFY((a)==(b));
16 #undef VERIFY_IS_NOT_APPROX
17 #define VERIFY_IS_NOT_APPROX(a, b) VERIFY((a)!=(b));
18 
signed_integer_type_tests(const MatrixType & m)19 template<typename MatrixType> void signed_integer_type_tests(const MatrixType& m)
20 {
21   typedef typename MatrixType::Index Index;
22   typedef typename MatrixType::Scalar Scalar;
23 
24   enum { is_signed = (Scalar(-1) > Scalar(0)) ? 0 : 1 };
25   VERIFY(is_signed == 1);
26 
27   Index rows = m.rows();
28   Index cols = m.cols();
29 
30   MatrixType m1(rows, cols),
31              m2 = MatrixType::Random(rows, cols),
32              mzero = MatrixType::Zero(rows, cols);
33 
34   do {
35     m1 = MatrixType::Random(rows, cols);
36   } while(m1 == mzero || m1 == m2);
37 
38   // check linear structure
39 
40   Scalar s1;
41   do {
42     s1 = internal::random<Scalar>();
43   } while(s1 == 0);
44 
45   VERIFY_IS_EQUAL(-(-m1),                  m1);
46   VERIFY_IS_EQUAL(-m2+m1+m2,               m1);
47   VERIFY_IS_EQUAL((-m1+m2)*s1,             -s1*m1+s1*m2);
48 }
49 
integer_type_tests(const MatrixType & m)50 template<typename MatrixType> void integer_type_tests(const MatrixType& m)
51 {
52   typedef typename MatrixType::Index Index;
53   typedef typename MatrixType::Scalar Scalar;
54 
55   VERIFY(NumTraits<Scalar>::IsInteger);
56   enum { is_signed = (Scalar(-1) > Scalar(0)) ? 0 : 1 };
57   VERIFY(int(NumTraits<Scalar>::IsSigned) == is_signed);
58 
59   typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
60 
61   Index rows = m.rows();
62   Index cols = m.cols();
63 
64   // this test relies a lot on Random.h, and there's not much more that we can do
65   // to test it, hence I consider that we will have tested Random.h
66   MatrixType m1(rows, cols),
67              m2 = MatrixType::Random(rows, cols),
68              m3(rows, cols),
69              mzero = MatrixType::Zero(rows, cols);
70 
71   typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime> SquareMatrixType;
72   SquareMatrixType identity = SquareMatrixType::Identity(rows, rows),
73                    square = SquareMatrixType::Random(rows, rows);
74   VectorType v1(rows),
75              v2 = VectorType::Random(rows),
76              vzero = VectorType::Zero(rows);
77 
78   do {
79     m1 = MatrixType::Random(rows, cols);
80   } while(m1 == mzero || m1 == m2);
81 
82   do {
83     v1 = VectorType::Random(rows);
84   } while(v1 == vzero || v1 == v2);
85 
86   VERIFY_IS_APPROX(               v1,    v1);
87   VERIFY_IS_NOT_APPROX(           v1,    2*v1);
88   VERIFY_IS_APPROX(               vzero, v1-v1);
89   VERIFY_IS_APPROX(               m1,    m1);
90   VERIFY_IS_NOT_APPROX(           m1,    2*m1);
91   VERIFY_IS_APPROX(               mzero, m1-m1);
92 
93   VERIFY_IS_APPROX(m3 = m1,m1);
94   MatrixType m4;
95   VERIFY_IS_APPROX(m4 = m1,m1);
96 
97   m3.real() = m1.real();
98   VERIFY_IS_APPROX(static_cast<const MatrixType&>(m3).real(), static_cast<const MatrixType&>(m1).real());
99   VERIFY_IS_APPROX(static_cast<const MatrixType&>(m3).real(), m1.real());
100 
101   // check == / != operators
102   VERIFY(m1==m1);
103   VERIFY(m1!=m2);
104   VERIFY(!(m1==m2));
105   VERIFY(!(m1!=m1));
106   m1 = m2;
107   VERIFY(m1==m2);
108   VERIFY(!(m1!=m2));
109 
110   // check linear structure
111 
112   Scalar s1;
113   do {
114     s1 = internal::random<Scalar>();
115   } while(s1 == 0);
116 
117   VERIFY_IS_EQUAL(m1+m1,                   2*m1);
118   VERIFY_IS_EQUAL(m1+m2-m1,                m2);
119   VERIFY_IS_EQUAL(m1*s1,                   s1*m1);
120   VERIFY_IS_EQUAL((m1+m2)*s1,              s1*m1+s1*m2);
121   m3 = m2; m3 += m1;
122   VERIFY_IS_EQUAL(m3,                      m1+m2);
123   m3 = m2; m3 -= m1;
124   VERIFY_IS_EQUAL(m3,                      m2-m1);
125   m3 = m2; m3 *= s1;
126   VERIFY_IS_EQUAL(m3,                      s1*m2);
127 
128   // check matrix product.
129 
130   VERIFY_IS_APPROX(identity * m1, m1);
131   VERIFY_IS_APPROX(square * (m1 + m2), square * m1 + square * m2);
132   VERIFY_IS_APPROX((m1 + m2).transpose() * square, m1.transpose() * square + m2.transpose() * square);
133   VERIFY_IS_APPROX((m1 * m2.transpose()) * m1, m1 * (m2.transpose() * m1));
134 }
135 
test_integer_types()136 void test_integer_types()
137 {
138   for(int i = 0; i < g_repeat; i++) {
139     CALL_SUBTEST_1( integer_type_tests(Matrix<unsigned int, 1, 1>()) );
140     CALL_SUBTEST_1( integer_type_tests(Matrix<unsigned long, 3, 4>()) );
141 
142     CALL_SUBTEST_2( integer_type_tests(Matrix<long, 2, 2>()) );
143     CALL_SUBTEST_2( signed_integer_type_tests(Matrix<long, 2, 2>()) );
144 
145     CALL_SUBTEST_3( integer_type_tests(Matrix<char, 2, Dynamic>(2, 10)) );
146     CALL_SUBTEST_3( signed_integer_type_tests(Matrix<signed char, 2, Dynamic>(2, 10)) );
147 
148     CALL_SUBTEST_4( integer_type_tests(Matrix<unsigned char, 3, 3>()) );
149     CALL_SUBTEST_4( integer_type_tests(Matrix<unsigned char, Dynamic, Dynamic>(20, 20)) );
150 
151     CALL_SUBTEST_5( integer_type_tests(Matrix<short, Dynamic, 4>(7, 4)) );
152     CALL_SUBTEST_5( signed_integer_type_tests(Matrix<short, Dynamic, 4>(7, 4)) );
153 
154     CALL_SUBTEST_6( integer_type_tests(Matrix<unsigned short, 4, 4>()) );
155 
156     CALL_SUBTEST_7( integer_type_tests(Matrix<long long, 11, 13>()) );
157     CALL_SUBTEST_7( signed_integer_type_tests(Matrix<long long, 11, 13>()) );
158 
159     CALL_SUBTEST_8( integer_type_tests(Matrix<unsigned long long, Dynamic, 5>(1, 5)) );
160   }
161 #ifdef EIGEN_TEST_PART_9
162   VERIFY_IS_EQUAL(internal::scalar_div_cost<int>::value, 8);
163   VERIFY_IS_EQUAL(internal::scalar_div_cost<unsigned int>::value, 8);
164   if(sizeof(long)>sizeof(int)) {
165     VERIFY(internal::scalar_div_cost<long>::value > internal::scalar_div_cost<int>::value);
166     VERIFY(internal::scalar_div_cost<unsigned long>::value > internal::scalar_div_cost<int>::value);
167   }
168 #endif
169 }
170