1 //
2 // Copyright (c) 2010 Athanasios Iliopoulos
3 //
4 // Distributed under the Boost Software License, Version 1.0. (See
5 // accompanying file LICENSE_1_0.txt or copy at
6 // http://www.boost.org/LICENSE_1_0.txt)
7 //
8
9 #include <boost/numeric/ublas/assignment.hpp>
10 #include <boost/numeric/ublas/vector.hpp>
11 #include <boost/numeric/ublas/vector_proxy.hpp>
12 #include <boost/numeric/ublas/vector_sparse.hpp>
13 #include <boost/numeric/ublas/matrix_sparse.hpp>
14 #include <boost/numeric/ublas/io.hpp>
15 #include <boost/numeric/ublas/matrix.hpp>
16 #include <boost/timer.hpp>
17 #include <ctime>
18 #include "common/testhelper.hpp"
19 #include "utils.hpp"
20
21 using namespace boost::numeric::ublas;
22
23 template <class V>
test_vector()24 bool test_vector() {
25 bool pass = true;
26
27 V a(3), ra(3);
28 a <<= 1, 2, 3;
29 ra(0) = 1; ra(1) = 2; ra(2) = 3;
30 pass &= compare_to(a, ra);
31
32 V b(7), rb(7);
33 b<<= a, 10, a;
34 rb(0) = 1; rb(1) = 2; rb(2) = 3; rb(3)=10, rb(4)= 1; rb(5)=2; rb(6)=3;
35 pass &= compare_to(b, rb);
36
37 {
38 V c(6), rc(6);
39 c <<= 1, move(2), 3 ,4, 5, move(-5), 10, 10;
40 rc(0) = 1; rc(1) = 10; rc(2) = 10; rc(3) = 3; rc(4) = 4; rc(5) = 5;
41 pass &= compare_to(c, rc);
42
43 V d(6), rd(6);
44 d <<= 1, move_to(3), 3 ,4, 5, move_to(1), 10, 10;
45 rd(0) = 1; rd(1) = 10; rd(2) = 10; rd(3) = 3; rd(4) = 4; rd(5) = 5;
46 pass &= compare_to(d, rd);
47 }
48
49 {
50 V c(6), rc(6);
51 c <<= 1, move<2>(), 3 ,4, 5, move<-5>(), 10, 10;
52 rc(0) = 1; rc(1) = 10; rc(2) = 10; rc(3) = 3; rc(4) = 4; rc(5) = 5;
53 pass &= compare_to(c, rc);
54
55 V d(6), rd(6);
56 d <<= 1, move_to<3>(), 3 ,4, 5, move_to<1>(), 10, 10;
57 rd(0) = 1; rd(1) = 10; rd(2) = 10; rd(3) = 3; rd(4) = 4; rd(5) = 5;
58 pass &= compare_to(d, rd);
59 }
60
61
62 {
63 V f(6), rf(6);
64 f <<= 5, 5, 5, 5, 5, 5;
65 V fa(3); fa<<= 1, 2, 3;
66 f <<= fill_policy::index_plus_assign(), fa;
67 rf <<= 6,7,8, 5, 5, 5;
68 pass &= compare_to(f, rf);
69 }
70
71 {
72 V f(6), rf(6);
73 f <<= 5, 5, 5, 5, 5, 5;
74 V fa(3); fa<<= 1, 2, 3;
75 f <<= fill_policy::index_minus_assign(), fa;
76 rf <<= 4,3,2, 5, 5, 5;
77 pass &= compare_to(f, rf);
78 }
79
80 return pass;
81 }
82
83 template <class V>
test_vector_sparse_push_back()84 bool test_vector_sparse_push_back() {
85 bool pass = true;
86
87 V a(3), ra(3);
88 a <<= fill_policy::sparse_push_back(), 1, 2, 3;
89 ra(0) = 1; ra(1) = 2; ra(2) = 3;
90 pass &= compare_to(a, ra);
91
92 V b(7), rb(7);
93 b<<= fill_policy::sparse_push_back(), a, 10, a;
94 rb(0) = 1; rb(1) = 2; rb(2) = 3; rb(3)=10, rb(4)= 1; rb(5)=2; rb(6)=3;
95 pass &= compare_to(b, rb);
96
97 V c(6), rc(6);
98 c <<= fill_policy::sparse_push_back(), 1, move(2), 3 ,4, 5; // Move back (i.e. negative is dangerous for push_back)
99 rc(0) = 1; rc(1) = 0; rc(2) = 0; rc(3) = 3; rc(4) = 4; rc(5) = 5;
100 pass &= compare_to(c, rc);
101
102 V d(6), rd(6);
103 d <<= fill_policy::sparse_push_back(), 1, move_to(3), 3 ,4, 5; // Move back (i.e. before current index is dangerous for push_back)
104 rd(0) = 1; rd(1) = 0; rd(2) = 0; rd(3) = 3; rd(4) = 4; rd(5) = 5;
105 pass &= compare_to(d, rd);
106
107 V e(6), re(6);
108 e <<= fill_policy::sparse_push_back(), 1, move_to(3), 3 ,4, 5, fill_policy::sparse_insert(), move_to(1), 10, 10; // If you want to move back, use this
109 re(0) = 1; re(1) = 10; re(2) = 10; re(3) = 3; re(4) = 4; re(5) = 5;
110 pass &= compare_to(e, re);
111
112 return pass;
113 }
114
115
116 template <class V>
test_vector_sparse_insert()117 bool test_vector_sparse_insert() {
118 bool pass = true;
119
120 V a(3), ra(3);
121 a <<= fill_policy::sparse_insert(), 1, 2, 3;
122 ra(0) = 1; ra(1) = 2; ra(2) = 3;
123 pass &= compare_to(a, ra);
124
125 V b(7), rb(7);
126 b<<= fill_policy::sparse_insert(), a, 10, a;
127 rb(0) = 1; rb(1) = 2; rb(2) = 3; rb(3)=10, rb(4)= 1; rb(5)=2; rb(6)=3;
128 pass &= compare_to(b, rb);
129
130 V c(6), rc(6);
131 c <<= fill_policy::sparse_insert(), 1, move(2), 3 ,4, 5, move(-5), 10, 10; // Move back (i.e. negative is dangerous for sparse)
132 rc(0) = 1; rc(1) = 10; rc(2) = 10; rc(3) = 3; rc(4) = 4; rc(5) = 5;
133 pass &= compare_to(c, rc);
134
135
136 V d(6), rd(6);
137 d <<= fill_policy::sparse_insert(), 1, move_to(3), 3 ,4, 5, move_to(1), 10, 10; // Move back (i.e.before is dangerous for sparse)
138 rd(0) = 1; rd(1) = 10; rd(2) = 10; rd(3) = 3; rd(4) = 4; rd(5) = 5;
139 pass &= compare_to(d, rd);
140
141
142 return pass;
143 }
144
145
146 template <class V>
test_matrix()147 bool test_matrix() {
148 bool pass = true;
149
150 V A(3,3), RA(3,3);
151 A <<= 1, 2, 3, 4, 5, 6, 7, 8, 9;
152 RA(0,0)= 1; RA(0,1)=2; RA(0,2)=3;
153 RA(1,0)= 4; RA(1,1)=5; RA(1,2)=6;
154 RA(2,0)= 7; RA(2,1)=8; RA(2,2)=9;
155 pass &= compare_to(A, RA);
156
157 {
158 V B(3,3), RB(3,3);
159 vector<typename V::value_type> b(3);
160 b<<= 4,5,6;
161 B<<= 1, 2, 3, b, 7, project(b, range(1,3));
162 RB<<=1, 2, 3, 4, 5, 6, 7, 5, 6; // If the first worked we can now probably use it.
163 pass &= compare_to(B, RB);
164 }
165
166 {
167 V B(3,3), RB(3,3);
168 vector<typename V::value_type> b(3);
169 b<<= 4,5,6;
170 B<<= move(1,0), b, move_to(0,0), 1, 2, 3, move(1,0), 7, project(b, range(1,3));
171 RB<<=1, 2, 3, 4, 5, 6, 7, 5, 6;
172 pass &= compare_to(B, RB);
173 }
174
175 {
176 V B(3,3), RB(3,3);
177 vector<typename V::value_type> b(9);
178 b<<= 1, 2, 3, 4, 5, 6, 7, 8, 9;
179 B<<=b;
180 RB<<=1, 2, 3, 4, 5, 6, 7, 8, 9;
181 pass &= compare_to(B, RB);
182 }
183
184 {
185 V B(4,4), RB(4,4);
186 V C(2,2);
187 C <<= 2, 3,
188 4, 5;
189 B<<= C,C,
190 C,C;
191 RB <<= 2,3,2,3,
192 4,5,4,5,
193 2,3,2,3,
194 4,5,4,5;
195 pass &= compare_to(B, RB);
196 }
197
198 {
199 V B(4,4), RB(4,4);
200 V C(2,2);
201 C <<= 2, 3, 4, 5;
202 B<<= C, zero_matrix<typename V::value_type>(2,2),
203 zero_matrix<typename V::value_type>(2,2), C;
204 RB<<= 2,3,0,0,
205 4,5,0,0,
206 0,0,2,3,
207 0,0,4,5;
208 pass &= compare_to(B, RB);
209 }
210
211 {
212 V B(4,4), RB(4,4);
213 V C(2,2);
214 C <<= 2, 3, 4, 5;
215 B<<= C, zero_matrix<typename V::value_type>(2,2),
216 zero_matrix<typename V::value_type>(2,2), C;
217 RB<<= 2,3,0,0,
218 4,5,0,0,
219 0,0,2,3,
220 0,0,4,5;
221 pass &= compare_to(B, RB);
222 }
223
224 {
225 V B(4,4), RB(4,4);
226 B = zero_matrix<typename V::value_type>(4,4); // We need that because of the non-zero instatiation of dense types.
227 V C(2,2);
228 C <<= 2, 3, 4, 5;
229 B<<= move(1,1), C;
230 RB<<= 0,0,0,0,
231 0,2,3,0,
232 0,4,5,0,
233 0,0,0,0;
234 pass &= compare_to(B, RB);
235 }
236
237 {
238 V B(4,4), RB(4,4);
239 B = zero_matrix<typename V::value_type>(4,4);
240 B<<= move_to(0,1), 2, 3, next_row(), 1, 2, next_row(), 4, 5;
241 RB<<= 0,2,3,0,
242 1,2,0,0,
243 4,5,0,0,
244 0,0,0,0;
245 pass &= compare_to(B, RB);
246 }
247
248 {
249 V B(4,4), RB(4,4);
250 B = zero_matrix<typename V::value_type>(4,4);
251 B<<=traverse_policy::by_column(), move_to(0,1), 2, 3, 6, next_column(), 4, 5;
252 RB<<= 0,2,4,0,
253 0,3,5,0,
254 0,6,0,0,
255 0,0,0,0;
256 pass &= compare_to(B, RB);
257 }
258
259 {
260 V B(4,4), RB(4,4);
261 B = zero_matrix<typename V::value_type>(4,4);
262 B<<=traverse_policy::by_column(), move_to(0,1), 2, 3, next_row(), traverse_policy::by_row(), 4, 5;
263 RB<<= 0,2,0,0,
264 0,3,0,0,
265 0,0,0,0,
266 4,5,0,0;
267 pass &= compare_to(B, RB);
268 }
269
270 {
271 V B(4,4), RB(4,4);
272 B = zero_matrix<typename V::value_type>(4,4);
273 B<<=traverse_policy::by_column(), move_to(0,1), 2, 3, begin2(), traverse_policy::by_row(), 4, 5, 6, 7, 8;
274 RB<<= 0,2,0,0,
275 0,3,0,0,
276 4,5,6,7,
277 8,0,0,0;
278 pass &= compare_to(B, RB);
279 }
280
281 {
282 V B(4,4), RB(4,4);
283 B = zero_matrix<typename V::value_type>(4,4);
284 B<<=traverse_policy::by_column(), move_to(0,1), 2, 3, begin2(), traverse_policy::by_row(), 4, 5, 6, 7, 8,9, begin1(), 1, 2;
285 RB<<= 0,2,1,2,
286 0,3,0,0,
287 4,5,6,7,
288 8,9,0,0;
289 pass &= compare_to(B, RB);
290 }
291
292 {
293 V B(4,4), RB(4,4);
294 B = scalar_matrix<typename V::value_type>(4,4,1);
295 V C(2,2);
296 C <<= 1, 2, 3, 4;
297 B<<= fill_policy::index_plus_assign(), move(1,1), C;
298 RB<<= 1,1,1,1,
299 1,2,3,1,
300 1,4,5,1,
301 1,1,1,1;
302 pass &= compare_to(B, RB);
303 }
304
305 {
306 V B(4,4), RB(4,4);
307 B = scalar_matrix<typename V::value_type>(4,4,5);
308 V C(2,2);
309 C <<= 1, 2, 3, 4;
310 B<<= fill_policy::index_minus_assign(), move(1,1), C;
311 RB<<= 5,5,5,5,
312 5,4,3,5,
313 5,2,1,5,
314 5,5,5,5;
315 pass &= compare_to(B, RB);
316 }
317
318
319 return pass;
320 }
321
322 template <class V>
test_matrix_sparse_push_back()323 bool test_matrix_sparse_push_back() {
324 bool pass = true;
325
326 V A(3,3), RA(3,3);
327 A <<= fill_policy::sparse_push_back(), 1, 2, 3, 4, 5, 6, 7, 8, 9;
328 RA(0,0)= 1; RA(0,1)=2; RA(0,2)=3;
329 RA(1,0)= 4; RA(1,1)=5; RA(1,2)=6;
330 RA(2,0)= 7; RA(2,1)=8; RA(2,2)=9;
331 pass &= compare_to(A, RA);
332
333 {
334 V B(3,3), RB(3,3);
335 vector<typename V::value_type> b(3);
336 b<<= 4,5,6;
337 B<<=fill_policy::sparse_push_back(), 1, 2, 3, b, 7, project(b, range(1,3));
338 RB<<= 1, 2, 3, 4, 5, 6, 7, 5, 6; // If the first worked we can now probably use it.
339 pass &= compare_to(B, RB);
340 }
341
342 {
343 V B(3,3), RB(3,3);
344 vector<typename V::value_type> b(3);
345 b<<= 4,5,6;
346 B<<=fill_policy::sparse_push_back(), move(1,0), b, fill_policy::sparse_insert(), move_to(0,0), 1, 2, 3, move(1,0), 7, project(b, range(1,3));
347 RB<<=1, 2, 3, 4, 5, 6, 7, 5, 6;
348 pass &= compare_to(B, RB);
349 }
350
351 {
352 V B(3,3), RB(3,3);
353 vector<typename V::value_type> b(9);
354 b<<= 1, 2, 3, 4, 5, 6, 7, 8, 9;
355 B<<=b;
356 RB<<=1, 2, 3, 4, 5, 6, 7, 8, 9;
357 pass &= compare_to(B, RB);
358 }
359
360
361 {
362 V B(4,4), RB(4,4);
363 V C(2,2);
364 C <<= 2, 3,
365 4, 5;
366 // It might get complicated for sparse push_back, this must go into the tutorial. (This way is not convient nor fast)
367 B<<=fill_policy::sparse_push_back(), C, move_to(2,2), C, fill_policy::sparse_insert(), move_to(0,2), C, C;
368 RB <<= 2,3,2,3,
369 4,5,4,5,
370 2,3,2,3,
371 4,5,4,5;
372 pass &= compare_to(B, RB);
373 }
374
375
376 {
377 V B(4,4), RB(4,4);
378 V C(2,2);
379 C <<= 2, 3, 4, 5;
380 B<<=fill_policy::sparse_push_back(), C, move_to(2,2), C;
381 RB<<= 2,3,0,0,
382 4,5,0,0,
383 0,0,2,3,
384 0,0,4,5;
385 pass &= compare_to(B, RB);
386 }
387
388 {
389 V B(4,4), RB(4,4);
390 V C(2,2);
391 C <<= 2, 3, 4, 5;
392 B<<=fill_policy::sparse_push_back(), move(1,1), C;
393 RB<<= 0,0,0,0,
394 0,2,3,0,
395 0,4,5,0,
396 0,0,0,0;
397 pass &= compare_to(B, RB);
398 }
399
400 {
401 V B(4,4), RB(4,4);
402 B = zero_matrix<typename V::value_type>(4,4);
403 B<<=fill_policy::sparse_push_back(), move_to(0,1), 2, 3, next_row(), 1, 2, next_row(), 4, 5;
404 RB<<= 0,2,3,0,
405 1,2,0,0,
406 4,5,0,0,
407 0,0,0,0;
408 pass &= compare_to(B, RB);
409 }
410 // The next will not work with sparse push_back because elements that are prior to the ones already in are attempted to be added
411 /*
412 {
413 V B(4,4), RB(4,4);
414 B = zero_matrix<typename V::value_type>(4,4);
415 B<<=fill_policy::sparse_push_back(),traverse_policy::by_column(), move_to(0,1), 2, 3, 6, next_column(), 4, 5;
416 RB<<= 0,2,4,0,
417 0,3,5,0,
418 0,6,0,0,
419 0,0,0,0;
420 pass &= compare_to(B, RB);
421 }
422 */
423 {
424 V B(4,4), RB(4,4);
425 B = zero_matrix<typename V::value_type>(4,4);
426 B<<=fill_policy::sparse_push_back(),traverse_policy::by_column(), move_to(0,1), 2, 3, next_row(), traverse_policy::by_row(), 4, 5;
427 RB<<= 0,2,0,0,
428 0,3,0,0,
429 0,0,0,0,
430 4,5,0,0;
431 pass &= compare_to(B, RB);
432 }
433
434 {
435 V B(4,4), RB(4,4);
436 B = zero_matrix<typename V::value_type>(4,4);
437 B<<=fill_policy::sparse_push_back(),traverse_policy::by_column(), move_to(0,1), 2, 3, begin2(), traverse_policy::by_row(), 4, 5, 6, 7, 8;
438 RB<<= 0,2,0,0,
439 0,3,0,0,
440 4,5,6,7,
441 8,0,0,0;
442 pass &= compare_to(B, RB);
443 }
444
445 // The next will not work with sparse push_back because elements that are prior to the ones already in are attempted to be added
446 /*
447 {
448 V B(4,4), RB(4,4);
449 B = zero_matrix<typename V::value_type>(4,4);
450 B<<=fill_policy::sparse_push_back(),traverse_policy::by_column(), move_to(0,1), 2, 3, begin2(), traverse_policy::by_row(), 4, 5, 6, 7, 8,9, begin1(), 1, 2;
451 RB<<= 0,2,1,2,
452 0,3,0,0,
453 4,5,6,7,
454 8,9,0,0;
455 pass &= compare_to(B, RB);
456 }
457 */
458 return pass;
459 }
460
461 template <class V>
test_matrix_sparse_insert()462 bool test_matrix_sparse_insert() {
463 bool pass = true;
464
465 V A(3,3), RA(3,3);
466 A <<= fill_policy::sparse_insert(), 1, 2, 3, 4, 5, 6, 7, 8, 9;
467 RA(0,0)= 1; RA(0,1)=2; RA(0,2)=3;
468 RA(1,0)= 4; RA(1,1)=5; RA(1,2)=6;
469 RA(2,0)= 7; RA(2,1)=8; RA(2,2)=9;
470 pass &= compare_to(A, RA);
471
472 {
473 V B(3,3), RB(3,3);
474 vector<typename V::value_type> b(3);
475 b<<= 4,5,6;
476 B<<=fill_policy::sparse_insert(), 1, 2, 3, b, 7, project(b, range(1,3));
477 RB<<=1, 2, 3, 4, 5, 6, 7, 5, 6; // If the first worked we can now probably use it.
478 pass &= compare_to(B, RB);
479 }
480
481 {
482 V B(3,3), RB(3,3);
483 vector<typename V::value_type> b(3);
484 b<<= 4,5,6;
485 B<<=fill_policy::sparse_insert(), move(1,0), b, fill_policy::sparse_insert(), move_to(0,0), 1, 2, 3, move(1,0), 7, project(b, range(1,3));
486 RB<<=1, 2, 3, 4, 5, 6, 7, 5, 6;
487 pass &= compare_to(B, RB);
488 }
489
490 {
491 V B(3,3), RB(3,3);
492 vector<typename V::value_type> b(9);
493 b<<= 1, 2, 3, 4, 5, 6, 7, 8, 9;
494 B<<=b;
495 RB<<=1, 2, 3, 4, 5, 6, 7, 8, 9;
496 pass &= compare_to(B, RB);
497 }
498
499
500 {
501 V B(4,4), RB(4,4);
502 V C(2,2);
503 C <<= 2, 3,
504 4, 5;
505 B<<=fill_policy::sparse_insert(), C, C, C, C;
506 RB <<= 2,3,2,3,
507 4,5,4,5,
508 2,3,2,3,
509 4,5,4,5;
510 pass &= compare_to(B, RB);
511 }
512
513
514 {
515 V B(4,4), RB(4,4);
516 V C(2,2);
517 C <<= 2, 3, 4, 5;
518 B<<=fill_policy::sparse_insert(), C, move_to(2,2), C;
519 RB<<= 2,3,0,0,
520 4,5,0,0,
521 0,0,2,3,
522 0,0,4,5;
523 pass &= compare_to(B, RB);
524 }
525
526 {
527 V B(4,4), RB(4,4);
528 V C(2,2);
529 C <<= 2, 3, 4, 5;
530 B<<=fill_policy::sparse_insert(), move(1,1), C;
531 RB<<= 0,0,0,0,
532 0,2,3,0,
533 0,4,5,0,
534 0,0,0,0;
535 pass &= compare_to(B, RB);
536 }
537
538 {
539 V B(4,4), RB(4,4);
540 B = zero_matrix<typename V::value_type>(4,4);
541 B<<=fill_policy::sparse_insert(), move_to(0,1), 2, 3, next_row(), 1, 2, next_row(), 4, 5;
542 RB<<= 0,2,3,0,
543 1,2,0,0,
544 4,5,0,0,
545 0,0,0,0;
546 pass &= compare_to(B, RB);
547 }
548
549 {
550 V B(4,4), RB(4,4);
551 B = zero_matrix<typename V::value_type>(4,4);
552 B<<=fill_policy::sparse_insert(),traverse_policy::by_column(), move_to(0,1), 2, 3, 6, next_column(), 4, 5;
553 RB<<= 0,2,4,0,
554 0,3,5,0,
555 0,6,0,0,
556 0,0,0,0;
557 pass &= compare_to(B, RB);
558 }
559
560 {
561 V B(4,4), RB(4,4);
562 B = zero_matrix<typename V::value_type>(4,4);
563 B<<=fill_policy::sparse_insert(),traverse_policy::by_column(), move_to(0,1), 2, 3, next_row(), traverse_policy::by_row(), 4, 5;
564 RB<<= 0,2,0,0,
565 0,3,0,0,
566 0,0,0,0,
567 4,5,0,0;
568 pass &= compare_to(B, RB);
569 }
570
571 {
572 V B(4,4), RB(4,4);
573 B = zero_matrix<typename V::value_type>(4,4);
574 B<<=fill_policy::sparse_insert(),traverse_policy::by_column(), move_to(0,1), 2, 3, begin2(), traverse_policy::by_row(), 4, 5, 6, 7, 8;
575 RB<<= 0,2,0,0,
576 0,3,0,0,
577 4,5,6,7,
578 8,0,0,0;
579 pass &= compare_to(B, RB);
580 }
581
582 {
583 V B(4,4), RB(4,4);
584 B = zero_matrix<typename V::value_type>(4,4);
585 B<<=fill_policy::sparse_insert(),traverse_policy::by_column(), move_to(0,1), 2, 3, begin2(), traverse_policy::by_row(), 4, 5, 6, 7, 8,9, begin1(), 1, 2;
586 RB<<= 0,2,1,2,
587 0,3,0,0,
588 4,5,6,7,
589 8,9,0,0;
590 pass &= compare_to(B, RB);
591 }
592
593 return pass;
594 }
595
596
BOOST_UBLAS_TEST_DEF(test_vector)597 BOOST_UBLAS_TEST_DEF (test_vector) {
598
599 BOOST_UBLAS_DEBUG_TRACE( "Starting operator \"<<= \" vector assignment tests" );
600
601 BOOST_UBLAS_TEST_CHECK(test_vector<vector<double> >());
602 BOOST_UBLAS_TEST_CHECK(test_vector<vector<float> >());
603 BOOST_UBLAS_TEST_CHECK(test_vector<vector<long> >());
604 BOOST_UBLAS_TEST_CHECK(test_vector<vector<unsigned long> >());
605 BOOST_UBLAS_TEST_CHECK(test_vector<vector<int> >());
606 BOOST_UBLAS_TEST_CHECK(test_vector<vector<unsigned int> >());
607 BOOST_UBLAS_TEST_CHECK(test_vector<vector<std::size_t> >());
608 BOOST_UBLAS_TEST_CHECK(test_vector<vector<char> >());
609
610 BOOST_UBLAS_TEST_CHECK((test_vector<bounded_vector<double,7> >()));
611 BOOST_UBLAS_TEST_CHECK((test_vector<bounded_vector<float,7> >()));
612 BOOST_UBLAS_TEST_CHECK((test_vector<bounded_vector<long,7> >()));
613 BOOST_UBLAS_TEST_CHECK((test_vector<bounded_vector<unsigned long,7> >()));
614 BOOST_UBLAS_TEST_CHECK((test_vector<bounded_vector<int,7> >()));
615 BOOST_UBLAS_TEST_CHECK((test_vector<bounded_vector<unsigned int,7> >()));
616 BOOST_UBLAS_TEST_CHECK((test_vector<bounded_vector<std::size_t,7> >()));
617 BOOST_UBLAS_TEST_CHECK((test_vector<bounded_vector<char,7> >()));
618
619 BOOST_UBLAS_TEST_CHECK(test_vector<mapped_vector<double> >());
620 BOOST_UBLAS_TEST_CHECK(test_vector<mapped_vector<float> >());
621 BOOST_UBLAS_TEST_CHECK(test_vector<mapped_vector<long> >());
622 BOOST_UBLAS_TEST_CHECK(test_vector<mapped_vector<unsigned long> >());
623 BOOST_UBLAS_TEST_CHECK(test_vector<mapped_vector<int> >());
624 BOOST_UBLAS_TEST_CHECK(test_vector<mapped_vector<unsigned int> >())
625 BOOST_UBLAS_TEST_CHECK(test_vector<mapped_vector<std::size_t> >())
626 BOOST_UBLAS_TEST_CHECK(test_vector<mapped_vector<char> >());
627
628 BOOST_UBLAS_TEST_CHECK(test_vector<compressed_vector<double> >());
629 BOOST_UBLAS_TEST_CHECK(test_vector<compressed_vector<float> >());
630 BOOST_UBLAS_TEST_CHECK(test_vector<compressed_vector<long> >());
631 BOOST_UBLAS_TEST_CHECK(test_vector<compressed_vector<unsigned long> >());
632 BOOST_UBLAS_TEST_CHECK(test_vector<compressed_vector<int> >());
633 BOOST_UBLAS_TEST_CHECK(test_vector<compressed_vector<unsigned int> >());
634 BOOST_UBLAS_TEST_CHECK(test_vector<compressed_vector<std::size_t> >());
635 BOOST_UBLAS_TEST_CHECK(test_vector<compressed_vector<char> >());
636
637 BOOST_UBLAS_TEST_CHECK(test_vector<coordinate_vector<double> >());
638 BOOST_UBLAS_TEST_CHECK(test_vector<coordinate_vector<float> >());
639 BOOST_UBLAS_TEST_CHECK(test_vector<coordinate_vector<long> >())
640 BOOST_UBLAS_TEST_CHECK(test_vector<coordinate_vector<unsigned long> >())
641 BOOST_UBLAS_TEST_CHECK(test_vector<coordinate_vector<int> >());
642 BOOST_UBLAS_TEST_CHECK(test_vector<coordinate_vector<unsigned int> >());
643 BOOST_UBLAS_TEST_CHECK(test_vector<coordinate_vector<std::size_t> >());
644 BOOST_UBLAS_TEST_CHECK(test_vector<coordinate_vector<char> >());
645
646 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<compressed_vector<double> >());
647 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<compressed_vector<float> >());
648 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<compressed_vector<long> >());
649 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<compressed_vector<unsigned long> >());
650 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<compressed_vector<int> >());
651 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<compressed_vector<unsigned int> >());
652 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<compressed_vector<std::size_t> >());
653 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<compressed_vector<char> >());
654
655 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<coordinate_vector<double> >());
656 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<coordinate_vector<float> >());
657 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<coordinate_vector<long> >());
658 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<coordinate_vector<unsigned long> >());
659 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<coordinate_vector<int> >());
660 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<coordinate_vector<unsigned int> >());
661 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<coordinate_vector<std::size_t> >());
662 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_push_back<coordinate_vector<char> >());
663
664 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<compressed_vector<double> >());
665 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<compressed_vector<float> >());
666 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<compressed_vector<long> >());
667 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<compressed_vector<unsigned long> >());
668 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<compressed_vector<int> >());
669 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<compressed_vector<unsigned int> >());
670 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<compressed_vector<std::size_t> >());
671 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<compressed_vector<char> >());
672
673 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<coordinate_vector<double> >());
674 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<coordinate_vector<float> >());
675 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<coordinate_vector<long> >());
676 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<coordinate_vector<unsigned long> >());
677 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<coordinate_vector<int> >());
678 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<coordinate_vector<unsigned int> >());
679 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<coordinate_vector<std::size_t> >());
680 BOOST_UBLAS_TEST_CHECK(test_vector_sparse_insert<coordinate_vector<char> >());
681 }
682
BOOST_UBLAS_TEST_DEF(test_matrix)683 BOOST_UBLAS_TEST_DEF (test_matrix) {
684
685 BOOST_UBLAS_DEBUG_TRACE( "Starting operator \"<<= \" matrix assignment tests" );
686
687 BOOST_UBLAS_TEST_CHECK(test_matrix<matrix<double> >());
688 BOOST_UBLAS_TEST_CHECK(test_matrix<matrix<float> >());
689 BOOST_UBLAS_TEST_CHECK(test_matrix<matrix<long> >());
690 BOOST_UBLAS_TEST_CHECK(test_matrix<matrix<unsigned long> >());
691 BOOST_UBLAS_TEST_CHECK(test_matrix<matrix<int> >());
692 BOOST_UBLAS_TEST_CHECK(test_matrix<matrix<unsigned int> >());
693 BOOST_UBLAS_TEST_CHECK(test_matrix<matrix<std::size_t> >());
694 BOOST_UBLAS_TEST_CHECK(test_matrix<matrix<char> >());
695
696 BOOST_UBLAS_TEST_CHECK((test_matrix<bounded_matrix<double,7, 7> >()));
697 BOOST_UBLAS_TEST_CHECK((test_matrix<bounded_matrix<float,7, 7> >()));
698 BOOST_UBLAS_TEST_CHECK((test_matrix<bounded_matrix<long,7, 7> >()));
699 BOOST_UBLAS_TEST_CHECK((test_matrix<bounded_matrix<unsigned long,7, 7> >()));
700 BOOST_UBLAS_TEST_CHECK((test_matrix<bounded_matrix<int,7,7 > >()));
701 BOOST_UBLAS_TEST_CHECK((test_matrix<bounded_matrix<unsigned int,7, 7> >()));
702 BOOST_UBLAS_TEST_CHECK((test_matrix<bounded_matrix<char,7, 7> >()));
703 BOOST_UBLAS_TEST_CHECK((test_matrix<bounded_matrix<std::size_t,7, 7> >()));
704
705 BOOST_UBLAS_TEST_CHECK(test_matrix<mapped_matrix<double> >());
706 BOOST_UBLAS_TEST_CHECK(test_matrix<mapped_matrix<float> >());
707 BOOST_UBLAS_TEST_CHECK(test_matrix<mapped_matrix<long> >());
708 BOOST_UBLAS_TEST_CHECK(test_matrix<mapped_matrix<unsigned long> >());
709 BOOST_UBLAS_TEST_CHECK(test_matrix<mapped_matrix<int> >());
710 BOOST_UBLAS_TEST_CHECK(test_matrix<mapped_matrix<unsigned int> >())
711 BOOST_UBLAS_TEST_CHECK(test_matrix<mapped_matrix<std::size_t> >())
712 BOOST_UBLAS_TEST_CHECK(test_matrix<mapped_matrix<char> >());
713
714 BOOST_UBLAS_TEST_CHECK(test_matrix<compressed_matrix<double> >());
715 BOOST_UBLAS_TEST_CHECK(test_matrix<compressed_matrix<float> >());
716 BOOST_UBLAS_TEST_CHECK(test_matrix<compressed_matrix<long> >());
717 BOOST_UBLAS_TEST_CHECK(test_matrix<compressed_matrix<unsigned long> >());
718 BOOST_UBLAS_TEST_CHECK(test_matrix<compressed_matrix<int> >());
719 BOOST_UBLAS_TEST_CHECK(test_matrix<compressed_matrix<unsigned int> >());
720 BOOST_UBLAS_TEST_CHECK(test_matrix<compressed_matrix<std::size_t> >());
721 BOOST_UBLAS_TEST_CHECK(test_matrix<compressed_matrix<char> >());
722
723 BOOST_UBLAS_TEST_CHECK(test_matrix<coordinate_matrix<double> >());
724 BOOST_UBLAS_TEST_CHECK(test_matrix<coordinate_matrix<float> >());
725 BOOST_UBLAS_TEST_CHECK(test_matrix<coordinate_matrix<long> >())
726 BOOST_UBLAS_TEST_CHECK(test_matrix<coordinate_matrix<unsigned long> >())
727 BOOST_UBLAS_TEST_CHECK(test_matrix<coordinate_matrix<int> >());
728 BOOST_UBLAS_TEST_CHECK(test_matrix<coordinate_matrix<unsigned int> >());
729 BOOST_UBLAS_TEST_CHECK(test_matrix<coordinate_matrix<std::size_t> >());
730 BOOST_UBLAS_TEST_CHECK(test_matrix<coordinate_matrix<char> >());
731
732 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<compressed_matrix<double> >());
733 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<compressed_matrix<float> >());
734 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<compressed_matrix<long> >());
735 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<compressed_matrix<unsigned long> >());
736 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<compressed_matrix<int> >());
737 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<compressed_matrix<unsigned int> >());
738 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<compressed_matrix<std::size_t> >());
739 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<compressed_matrix<char> >());
740
741 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<coordinate_matrix<double> >());
742 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<coordinate_matrix<float> >());
743 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<coordinate_matrix<long> >());
744 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<coordinate_matrix<unsigned long> >());
745 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<coordinate_matrix<int> >());
746 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<coordinate_matrix<unsigned int> >());
747 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<coordinate_matrix<std::size_t> >());
748 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_push_back<coordinate_matrix<char> >());
749
750
751 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<compressed_matrix<double> >());
752 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<compressed_matrix<float> >());
753 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<compressed_matrix<long> >());
754 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<compressed_matrix<unsigned long> >());
755 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<compressed_matrix<int> >());
756 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<compressed_matrix<unsigned int> >());
757 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<compressed_matrix<std::size_t> >());
758 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<compressed_matrix<char> >());
759
760 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<coordinate_matrix<double> >());
761 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<coordinate_matrix<float> >());
762 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<coordinate_matrix<long> >());
763 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<coordinate_matrix<unsigned long> >());
764 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<coordinate_matrix<int> >());
765 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<coordinate_matrix<unsigned int> >());
766 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<coordinate_matrix<std::size_t> >());
767 BOOST_UBLAS_TEST_CHECK(test_matrix_sparse_insert<coordinate_matrix<char> >());
768 }
769
770
main()771 int main () {
772 BOOST_UBLAS_TEST_BEGIN();
773
774 BOOST_UBLAS_TEST_DO( test_vector );
775 BOOST_UBLAS_TEST_DO( test_matrix );
776
777 BOOST_UBLAS_TEST_END();
778
779 return EXIT_SUCCESS;
780 }
781