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> |
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(i: 2), 3 ,4, 5, move(i: -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(i: 3), 3 ,4, 5, move_to(i: 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> |
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(i: 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(i: 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(i: 3), 3 ,4, 5, fill_policy::sparse_insert(), move_to(i: 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> |
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(i: 2), 3 ,4, 5, move(i: -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(i: 3), 3 ,4, 5, move_to(i: 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> |
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(i: 1,j: 0), b, move_to(i: 0,j: 0), 1, 2, 3, move(i: 1,j: 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(i: 1,j: 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(i: 0,j: 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(i: 0,j: 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(i: 0,j: 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(i: 0,j: 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(i: 0,j: 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(i: 1,j: 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(i: 1,j: 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> |
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(i: 1,j: 0), b, fill_policy::sparse_insert(), move_to(i: 0,j: 0), 1, 2, 3, move(i: 1,j: 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(i: 2,j: 2), C, fill_policy::sparse_insert(), move_to(i: 0,j: 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(i: 2,j: 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(i: 1,j: 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(i: 0,j: 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(i: 0,j: 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(i: 0,j: 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> |
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(i: 1,j: 0), b, fill_policy::sparse_insert(), move_to(i: 0,j: 0), 1, 2, 3, move(i: 1,j: 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(i: 2,j: 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(i: 1,j: 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(i: 0,j: 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(i: 0,j: 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(i: 0,j: 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(i: 0,j: 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(i: 0,j: 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 | |
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 | |
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 | |
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 | |