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