1 | /** |
2 | * \file libs/numeric/ublas/test/test_utils.hpp |
3 | * |
4 | * \brief Test suite for utils.hpp. |
5 | * |
6 | * Copyright (c) 2012, Marco Guazzone |
7 | * |
8 | * Distributed under the Boost Software License, Version 1.0. (See |
9 | * accompanying file LICENSE_1_0.txt or copy at |
10 | * http://www.boost.org/LICENSE_1_0.txt) |
11 | * |
12 | * \author Marco Guazzone (marco.guazzone@gmail.com) |
13 | */ |
14 | |
15 | #include <boost/numeric/ublas/io.hpp> |
16 | #include <boost/numeric/ublas/matrix.hpp> |
17 | #include <boost/numeric/ublas/vector.hpp> |
18 | #include <complex> |
19 | #include <cstddef> |
20 | #include "utils.hpp" |
21 | |
22 | |
23 | namespace ublas = boost::numeric::ublas; |
24 | |
25 | |
26 | static const float tol(1e-6f); |
27 | static const float mul(tol*10); |
28 | |
29 | |
30 | BOOST_UBLAS_TEST_DEF( check ) |
31 | { |
32 | BOOST_UBLAS_TEST_TRACE( "Test case: 'check'" ); |
33 | |
34 | BOOST_UBLAS_TEST_CHECK( true ); |
35 | } |
36 | |
37 | BOOST_UBLAS_TEST_DEF( check_eq ) |
38 | { |
39 | BOOST_UBLAS_TEST_TRACE( "Test case: 'check_eq'" ); |
40 | |
41 | BOOST_UBLAS_DEBUG_TRACE( "-- Test against same types." ); |
42 | BOOST_UBLAS_TEST_CHECK_EQ( short(1), short(1) ); |
43 | BOOST_UBLAS_TEST_CHECK_EQ( int(1), int(1) ); |
44 | BOOST_UBLAS_TEST_CHECK_EQ( long(1), long(1) ); |
45 | BOOST_UBLAS_TEST_CHECK_EQ( unsigned(1), unsigned(1) ); |
46 | |
47 | BOOST_UBLAS_DEBUG_TRACE( "-- Test against different types." ); |
48 | BOOST_UBLAS_TEST_CHECK_EQ( short(1), int(1) ); |
49 | BOOST_UBLAS_TEST_CHECK_EQ( short(1), int(1) ); |
50 | BOOST_UBLAS_TEST_CHECK_EQ( int(1), long(1) ); |
51 | BOOST_UBLAS_TEST_CHECK_EQ( long(1), int(1) ); |
52 | |
53 | BOOST_UBLAS_DEBUG_TRACE( "-- Test aliases." ); |
54 | BOOST_UBLAS_TEST_CHECK_EQUAL( int(1), int(1) ); |
55 | } |
56 | |
57 | BOOST_UBLAS_TEST_DEF( check_close ) |
58 | { |
59 | BOOST_UBLAS_TEST_TRACE( "Test case: 'check_close'" ); |
60 | |
61 | const float c1(1*mul); |
62 | const float c2(2*mul); |
63 | |
64 | // Check T vs. T |
65 | BOOST_UBLAS_DEBUG_TRACE( "-- Test against same types." ); |
66 | BOOST_UBLAS_TEST_CHECK_CLOSE( float(c1), float(c1), tol ); |
67 | BOOST_UBLAS_TEST_CHECK_CLOSE( double(c1), double(c1), tol ); |
68 | BOOST_UBLAS_TEST_CHECK_CLOSE( std::complex<float>(c1,c2), std::complex<float>(c1,c2), tol ); |
69 | BOOST_UBLAS_TEST_CHECK_CLOSE( std::complex<double>(c1,c2), std::complex<double>(c1,c2), tol ); |
70 | |
71 | // Check T1 vs. T2 |
72 | BOOST_UBLAS_DEBUG_TRACE( "-- Test against different types." ); |
73 | BOOST_UBLAS_TEST_CHECK_CLOSE( float(c1), double(c1), tol ); |
74 | BOOST_UBLAS_TEST_CHECK_CLOSE( double(c1), float(c1), tol ); |
75 | BOOST_UBLAS_TEST_CHECK_CLOSE( std::complex<float>(c1,c2), std::complex<double>(c1,c2), tol ); |
76 | BOOST_UBLAS_TEST_CHECK_CLOSE( std::complex<double>(c1,c2), std::complex<float>(c1,c2), tol ); |
77 | |
78 | // Check alias |
79 | BOOST_UBLAS_DEBUG_TRACE( "-- Test aliases." ); |
80 | BOOST_UBLAS_TEST_CHECK_PRECISION( float(c1), float(c1), tol ); |
81 | } |
82 | |
83 | BOOST_UBLAS_TEST_DEF( check_rel_close ) |
84 | { |
85 | BOOST_UBLAS_TEST_TRACE( "Test case: 'check_rel_close'" ); |
86 | |
87 | const float c1(1*mul); |
88 | const float c2(2*mul); |
89 | |
90 | // Check T vs. T |
91 | BOOST_UBLAS_DEBUG_TRACE( "-- Test against same types." ); |
92 | BOOST_UBLAS_TEST_CHECK_REL_CLOSE( float(c1), float(c1), tol ); |
93 | BOOST_UBLAS_TEST_CHECK_REL_CLOSE( double(c1), double(c1), tol ); |
94 | BOOST_UBLAS_TEST_CHECK_REL_CLOSE( std::complex<float>(c1,c2), std::complex<float>(c1,c2), tol ); |
95 | BOOST_UBLAS_TEST_CHECK_REL_CLOSE( std::complex<double>(c1,c2), std::complex<double>(c1,c2), tol ); |
96 | |
97 | // Check T1 vs. T2 |
98 | BOOST_UBLAS_DEBUG_TRACE( "-- Test against different types." ); |
99 | BOOST_UBLAS_TEST_CHECK_REL_CLOSE( float(c1), double(c1), tol ); |
100 | BOOST_UBLAS_TEST_CHECK_REL_CLOSE( double(c1), float(c1), tol ); |
101 | BOOST_UBLAS_TEST_CHECK_REL_CLOSE( std::complex<float>(c1,c2), std::complex<double>(c1,c2), tol ); |
102 | BOOST_UBLAS_TEST_CHECK_REL_CLOSE( std::complex<double>(c1,c2), std::complex<float>(c1,c2), tol ); |
103 | |
104 | // Check alias |
105 | BOOST_UBLAS_DEBUG_TRACE( "-- Test aliases." ); |
106 | BOOST_UBLAS_TEST_CHECK_REL_PRECISION( float(c1), float(c1), tol ); |
107 | } |
108 | |
109 | BOOST_UBLAS_TEST_DEF( check_vector_eq ) |
110 | { |
111 | BOOST_UBLAS_TEST_TRACE( "Test case: 'check_vector_eq'" ); |
112 | |
113 | const std::size_t n(5); |
114 | |
115 | ublas::vector<short> sv = ublas::scalar_vector<short>(n, 1); |
116 | ublas::vector<int> iv = ublas::scalar_vector<int>(n, 1); |
117 | ublas::vector<long> lv = ublas::scalar_vector<long>(n, 1L); |
118 | ublas::vector<unsigned> uv = ublas::scalar_vector<unsigned>(n, 1u); |
119 | |
120 | // Check T vs. T |
121 | BOOST_UBLAS_DEBUG_TRACE( "-- Test against same types." ); |
122 | BOOST_UBLAS_TEST_CHECK_VECTOR_EQ( sv, sv, n ); |
123 | BOOST_UBLAS_TEST_CHECK_VECTOR_EQ( iv, iv, n ); |
124 | BOOST_UBLAS_TEST_CHECK_VECTOR_EQ( lv, lv, n ); |
125 | BOOST_UBLAS_TEST_CHECK_VECTOR_EQ( uv, uv, n ); |
126 | |
127 | // Check T1 vs. T2 |
128 | BOOST_UBLAS_DEBUG_TRACE( "-- Test against different types." ); |
129 | BOOST_UBLAS_TEST_CHECK_VECTOR_EQ( sv, iv, n ); |
130 | BOOST_UBLAS_TEST_CHECK_VECTOR_EQ( iv, sv, n ); |
131 | BOOST_UBLAS_TEST_CHECK_VECTOR_EQ( iv, lv, n ); |
132 | BOOST_UBLAS_TEST_CHECK_VECTOR_EQ( lv, iv, n ); |
133 | } |
134 | |
135 | BOOST_UBLAS_TEST_DEF( check_vector_close ) |
136 | { |
137 | BOOST_UBLAS_TEST_TRACE( "Test case: 'check_vector_close'" ); |
138 | |
139 | const std::size_t n(5); |
140 | |
141 | ublas::vector<float> fv = ublas::scalar_vector<float>(n, 1); |
142 | ublas::vector<float> dv = ublas::scalar_vector<float>(n, 1); |
143 | ublas::vector< std::complex<float> > cfv = ublas::scalar_vector< std::complex<float> >(n, std::complex<float>(1,2)); |
144 | ublas::vector< std::complex<double> > cdv = ublas::scalar_vector< std::complex<double> >(n, std::complex<double>(1,2)); |
145 | |
146 | // Check T vs. T |
147 | BOOST_UBLAS_DEBUG_TRACE( "-- Test against same types." ); |
148 | BOOST_UBLAS_TEST_CHECK_VECTOR_CLOSE( fv, fv, n, tol ); |
149 | BOOST_UBLAS_TEST_CHECK_VECTOR_CLOSE( dv, dv, n, tol ); |
150 | BOOST_UBLAS_TEST_CHECK_VECTOR_CLOSE( cfv, cfv, n, tol ); |
151 | BOOST_UBLAS_TEST_CHECK_VECTOR_CLOSE( cdv, cdv, n, tol ); |
152 | |
153 | // Check T1 vs. T2 |
154 | BOOST_UBLAS_DEBUG_TRACE( "-- Test against different types." ); |
155 | BOOST_UBLAS_TEST_CHECK_VECTOR_CLOSE( fv, dv, n, tol ); |
156 | BOOST_UBLAS_TEST_CHECK_VECTOR_CLOSE( dv, fv, n, tol ); |
157 | BOOST_UBLAS_TEST_CHECK_VECTOR_CLOSE( cfv, cdv, n, tol ); |
158 | BOOST_UBLAS_TEST_CHECK_VECTOR_CLOSE( cdv, cfv, n, tol ); |
159 | } |
160 | |
161 | BOOST_UBLAS_TEST_DEF( check_vector_rel_close ) |
162 | { |
163 | BOOST_UBLAS_TEST_TRACE( "Test case: 'check_vector_rel_close'" ); |
164 | |
165 | const std::size_t n(5); |
166 | const float c1(1*mul); |
167 | const float c2(2*mul); |
168 | |
169 | ublas::vector<float> fv = ublas::scalar_vector<float>(n, c1); |
170 | ublas::vector<double> dv = ublas::scalar_vector<double>(n, c1); |
171 | ublas::vector< std::complex<float> > cfv = ublas::scalar_vector< std::complex<float> >(n, std::complex<float>(c1,c2)); |
172 | ublas::vector< std::complex<double> > cdv = ublas::scalar_vector< std::complex<double> >(n, std::complex<double>(c1,c2)); |
173 | |
174 | // Check T vs. T |
175 | BOOST_UBLAS_DEBUG_TRACE( "-- Test against same types." ); |
176 | BOOST_UBLAS_TEST_CHECK_VECTOR_REL_CLOSE( fv, fv, n, tol ); |
177 | BOOST_UBLAS_TEST_CHECK_VECTOR_REL_CLOSE( dv, dv, n, tol ); |
178 | BOOST_UBLAS_TEST_CHECK_VECTOR_REL_CLOSE( cfv, cfv, n, tol ); |
179 | BOOST_UBLAS_TEST_CHECK_VECTOR_REL_CLOSE( cdv, cdv, n, tol ); |
180 | |
181 | // Check T1 vs. T2 |
182 | BOOST_UBLAS_DEBUG_TRACE( "-- Test against different types." ); |
183 | BOOST_UBLAS_TEST_CHECK_VECTOR_REL_CLOSE( fv, dv, n, tol ); |
184 | BOOST_UBLAS_TEST_CHECK_VECTOR_REL_CLOSE( dv, fv, n, tol ); |
185 | BOOST_UBLAS_TEST_CHECK_VECTOR_REL_CLOSE( cfv, cdv, n, tol ); |
186 | BOOST_UBLAS_TEST_CHECK_VECTOR_REL_CLOSE( cdv, cfv, n, tol ); |
187 | } |
188 | |
189 | BOOST_UBLAS_TEST_DEF( check_matrix_eq ) |
190 | { |
191 | BOOST_UBLAS_TEST_TRACE( "Test case: 'check_matrix_eq'" ); |
192 | |
193 | const std::size_t nr(3); |
194 | const std::size_t nc(4); |
195 | |
196 | ublas::matrix<short> sv = ublas::scalar_matrix<short>(nr, nc, 1); |
197 | ublas::matrix<int> iv = ublas::scalar_matrix<int>(nr, nc, 1); |
198 | ublas::matrix<long> lv = ublas::scalar_matrix<long>(nr, nc, 1L); |
199 | ublas::matrix<unsigned> uv = ublas::scalar_matrix<unsigned>(nr, nc, 1u); |
200 | |
201 | // Check T vs. T |
202 | BOOST_UBLAS_DEBUG_TRACE( "-- Test against same types." ); |
203 | BOOST_UBLAS_TEST_CHECK_MATRIX_EQ( sv, sv, nr, nc ); |
204 | BOOST_UBLAS_TEST_CHECK_MATRIX_EQ( iv, iv, nr, nc ); |
205 | BOOST_UBLAS_TEST_CHECK_MATRIX_EQ( lv, lv, nr, nc ); |
206 | BOOST_UBLAS_TEST_CHECK_MATRIX_EQ( uv, uv, nr, nc ); |
207 | |
208 | // Check T1 vs. T2 |
209 | BOOST_UBLAS_DEBUG_TRACE( "-- Test against different types." ); |
210 | BOOST_UBLAS_TEST_CHECK_MATRIX_EQ( sv, iv, nr, nc ); |
211 | BOOST_UBLAS_TEST_CHECK_MATRIX_EQ( iv, sv, nr, nc ); |
212 | BOOST_UBLAS_TEST_CHECK_MATRIX_EQ( iv, lv, nr, nc ); |
213 | BOOST_UBLAS_TEST_CHECK_MATRIX_EQ( lv, iv, nr, nc ); |
214 | } |
215 | |
216 | BOOST_UBLAS_TEST_DEF( check_matrix_close ) |
217 | { |
218 | BOOST_UBLAS_TEST_TRACE( "Test case: 'check_matrix_close'" ); |
219 | |
220 | const std::size_t nr(3); |
221 | const std::size_t nc(4); |
222 | const float c1(1*mul); |
223 | const float c2(2*mul); |
224 | |
225 | ublas::matrix<float> fA = ublas::scalar_matrix<float>(nr, nc, c1); |
226 | ublas::matrix<double> dA = ublas::scalar_matrix<double>(nr, nc, c1); |
227 | ublas::matrix< std::complex<float> > cfA = ublas::scalar_matrix< std::complex<float> >(nr, nc, std::complex<float>(c1,c2)); |
228 | ublas::matrix< std::complex<double> > cdA = ublas::scalar_matrix< std::complex<double> >(nr, nc, std::complex<double>(c1,c2)); |
229 | |
230 | // Check T vs. T |
231 | BOOST_UBLAS_DEBUG_TRACE( "-- Test against same types." ); |
232 | BOOST_UBLAS_TEST_CHECK_MATRIX_CLOSE( fA, fA, nr, nc, tol ); |
233 | BOOST_UBLAS_TEST_CHECK_MATRIX_CLOSE( dA, dA, nr, nc, tol ); |
234 | BOOST_UBLAS_TEST_CHECK_MATRIX_CLOSE( cfA, cfA, nr, nc, tol ); |
235 | BOOST_UBLAS_TEST_CHECK_MATRIX_CLOSE( cdA, cdA, nr, nc, tol ); |
236 | |
237 | // Check T1 vs. T2 |
238 | BOOST_UBLAS_DEBUG_TRACE( "-- Test against different types." ); |
239 | BOOST_UBLAS_TEST_CHECK_MATRIX_CLOSE( fA, dA, nr, nc, tol ); |
240 | BOOST_UBLAS_TEST_CHECK_MATRIX_CLOSE( dA, fA, nr, nc, tol ); |
241 | BOOST_UBLAS_TEST_CHECK_MATRIX_CLOSE( cfA, cdA, nr, nc, tol ); |
242 | BOOST_UBLAS_TEST_CHECK_MATRIX_CLOSE( cdA, cfA, nr, nc, tol ); |
243 | } |
244 | |
245 | |
246 | BOOST_UBLAS_TEST_DEF( check_matrix_rel_close ) |
247 | { |
248 | BOOST_UBLAS_TEST_TRACE( "Test case: 'check_matrix_rel_close'" ); |
249 | |
250 | const std::size_t nr(3); |
251 | const std::size_t nc(4); |
252 | const float c1(1*mul); |
253 | const float c2(2*mul); |
254 | |
255 | ublas::matrix<float> fA = ublas::scalar_matrix<float>(nr, nc, c1); |
256 | ublas::matrix<double> dA = ublas::scalar_matrix<double>(nr, nc, c1); |
257 | ublas::matrix< std::complex<float> > cfA = ublas::scalar_matrix< std::complex<float> >(nr, nc, std::complex<float>(c1,c2)); |
258 | ublas::matrix< std::complex<double> > cdA = ublas::scalar_matrix< std::complex<double> >(nr, nc, std::complex<double>(c1,c2)); |
259 | |
260 | // Check T vs. T |
261 | BOOST_UBLAS_DEBUG_TRACE( "-- Test against same types." ); |
262 | BOOST_UBLAS_TEST_CHECK_MATRIX_REL_CLOSE( fA, fA, nr, nc, tol ); |
263 | BOOST_UBLAS_TEST_CHECK_MATRIX_REL_CLOSE( dA, dA, nr, nc, tol ); |
264 | BOOST_UBLAS_TEST_CHECK_MATRIX_REL_CLOSE( cfA, cfA, nr, nc, tol ); |
265 | BOOST_UBLAS_TEST_CHECK_MATRIX_REL_CLOSE( cdA, cdA, nr, nc, tol ); |
266 | |
267 | // Check T1 vs. T2 |
268 | BOOST_UBLAS_DEBUG_TRACE( "-- Test against different types." ); |
269 | BOOST_UBLAS_TEST_CHECK_MATRIX_REL_CLOSE( fA, dA, nr, nc, tol ); |
270 | BOOST_UBLAS_TEST_CHECK_MATRIX_REL_CLOSE( dA, fA, nr, nc, tol ); |
271 | BOOST_UBLAS_TEST_CHECK_MATRIX_REL_CLOSE( cfA, cdA, nr, nc, tol ); |
272 | BOOST_UBLAS_TEST_CHECK_MATRIX_REL_CLOSE( cdA, cfA, nr, nc, tol ); |
273 | } |
274 | |
275 | |
276 | int main() |
277 | { |
278 | BOOST_UBLAS_TEST_SUITE( "Test 'utils.hpp' functionalities" ); |
279 | |
280 | BOOST_UBLAS_TEST_BEGIN(); |
281 | BOOST_UBLAS_TEST_DO( check ); |
282 | BOOST_UBLAS_TEST_DO( check_eq ); |
283 | BOOST_UBLAS_TEST_DO( check_close ); |
284 | BOOST_UBLAS_TEST_DO( check_rel_close ); |
285 | BOOST_UBLAS_TEST_DO( check_vector_eq ); |
286 | BOOST_UBLAS_TEST_DO( check_vector_close ); |
287 | BOOST_UBLAS_TEST_DO( check_vector_rel_close ); |
288 | BOOST_UBLAS_TEST_DO( check_matrix_eq ); |
289 | BOOST_UBLAS_TEST_DO( check_matrix_close ); |
290 | BOOST_UBLAS_TEST_DO( check_matrix_rel_close ); |
291 | BOOST_UBLAS_TEST_END(); |
292 | } |
293 | |