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
BOOST_UBLAS_TEST_DEF(check)30 BOOST_UBLAS_TEST_DEF( check )
31 {
32 BOOST_UBLAS_TEST_TRACE( "Test case: 'check'" );
33
34 BOOST_UBLAS_TEST_CHECK( true );
35 }
36
BOOST_UBLAS_TEST_DEF(check_eq)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
BOOST_UBLAS_TEST_DEF(check_close)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
BOOST_UBLAS_TEST_DEF(check_rel_close)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
BOOST_UBLAS_TEST_DEF(check_vector_eq)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
BOOST_UBLAS_TEST_DEF(check_vector_close)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
BOOST_UBLAS_TEST_DEF(check_vector_rel_close)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
BOOST_UBLAS_TEST_DEF(check_matrix_eq)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
BOOST_UBLAS_TEST_DEF(check_matrix_close)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
BOOST_UBLAS_TEST_DEF(check_matrix_rel_close)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
main()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