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