]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | #undef BOOST_UBLAS_NO_EXCEPTIONS |
2 | #include "common/testhelper.hpp" | |
3 | #include <boost/numeric/ublas/vector.hpp> | |
4 | #include <boost/numeric/ublas/matrix.hpp> | |
5 | #include <boost/numeric/ublas/assignment.hpp> | |
6 | #include <boost/numeric/ublas/io.hpp> | |
7 | #include <string> | |
7c673cae FG |
8 | #include <complex> |
9 | #include <iomanip> | |
10 | #include "utils.hpp" | |
11 | ||
12 | #ifdef BOOST_UBLAS_CPP_GE_2011 | |
13 | ||
14 | using namespace boost::numeric::ublas; | |
15 | ||
16 | using std::cout; | |
17 | using std::endl; | |
18 | ||
92f5a8d4 TL |
19 | |
20 | template <typename T> | |
21 | struct data_type { | |
22 | typedef T value_type; | |
23 | }; | |
24 | ||
25 | template <typename T> | |
26 | struct data_type< std::complex<T> > { | |
27 | typedef typename std::complex<T>::value_type value_type; | |
28 | }; | |
29 | ||
30 | ||
7c673cae FG |
31 | template < class T > |
32 | bool test_vector( std::string type_name) | |
33 | { | |
92f5a8d4 TL |
34 | typedef typename data_type<T>::value_type component_type; |
35 | ||
36 | BOOST_UBLAS_DEBUG_TRACE( std::string("Testing for: ") + type_name ); | |
7c673cae FG |
37 | |
38 | bool pass = true; | |
39 | ||
40 | { | |
41 | typedef fixed_vector<T, 1> vec1; | |
42 | ||
92f5a8d4 | 43 | vec1 v1( static_cast<component_type>(122.0) ); |
7c673cae | 44 | |
92f5a8d4 | 45 | pass &= ( v1(0) == static_cast<component_type>(122.0) ); |
7c673cae FG |
46 | |
47 | } | |
48 | ||
49 | { | |
50 | typedef fixed_vector<T, 3> vec3; | |
51 | ||
92f5a8d4 TL |
52 | vec3 v1(static_cast<component_type>(0.0), |
53 | static_cast<component_type>(0.0), | |
54 | static_cast<component_type>(0.0)); | |
7c673cae | 55 | |
92f5a8d4 | 56 | pass &=(sizeof( vec3 ) == v1.size() * sizeof( T ) ) ; |
7c673cae FG |
57 | |
58 | vector<T> v( 3, 0 ) ; | |
59 | ||
60 | pass &= compare( v1, v ); | |
61 | ||
92f5a8d4 TL |
62 | v1 <<= static_cast<component_type>(10.0), 10, 33; |
63 | v <<= static_cast<component_type>(10.0), 10, 33; | |
7c673cae FG |
64 | |
65 | pass &= compare( v1, v ); | |
66 | ||
67 | ||
68 | vec3 v2; | |
69 | ||
92f5a8d4 TL |
70 | v2( 0 ) = static_cast<component_type>(10.0); |
71 | v2( 1 ) = 10; | |
72 | v2( 2 ) = 33; | |
7c673cae FG |
73 | pass &= compare( v, v2 ); |
74 | ||
75 | v2 += v; | |
76 | ||
77 | pass &= compare( v2, 2*v ); | |
78 | ||
79 | ||
80 | v1 = 2*v1 + v - 6*v2; | |
81 | pass &= compare( v1, (3-2*6)*v ); | |
82 | ||
83 | ||
92f5a8d4 TL |
84 | vec3 v3{ static_cast<component_type>(-90.0), |
85 | static_cast<component_type>(-90.0), | |
86 | static_cast<component_type>(-297.0) }; | |
7c673cae FG |
87 | pass &= compare( v3, v1 ); |
88 | ||
92f5a8d4 TL |
89 | vec3 v4 = { static_cast<component_type>(-90.0), |
90 | static_cast<component_type>(-90.0), | |
91 | static_cast<component_type>(-297.0) }; | |
7c673cae FG |
92 | pass &= compare( v4, v1 ); |
93 | ||
92f5a8d4 TL |
94 | vec3 v5( static_cast<component_type>(-90.0), |
95 | static_cast<component_type>(-90.0), | |
96 | static_cast<component_type>(-297.0) ); | |
7c673cae FG |
97 | pass &= compare( v5, v1 ); |
98 | ||
92f5a8d4 TL |
99 | vec3 v6( static_cast<component_type>(5.0), |
100 | static_cast<component_type>(8.0), | |
101 | static_cast<component_type>(9.0) ); | |
7c673cae FG |
102 | |
103 | matrix<T> M = outer_prod( v6, v6), L( 3, 3); | |
104 | ||
105 | L <<= 25, 40, 45, 40, 64, 72, 45, 72, 81; | |
106 | ||
107 | pass &= compare( M, L ); | |
108 | ||
109 | L <<= 1, 2, 3, 4, 5, 6, 7, 8, 9; | |
110 | v6 <<= 4, 5, 6; | |
92f5a8d4 TL |
111 | vec3 v7 ( static_cast<component_type>(32.0), |
112 | static_cast<component_type>(77.0), | |
113 | static_cast<component_type>(122.0) ); | |
7c673cae FG |
114 | |
115 | pass &= compare( v7, prod(L, v6) ); | |
116 | ||
92f5a8d4 | 117 | vec3 v8(prod(L, v6)); |
7c673cae FG |
118 | |
119 | pass &= compare( v7, v8 ); | |
7c673cae FG |
120 | } |
121 | ||
122 | ||
123 | { | |
124 | const std::size_t N = 33; | |
125 | typedef fixed_vector<T, N> vec33; | |
126 | ||
127 | vec33 v1; | |
128 | vector<T> v( N ); | |
129 | ||
92f5a8d4 | 130 | for ( std::size_t i = 0; i != v1.size(); i++) |
7c673cae | 131 | { |
92f5a8d4 TL |
132 | v1( i ) = static_cast<component_type>(3.14159*i); |
133 | v ( i ) = static_cast<component_type>(3.14159*i); | |
7c673cae FG |
134 | } |
135 | ||
136 | pass &= compare( v1, v ); | |
137 | ||
138 | ||
139 | auto ip = inner_prod( v, v); | |
140 | auto ip1 = inner_prod( v1, v1); | |
141 | ||
92f5a8d4 | 142 | pass &= ( ip == ip1 ) ; |
7c673cae FG |
143 | |
144 | T c = 0; | |
145 | for (auto i = v1.begin(); i != v1.end(); i++) | |
146 | { | |
147 | *i = c; | |
148 | c = c + 1; | |
149 | } | |
150 | ||
151 | c = 0; | |
152 | for (auto i = v.begin(); i != v.end(); i++) | |
153 | { | |
154 | *i = c; | |
155 | c = c + 1; | |
156 | } | |
157 | ||
158 | pass &= compare( v1, v ); | |
159 | ||
160 | // Check if bad index indeed works | |
161 | try { | |
162 | T a; | |
163 | a=v1( 100 ); | |
164 | BOOST_UBLAS_NOT_USED( a ); | |
165 | ||
166 | } catch ( bad_index &e) { | |
167 | std::cout << " Caught (GOOD): " << e.what() << endl; | |
168 | pass &= true; | |
169 | } | |
170 | ||
171 | ||
172 | } | |
173 | return pass; | |
174 | } | |
175 | ||
176 | template < class T > | |
177 | bool test_matrix( std::string type_name) | |
178 | { | |
92f5a8d4 TL |
179 | typedef typename data_type<T>::value_type component_type; |
180 | ||
181 | BOOST_UBLAS_DEBUG_TRACE( std::string("Testing for: ") + type_name ); | |
7c673cae FG |
182 | |
183 | bool pass = true; | |
184 | ||
185 | typedef fixed_matrix<T, 3, 4> mat34; | |
186 | typedef fixed_matrix<T, 4, 3> mat43; | |
187 | typedef fixed_matrix<T, 3, 3> mat33; | |
188 | ||
189 | ||
190 | { | |
191 | typedef fixed_matrix<T, 1, 1> mat1; | |
192 | ||
92f5a8d4 | 193 | mat1 m1( static_cast<component_type>(122.0) ); |
7c673cae | 194 | |
92f5a8d4 | 195 | pass &= ( m1(0, 0) == static_cast<component_type>(122.0) ); |
7c673cae FG |
196 | } |
197 | ||
198 | ||
199 | { | |
92f5a8d4 | 200 | mat34 m1( T(static_cast<component_type>(3.0)) ); |
7c673cae | 201 | |
92f5a8d4 | 202 | pass &=(sizeof( mat34 ) == m1.size1()*m1.size2()*sizeof( T ) ) ; |
7c673cae | 203 | |
92f5a8d4 | 204 | matrix<T> m( 3, 4, static_cast<component_type>(3.0) ) ; |
7c673cae FG |
205 | |
206 | pass &= compare( m1, m ); | |
207 | ||
208 | cout << m1 << endl; | |
209 | cout << m << endl; | |
210 | ||
211 | ||
212 | m1 <<= 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12; | |
213 | m <<= 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12; | |
214 | ||
215 | pass &= compare( m1, m ); | |
216 | ||
217 | cout << m1 << endl; | |
218 | cout << m << endl; | |
219 | ||
92f5a8d4 | 220 | mat34 m2( static_cast<component_type>(0.0) ); |
7c673cae FG |
221 | |
222 | T count = 1 ; | |
223 | for ( std::size_t i = 0; i != m2.size1(); i++) | |
224 | { | |
225 | for (std::size_t j = 0; j!= m2.size2(); j++) | |
226 | { | |
227 | m2( i, j ) = count; | |
228 | count = count + 1; | |
229 | } | |
230 | ||
231 | } | |
232 | pass &= compare( m2, m ); | |
233 | cout << m2 << endl; | |
234 | ||
235 | } | |
236 | { | |
92f5a8d4 TL |
237 | mat34 m1((T)1, (T)2, (T)3, (T)3, (T)3, (T)2, (T)5, (T)4, (T)2, (T)6, (T)5, (T)2); |
238 | mat43 m2((T)4, (T)5, (T)6, (T)3, (T)2, (T)2, (T)1, (T)4, (T)2, (T)6, (T)5, (T)2); | |
7c673cae | 239 | |
92f5a8d4 | 240 | mat33 m3(prod(m1, m2)); |
7c673cae FG |
241 | |
242 | matrix<T> m(3, 3); | |
243 | m <<= 31,36,22,47,59,40,43,52,38; | |
244 | ||
245 | pass &= compare(m ,m3); | |
246 | ||
247 | mat33 m4; | |
248 | m4 <<= (T)1, (T)2, (T)1, (T)2, (T)1, (T)3, (T)1, (T)2, (T) 5; | |
92f5a8d4 | 249 | m3 = prod(m4, trans(m4)); |
7c673cae FG |
250 | |
251 | m<<=6,7,10,7,14,19,10,19,30; | |
252 | ||
253 | cout << m3 << endl; | |
254 | pass &= compare(m ,m3); | |
255 | ||
256 | m3 = 2 * m4 - 1 * m3; | |
257 | ||
92f5a8d4 | 258 | cout << m3 << endl; |
7c673cae FG |
259 | |
260 | m <<= -4,-3,-8,-3,-12,-13,-8,-15,-20; | |
261 | ||
262 | pass &= compare(m, m3); | |
263 | ||
264 | m = m3; | |
265 | ||
266 | m3 = trans(m); | |
267 | ||
268 | pass &= compare(m3, trans(m)); | |
269 | ||
270 | // Check if bad index indeed works | |
271 | try { | |
272 | T a; | |
273 | a=m1( 100, 100 ); | |
274 | BOOST_UBLAS_NOT_USED( a ); | |
275 | ||
276 | } catch ( bad_index &e) { | |
277 | std::cout << " Caught (GOOD): " << e.what() << endl; | |
278 | pass &= true; | |
279 | } | |
280 | ||
281 | } | |
282 | ||
283 | return pass; | |
284 | ||
285 | } | |
286 | ||
287 | BOOST_UBLAS_TEST_DEF (test_fixed) { | |
288 | ||
289 | BOOST_UBLAS_DEBUG_TRACE( "Starting fixed container tests" ); | |
290 | ||
291 | BOOST_UBLAS_TEST_CHECK( test_vector< double >( "double") ); | |
292 | BOOST_UBLAS_TEST_CHECK( test_vector< float >( "float") ); | |
293 | BOOST_UBLAS_TEST_CHECK( test_vector< int >( "int") ); | |
294 | ||
295 | BOOST_UBLAS_TEST_CHECK( test_vector< std::complex<double> >( "std::complex<double>") ); | |
296 | BOOST_UBLAS_TEST_CHECK( test_vector< std::complex<float> >( "std::complex<float>") ); | |
297 | BOOST_UBLAS_TEST_CHECK( test_vector< std::complex<int> >( "std::complex<int>") ); | |
298 | ||
299 | BOOST_UBLAS_TEST_CHECK( test_matrix< double >( "double") ); | |
300 | BOOST_UBLAS_TEST_CHECK( test_matrix< float >( "float") ); | |
301 | BOOST_UBLAS_TEST_CHECK( test_matrix< int >( "int") ); | |
302 | ||
303 | BOOST_UBLAS_TEST_CHECK( test_matrix< std::complex<double> >( "std::complex<double>") ); | |
304 | BOOST_UBLAS_TEST_CHECK( test_matrix< std::complex<float> >( "std::complex<float>") ); | |
305 | BOOST_UBLAS_TEST_CHECK( test_matrix< std::complex<int> >( "std::complex<int>") ); | |
306 | } | |
307 | ||
308 | ||
309 | int main () { | |
310 | ||
311 | BOOST_UBLAS_TEST_BEGIN(); | |
312 | ||
313 | BOOST_UBLAS_TEST_DO( test_fixed ); | |
314 | ||
315 | BOOST_UBLAS_TEST_END(); | |
7c673cae FG |
316 | } |
317 | ||
318 | #else | |
319 | ||
320 | int main () { | |
321 | ||
322 | BOOST_UBLAS_TEST_BEGIN(); | |
323 | BOOST_UBLAS_TEST_END(); | |
7c673cae FG |
324 | } |
325 | #endif // BOOST_UBLAS_CPP_GE_2011 |