1 //=================================================================================================
2 /*!
3 // \file src/mathtest/vectors/compressedvector/ProxyTest.cpp
4 // \brief Source file for the CompressedVector proxy test
5 //
6 // Copyright (C) 2012-2020 Klaus Iglberger - All Rights Reserved
7 //
8 // This file is part of the Blaze library. You can redistribute it and/or modify it under
9 // the terms of the New (Revised) BSD License. Redistribution and use in source and binary
10 // forms, with or without modification, are permitted provided that the following conditions
11 // are met:
12 //
13 // 1. Redistributions of source code must retain the above copyright notice, this list of
14 // conditions and the following disclaimer.
15 // 2. Redistributions in binary form must reproduce the above copyright notice, this list
16 // of conditions and the following disclaimer in the documentation and/or other materials
17 // provided with the distribution.
18 // 3. Neither the names of the Blaze development group nor the names of its contributors
19 // may be used to endorse or promote products derived from this software without specific
20 // prior written permission.
21 //
22 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
23 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24 // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
25 // SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
27 // TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
28 // BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 // CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
30 // ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
31 // DAMAGE.
32 */
33 //=================================================================================================
34
35
36 //*************************************************************************************************
37 // Includes
38 //*************************************************************************************************
39
40 #include <cstdlib>
41 #include <iostream>
42 #include <blazetest/mathtest/vectors/compressedvector/ProxyTest.h>
43 #include <blazetest/system/LAPACK.h>
44
45 #ifdef BLAZE_USE_HPX_THREADS
46 # include <hpx/hpx_main.hpp>
47 #endif
48
49
50 namespace blazetest {
51
52 namespace mathtest {
53
54 namespace vectors {
55
56 namespace compressedvector {
57
58 //=================================================================================================
59 //
60 // CONSTRUCTORS
61 //
62 //=================================================================================================
63
64 //*************************************************************************************************
65 /*!\brief Constructor for the CompressedVector proxy test.
66 //
67 // \exception std::runtime_error Operation error detected.
68 */
ProxyTest()69 ProxyTest::ProxyTest()
70 {
71 testAssignment();
72 testAddAssign();
73 testSubAssign();
74 testMultAssign();
75 testDivAssign();
76 testModAssign();
77 testScaling();
78 testSubscript();
79 testFunctionCall();
80 testIterator();
81 testNonZeros();
82 testReset();
83 testClear();
84 testResize();
85 testExtend();
86 testReserve();
87 testTrim();
88 testSwap();
89 testSet();
90 testInsert();
91 testAppend();
92 testErase();
93 testFind();
94 testLowerBound();
95 testUpperBound();
96 testTranspose();
97 testCTranspose();
98 testInvert();
99 }
100 //*************************************************************************************************
101
102
103
104
105 //=================================================================================================
106 //
107 // TEST FUNCTIONS
108 //
109 //=================================================================================================
110
111 //*************************************************************************************************
112 /*!\brief Test of the VectorAccessProxy assignment operators.
113 //
114 // \return void
115 // \exception std::runtime_error Error detected.
116 //
117 // This function performs a test of all assignment operators of the VectorAccessProxy class
118 // template. In case an error is detected, a \a std::runtime_error exception is thrown.
119 */
testAssignment()120 void ProxyTest::testAssignment()
121 {
122 //=====================================================================================
123 // Homogeneous assignment
124 //=====================================================================================
125
126 {
127 test_ = "VectorAccessProxy homogeneous assignment";
128
129 DVV vec( 3UL, 1UL );
130 vec[1] = DV( 3UL, 2 );
131
132 vec[1] = 4;
133
134 checkSize ( vec, 3UL );
135 checkCapacity( vec, 1UL );
136 checkNonZeros( vec, 1UL );
137
138 checkSize ( vec[0], 0UL );
139 checkSize ( vec[1], 3UL );
140 checkCapacity( vec[1], 3UL );
141 checkNonZeros( vec[1], 3UL );
142 checkSize ( vec[2], 0UL );
143
144 if( vec[1][0] != 4 || vec[1][1] != 4 || vec[1][2] != 4 ) {
145 std::ostringstream oss;
146 oss << " Test: " << test_ << "\n"
147 << " Error: Assignment failed\n"
148 << " Details:\n"
149 << " Result:\n" << vec[1] << "\n"
150 << " Expected result:\n( 4 4 4 )\n";
151 throw std::runtime_error( oss.str() );
152 }
153 }
154
155
156 //=====================================================================================
157 // List assignment
158 //=====================================================================================
159
160 {
161 test_ = "VectorAccessProxy 1D initializer list assignment";
162
163 DVV vec( 3UL, 1UL );
164 vec[1] = DV( 3UL, 2 );
165
166 vec[1] = { 1, -2, 3 };
167
168 checkSize ( vec, 3UL );
169 checkCapacity( vec, 1UL );
170 checkNonZeros( vec, 1UL );
171
172 checkSize ( vec[0], 0UL );
173 checkSize ( vec[1], 3UL );
174 checkCapacity( vec[1], 3UL );
175 checkNonZeros( vec[1], 3UL );
176 checkSize ( vec[2], 0UL );
177
178 if( vec[1][0] != 1 || vec[1][1] != -2 || vec[1][2] != 3 ) {
179 std::ostringstream oss;
180 oss << " Test: " << test_ << "\n"
181 << " Error: Assignment failed\n"
182 << " Details:\n"
183 << " Result:\n" << vec[1] << "\n"
184 << " Expected result:\n( 1 -2 3 )\n";
185 throw std::runtime_error( oss.str() );
186 }
187 }
188
189 {
190 test_ = "VectorAccessProxy 2D initializer list assignment";
191
192 using blaze::initializer_list;
193
194 DMV vec( 3UL, 1UL );
195 vec[1] = DM( 3UL, 3UL, 2 );
196
197 initializer_list< initializer_list<int> > list = { { 1, -2, 3 }, { -2, 4, -6 }, { 3, -6, 9 } };
198 vec[1] = list;
199
200 checkSize ( vec, 3UL );
201 checkCapacity( vec, 1UL );
202 checkNonZeros( vec, 1UL );
203
204 checkRows ( vec[0], 0UL );
205 checkColumns ( vec[0], 0UL );
206 checkRows ( vec[1], 3UL );
207 checkColumns ( vec[1], 3UL );
208 checkCapacity( vec[1], 9UL );
209 checkNonZeros( vec[1], 9UL );
210 checkRows ( vec[2], 0UL );
211 checkColumns ( vec[2], 0UL );
212
213 if( vec[1](0,0) != 1 || vec[1](0,1) != -2 || vec[1](0,2) != 3 ||
214 vec[1](1,0) != -2 || vec[1](1,1) != 4 || vec[1](1,2) != -6 ||
215 vec[1](2,0) != 3 || vec[1](2,1) != -6 || vec[1](2,2) != 9 ) {
216 std::ostringstream oss;
217 oss << " Test: " << test_ << "\n"
218 << " Error: Assignment failed\n"
219 << " Details:\n"
220 << " Result:\n" << vec[1] << "\n"
221 << " Expected result:\n( 1 -2 3 )\n( -2 4 -6 )\n( 3 -6 9 )\n";
222 throw std::runtime_error( oss.str() );
223 }
224 }
225
226
227 //=====================================================================================
228 // Array assignment
229 //=====================================================================================
230
231 {
232 test_ = "VectorAccessProxy array assignment";
233
234 const int array[3] = { 1, 2, 3 };
235 DVV vec( 3UL, 1UL );
236 vec[1] = DV( 3UL, 0 );
237
238 vec[1] = array;
239
240 checkSize ( vec, 3UL );
241 checkCapacity( vec, 1UL );
242 checkNonZeros( vec, 1UL );
243
244 checkSize ( vec[0], 0UL );
245 checkSize ( vec[1], 3UL );
246 checkCapacity( vec[1], 3UL );
247 checkNonZeros( vec[1], 3UL );
248 checkSize ( vec[2], 0UL );
249
250 if( vec[1][0] != 1 || vec[1][1] != 2 || vec[1][2] != 3 ) {
251 std::ostringstream oss;
252 oss << " Test: " << test_ << "\n"
253 << " Error: Assignment failed\n"
254 << " Details:\n"
255 << " Result:\n" << vec[1] << "\n"
256 << " Expected result:\n( 1 2 3 )\n";
257 throw std::runtime_error( oss.str() );
258 }
259 }
260
261
262 //=====================================================================================
263 // Copy assignment
264 //=====================================================================================
265
266 {
267 test_ = "VectorAccessProxy copy assignment";
268
269 DVV vec( 3UL, 1UL );
270 vec[0] = DV( 3UL, 5 );
271
272 vec[1] = vec[0];
273
274 checkSize ( vec, 3UL );
275 checkCapacity( vec, 1UL );
276 checkNonZeros( vec, 2UL );
277
278 checkSize ( vec[0], 3UL );
279 checkCapacity( vec[0], 3UL );
280 checkNonZeros( vec[0], 3UL );
281 checkSize ( vec[1], 3UL );
282 checkCapacity( vec[1], 3UL );
283 checkNonZeros( vec[1], 3UL );
284 checkSize ( vec[2], 0UL );
285
286 if( vec[1][0] != 5 || vec[1][1] != 5 || vec[1][2] != 5 ) {
287 std::ostringstream oss;
288 oss << " Test: " << test_ << "\n"
289 << " Error: Assignment failed\n"
290 << " Details:\n"
291 << " Result:\n" << vec[1] << "\n"
292 << " Expected result:\n( 5 5 5 )\n";
293 throw std::runtime_error( oss.str() );
294 }
295 }
296
297
298 //=====================================================================================
299 // Dense vector assignment
300 //=====================================================================================
301
302 {
303 test_ = "VectorAccessProxy dense vector assignment";
304
305 DV tmp( 3UL );
306 tmp[0] = 1;
307 tmp[1] = 2;
308 tmp[2] = 3;
309 DVV vec( 3UL, 1UL );
310
311 vec[1] = tmp;
312
313 checkSize ( vec, 3UL );
314 checkCapacity( vec, 1UL );
315 checkNonZeros( vec, 1UL );
316
317 checkSize ( vec[0], 0UL );
318 checkSize ( vec[1], 3UL );
319 checkCapacity( vec[1], 3UL );
320 checkNonZeros( vec[1], 3UL );
321 checkSize ( vec[2], 0UL );
322
323 if( vec[1][0] != 1 || vec[1][1] != 2 || vec[1][2] != 3 ) {
324 std::ostringstream oss;
325 oss << " Test: " << test_ << "\n"
326 << " Error: Assignment failed\n"
327 << " Details:\n"
328 << " Result:\n" << vec[1] << "\n"
329 << " Expected result:\n( 1 2 3 )\n";
330 throw std::runtime_error( oss.str() );
331 }
332 }
333
334
335 //=====================================================================================
336 // Sparse vector assignment
337 //=====================================================================================
338
339 {
340 test_ = "VectorAccessProxy sparse vector assignment";
341
342 SV tmp( 3UL );
343 tmp[1] = 2;
344 DVV vec( 3UL, 1UL );
345
346 vec[1] = tmp;
347
348 checkSize ( vec, 3UL );
349 checkCapacity( vec, 1UL );
350 checkNonZeros( vec, 1UL );
351
352 checkSize ( vec[0], 0UL );
353 checkSize ( vec[1], 3UL );
354 checkCapacity( vec[1], 3UL );
355 checkNonZeros( vec[1], 1UL );
356 checkSize ( vec[2], 0UL );
357
358 if( vec[1][0] != 0 || vec[1][1] != 2 || vec[1][2] != 0 ) {
359 std::ostringstream oss;
360 oss << " Test: " << test_ << "\n"
361 << " Error: Assignment failed\n"
362 << " Details:\n"
363 << " Result:\n" << vec[1] << "\n"
364 << " Expected result:\n( 0 2 0 )\n";
365 throw std::runtime_error( oss.str() );
366 }
367 }
368 }
369 //*************************************************************************************************
370
371
372 //*************************************************************************************************
373 /*!\brief Test of the VectorAccessProxy addition assignment operators.
374 //
375 // \return void
376 // \exception std::runtime_error Error detected.
377 //
378 // This function performs a test of the addition assignment operators of the VectorAccessProxy
379 // class template. In case an error is detected, a \a std::runtime_error exception is thrown.
380 */
testAddAssign()381 void ProxyTest::testAddAssign()
382 {
383 //=====================================================================================
384 // Dense vector addition assignment
385 //=====================================================================================
386
387 {
388 test_ = "VectorAccessProxy dense vector addition assignment";
389
390 DV tmp( 3UL );
391 tmp[0] = 1;
392 tmp[1] = 2;
393 tmp[2] = 3;
394 DVV vec( 3UL, 1UL );
395 vec[1] = tmp;
396
397 vec[1] += tmp;
398
399 checkSize ( vec, 3UL );
400 checkCapacity( vec, 1UL );
401 checkNonZeros( vec, 1UL );
402
403 checkSize ( vec[0], 0UL );
404 checkSize ( vec[1], 3UL );
405 checkCapacity( vec[1], 3UL );
406 checkNonZeros( vec[1], 3UL );
407 checkSize ( vec[2], 0UL );
408
409 if( vec[1][0] != 2 || vec[1][1] != 4 || vec[1][2] != 6 ) {
410 std::ostringstream oss;
411 oss << " Test: " << test_ << "\n"
412 << " Error: Assignment failed\n"
413 << " Details:\n"
414 << " Result:\n" << vec[1] << "\n"
415 << " Expected result:\n( 2 4 6 )\n";
416 throw std::runtime_error( oss.str() );
417 }
418 }
419
420
421 //=====================================================================================
422 // Sparse vector addition assignment
423 //=====================================================================================
424
425 {
426 test_ = "VectorAccessProxy sparse vector addition assignment";
427
428 SV tmp( 3UL );
429 tmp[1] = 2;
430 DVV vec( 3UL, 1UL );
431 vec[1] = tmp;
432
433 vec[1] += tmp;
434
435 checkSize ( vec, 3UL );
436 checkCapacity( vec, 1UL );
437 checkNonZeros( vec, 1UL );
438
439 checkSize ( vec[0], 0UL );
440 checkSize ( vec[1], 3UL );
441 checkCapacity( vec[1], 3UL );
442 checkNonZeros( vec[1], 1UL );
443 checkSize ( vec[2], 0UL );
444
445 if( vec[1][0] != 0 || vec[1][1] != 4 || vec[1][2] != 0 ) {
446 std::ostringstream oss;
447 oss << " Test: " << test_ << "\n"
448 << " Error: Assignment failed\n"
449 << " Details:\n"
450 << " Result:\n" << vec[1] << "\n"
451 << " Expected result:\n( 0 4 0 )\n";
452 throw std::runtime_error( oss.str() );
453 }
454 }
455 }
456 //*************************************************************************************************
457
458
459 //*************************************************************************************************
460 /*!\brief Test of the VectorAccessProxy subtraction assignment operators.
461 //
462 // \return void
463 // \exception std::runtime_error Error detected.
464 //
465 // This function performs a test of the subtraction assignment operators of the VectorAccessProxy
466 // class template. In case an error is detected, a \a std::runtime_error exception is thrown.
467 */
testSubAssign()468 void ProxyTest::testSubAssign()
469 {
470 //=====================================================================================
471 // Dense vector subtraction assignment
472 //=====================================================================================
473
474 {
475 test_ = "VectorAccessProxy dense vector subtraction assignment";
476
477 DV tmp( 3UL );
478 tmp[0] = 1;
479 tmp[1] = 2;
480 tmp[2] = 3;
481 DVV vec( 3UL, 1UL );
482 vec[1] = tmp;
483
484 vec[1] -= tmp;
485
486 checkSize ( vec, 3UL );
487 checkCapacity( vec, 1UL );
488 checkNonZeros( vec, 1UL );
489
490 checkSize ( vec[0], 0UL );
491 checkSize ( vec[1], 3UL );
492 checkCapacity( vec[1], 3UL );
493 checkNonZeros( vec[1], 0UL );
494 checkSize ( vec[2], 0UL );
495
496 if( vec[1][0] != 0 || vec[1][1] != 0 || vec[1][2] != 0 ) {
497 std::ostringstream oss;
498 oss << " Test: " << test_ << "\n"
499 << " Error: Assignment failed\n"
500 << " Details:\n"
501 << " Result:\n" << vec[1] << "\n"
502 << " Expected result:\n( 0 0 0 )\n";
503 throw std::runtime_error( oss.str() );
504 }
505 }
506
507
508 //=====================================================================================
509 // Sparse vector subtraction assignment
510 //=====================================================================================
511
512 {
513 test_ = "VectorAccessProxy sparse vector subtraction assignment";
514
515 SV tmp( 3UL );
516 tmp[1] = 2;
517 DVV vec( 3UL, 1UL );
518 vec[1] = tmp;
519
520 vec[1] -= tmp;
521
522 checkSize ( vec, 3UL );
523 checkCapacity( vec, 1UL );
524 checkNonZeros( vec, 1UL );
525
526 checkSize ( vec[0], 0UL );
527 checkSize ( vec[1], 3UL );
528 checkCapacity( vec[1], 1UL );
529 checkNonZeros( vec[1], 0UL );
530 checkSize ( vec[2], 0UL );
531
532 if( vec[1][0] != 0 || vec[1][1] != 0 || vec[1][2] != 0 ) {
533 std::ostringstream oss;
534 oss << " Test: " << test_ << "\n"
535 << " Error: Assignment failed\n"
536 << " Details:\n"
537 << " Result:\n" << vec[1] << "\n"
538 << " Expected result:\n( 0 0 0 )\n";
539 throw std::runtime_error( oss.str() );
540 }
541 }
542 }
543 //*************************************************************************************************
544
545
546 //*************************************************************************************************
547 /*!\brief Test of the VectorAccessProxy multiplication assignment operators.
548 //
549 // \return void
550 // \exception std::runtime_error Error detected.
551 //
552 // This function performs a test of the multiplication assignment operators of the VectorAccessProxy
553 // class template. In case an error is detected, a \a std::runtime_error exception is thrown.
554 */
testMultAssign()555 void ProxyTest::testMultAssign()
556 {
557 //=====================================================================================
558 // Dense vector multiplication assignment
559 //=====================================================================================
560
561 {
562 test_ = "VectorAccessProxy dense vector multiplication assignment";
563
564 DV tmp( 3UL );
565 tmp[0] = 1;
566 tmp[1] = 2;
567 tmp[2] = 3;
568 DVV vec( 3UL, 1UL );
569 vec[1] = tmp;
570
571 vec[1] *= tmp;
572
573 checkSize ( vec, 3UL );
574 checkCapacity( vec, 1UL );
575 checkNonZeros( vec, 1UL );
576
577 checkSize ( vec[0], 0UL );
578 checkSize ( vec[1], 3UL );
579 checkCapacity( vec[1], 3UL );
580 checkNonZeros( vec[1], 3UL );
581 checkSize ( vec[2], 0UL );
582
583 if( vec[1][0] != 1 || vec[1][1] != 4 || vec[1][2] != 9 ) {
584 std::ostringstream oss;
585 oss << " Test: " << test_ << "\n"
586 << " Error: Assignment failed\n"
587 << " Details:\n"
588 << " Result:\n" << vec[1] << "\n"
589 << " Expected result:\n( 1 4 9 )\n";
590 throw std::runtime_error( oss.str() );
591 }
592 }
593
594
595 //=====================================================================================
596 // Sparse vector multiplication assignment
597 //=====================================================================================
598
599 {
600 test_ = "VectorAccessProxy sparse vector multiplication assignment";
601
602 SV tmp( 3UL );
603 tmp[1] = 2;
604 DVV vec( 3UL, 1UL );
605 vec[1] = tmp;
606
607 vec[1] *= tmp;
608
609 checkSize ( vec, 3UL );
610 checkCapacity( vec, 1UL );
611 checkNonZeros( vec, 1UL );
612
613 checkSize ( vec[0], 0UL );
614 checkSize ( vec[1], 3UL );
615 checkCapacity( vec[1], 3UL );
616 checkNonZeros( vec[1], 1UL );
617 checkSize ( vec[2], 0UL );
618
619 if( vec[1][0] != 0 || vec[1][1] != 4 || vec[1][2] != 0 ) {
620 std::ostringstream oss;
621 oss << " Test: " << test_ << "\n"
622 << " Error: Assignment failed\n"
623 << " Details:\n"
624 << " Result:\n" << vec[1] << "\n"
625 << " Expected result:\n( 0 4 0 )\n";
626 throw std::runtime_error( oss.str() );
627 }
628 }
629 }
630 //*************************************************************************************************
631
632
633 //*************************************************************************************************
634 /*!\brief Test of the VectorAccessProxy division assignment operators.
635 //
636 // \return void
637 // \exception std::runtime_error Error detected.
638 //
639 // This function performs a test of the division assignment operators of the VectorAccessProxy
640 // class template. In case an error is detected, a \a std::runtime_error exception is thrown.
641 */
testDivAssign()642 void ProxyTest::testDivAssign()
643 {
644 //=====================================================================================
645 // Dense vector division assignment
646 //=====================================================================================
647
648 {
649 test_ = "VectorAccessProxy dense vector division assignment";
650
651 DV tmp( 3UL );
652 tmp[0] = 1;
653 tmp[1] = 2;
654 tmp[2] = 3;
655 DVV vec( 3UL, 1UL );
656 vec[1] = tmp;
657
658 vec[1] /= tmp;
659
660 checkSize ( vec, 3UL );
661 checkCapacity( vec, 1UL );
662 checkNonZeros( vec, 1UL );
663
664 checkSize ( vec[0], 0UL );
665 checkSize ( vec[1], 3UL );
666 checkCapacity( vec[1], 3UL );
667 checkNonZeros( vec[1], 3UL );
668 checkSize ( vec[2], 0UL );
669
670 if( vec[1][0] != 1 || vec[1][1] != 1 || vec[1][2] != 1 ) {
671 std::ostringstream oss;
672 oss << " Test: " << test_ << "\n"
673 << " Error: Assignment failed\n"
674 << " Details:\n"
675 << " Result:\n" << vec[1] << "\n"
676 << " Expected result:\n( 1 1 1 )\n";
677 throw std::runtime_error( oss.str() );
678 }
679 }
680 }
681 //*************************************************************************************************
682
683
684 //*************************************************************************************************
685 /*!\brief Test of the VectorAccessProxy modulo assignment operators.
686 //
687 // \return void
688 // \exception std::runtime_error Error detected.
689 //
690 // This function performs a test of the modulo assignment operators of the VectorAccessProxy
691 // class template. In case an error is detected, a \a std::runtime_error exception is thrown.
692 */
testModAssign()693 void ProxyTest::testModAssign()
694 {
695 //=====================================================================================
696 // Dense vector cross product assignment
697 //=====================================================================================
698
699 {
700 test_ = "VectorAccessProxy dense vector cross product assignment";
701
702 DV tmp( 3UL );
703 tmp[0] = 1;
704 tmp[1] = 2;
705 tmp[2] = 3;
706 DVV vec( 3UL, 1UL );
707 vec[1] = tmp;
708
709 vec[1] %= tmp;
710
711 checkSize ( vec, 3UL );
712 checkCapacity( vec, 1UL );
713 checkNonZeros( vec, 1UL );
714
715 checkSize ( vec[0], 0UL );
716 checkSize ( vec[1], 3UL );
717 checkCapacity( vec[1], 3UL );
718 checkNonZeros( vec[1], 0UL );
719 checkSize ( vec[2], 0UL );
720
721 if( vec[1][0] != 0 || vec[1][1] != 0 || vec[1][2] != 0 ) {
722 std::ostringstream oss;
723 oss << " Test: " << test_ << "\n"
724 << " Error: Assignment failed\n"
725 << " Details:\n"
726 << " Result:\n" << vec[1] << "\n"
727 << " Expected result:\n( 0 0 0 )\n";
728 throw std::runtime_error( oss.str() );
729 }
730 }
731
732
733 //=====================================================================================
734 // Sparse vector cross product assignment
735 //=====================================================================================
736
737 {
738 test_ = "VectorAccessProxy sparse vector cross product assignment";
739
740 SV tmp( 3UL );
741 tmp[1] = 2;
742 DVV vec( 3UL, 1UL );
743 vec[1] = tmp;
744
745 vec[1] %= tmp;
746
747 checkSize ( vec, 3UL );
748 checkCapacity( vec, 1UL );
749 checkNonZeros( vec, 1UL );
750
751 checkSize ( vec[0], 0UL );
752 checkSize ( vec[1], 3UL );
753 checkCapacity( vec[1], 1UL );
754 checkNonZeros( vec[1], 0UL );
755 checkSize ( vec[2], 0UL );
756
757 if( vec[1][0] != 0 || vec[1][1] != 0 || vec[1][2] != 0 ) {
758 std::ostringstream oss;
759 oss << " Test: " << test_ << "\n"
760 << " Error: Assignment failed\n"
761 << " Details:\n"
762 << " Result:\n" << vec[1] << "\n"
763 << " Expected result:\n( 0 0 0 )\n";
764 throw std::runtime_error( oss.str() );
765 }
766 }
767 }
768 //*************************************************************************************************
769
770
771 //*************************************************************************************************
772 /*!\brief Test of all VectorAccessProxy (self-)scaling operations.
773 //
774 // \return void
775 // \exception std::runtime_error Error detected.
776 //
777 // This function performs a test of all available ways to scale an instance of the VectorAccessProxy
778 // class template. In case an error is detected, a \a std::runtime_error exception is thrown.
779 */
testScaling()780 void ProxyTest::testScaling()
781 {
782 //=====================================================================================
783 // Self-scaling (v*=s)
784 //=====================================================================================
785
786 {
787 test_ = "VectorAccessProxy self-scaling (v*=s)";
788
789 DVV vec( 3UL, 1UL );
790 vec[1] = DV( 1UL, 2 );
791
792 vec[1] *= 2;
793
794 checkSize ( vec, 3UL );
795 checkCapacity( vec, 1UL );
796 checkNonZeros( vec, 1UL );
797
798 checkSize ( vec[0], 0UL );
799 checkSize ( vec[1], 1UL );
800 checkCapacity( vec[1], 1UL );
801 checkNonZeros( vec[1], 1UL );
802 checkSize ( vec[2], 0UL );
803
804 if( vec[1][0] != 4 ) {
805 std::ostringstream oss;
806 oss << " Test: " << test_ << "\n"
807 << " Error: Failed self-scaling operation\n"
808 << " Details:\n"
809 << " Result:\n" << vec[1] << "\n"
810 << " Expected result:\n( 4 )\n";
811 throw std::runtime_error( oss.str() );
812 }
813 }
814
815
816 //=====================================================================================
817 // Self-scaling (v/=s)
818 //=====================================================================================
819
820 {
821 test_ = "VectorAccessProxy self-scaling (v/=s)";
822
823 DVV vec( 3UL, 1UL );
824 vec[1] = DV( 1UL, 2 );
825
826 vec[1] /= 2;
827
828 checkSize ( vec, 3UL );
829 checkCapacity( vec, 1UL );
830 checkNonZeros( vec, 1UL );
831
832 checkSize ( vec[0], 0UL );
833 checkSize ( vec[1], 1UL );
834 checkCapacity( vec[1], 1UL );
835 checkNonZeros( vec[1], 1UL );
836 checkSize ( vec[2], 0UL );
837
838 if( vec[1][0] != 1 ) {
839 std::ostringstream oss;
840 oss << " Test: " << test_ << "\n"
841 << " Error: Failed self-scaling operation\n"
842 << " Details:\n"
843 << " Result:\n" << vec[1] << "\n"
844 << " Expected result:\n( 1 )\n";
845 throw std::runtime_error( oss.str() );
846 }
847 }
848
849
850 //=====================================================================================
851 // VectorAccessProxy::scale()
852 //=====================================================================================
853
854 {
855 test_ = "VectorAccessProxy::scale()";
856
857 DVV vec( 3UL, 1UL );
858 vec[1] = DV( 1UL, 2 );
859
860 vec[1].scale( 2 );
861
862 checkSize ( vec, 3UL );
863 checkCapacity( vec, 1UL );
864 checkNonZeros( vec, 1UL );
865
866 checkSize ( vec[0], 0UL );
867 checkSize ( vec[1], 1UL );
868 checkCapacity( vec[1], 1UL );
869 checkNonZeros( vec[1], 1UL );
870 checkSize ( vec[2], 0UL );
871
872 if( vec[1][0] != 4 ) {
873 std::ostringstream oss;
874 oss << " Test: " << test_ << "\n"
875 << " Error: Failed self-scaling operation\n"
876 << " Details:\n"
877 << " Result:\n" << vec[1] << "\n"
878 << " Expected result:\n( 4 )\n";
879 throw std::runtime_error( oss.str() );
880 }
881 }
882 }
883 //*************************************************************************************************
884
885
886 //*************************************************************************************************
887 /*!\brief Test of the VectorAccessProxy subscript operator.
888 //
889 // \return void
890 // \exception std::runtime_error Error detected.
891 //
892 // This function performs a test of adding and accessing elements via the subscript operator
893 // of the VectorAccessProxy class template. In case an error is detected, a \a std::runtime_error
894 // exception is thrown.
895 */
testSubscript()896 void ProxyTest::testSubscript()
897 {
898 test_ = "VectorAccessProxy::operator[]";
899
900 DVV vec( 3UL, 1UL );
901 vec[1] = DV( 1UL, 2 );
902 vec[1][0] = 3;
903
904 checkSize ( vec, 3UL );
905 checkCapacity( vec, 1UL );
906 checkNonZeros( vec, 1UL );
907
908 checkSize ( vec[0], 0UL );
909 checkSize ( vec[1], 1UL );
910 checkCapacity( vec[1], 1UL );
911 checkNonZeros( vec[1], 1UL );
912 checkSize ( vec[2], 0UL );
913
914 if( vec[1][0] != DV( 1UL, 3 ) ) {
915 std::ostringstream oss;
916 oss << " Test: " << test_ << "\n"
917 << " Error: Subscript operator failed\n"
918 << " Details:\n"
919 << " Result:\n" << vec[1] << "\n"
920 << " Expected result:\n( 3 )\n";
921 throw std::runtime_error( oss.str() );
922 }
923 }
924 //*************************************************************************************************
925
926
927 //*************************************************************************************************
928 /*!\brief Test of the VectorAccessProxy function call operator.
929 //
930 // \return void
931 // \exception std::runtime_error Error detected.
932 //
933 // This function performs a test of adding and accessing elements via the function call operator
934 // of the VectorAccessProxy class template. In case an error is detected, a \a std::runtime_error
935 // exception is thrown.
936 */
testFunctionCall()937 void ProxyTest::testFunctionCall()
938 {
939 test_ = "VectorAccessProxy::operator()";
940
941 DMV vec( 3UL, 1UL );
942 vec[1] = DM( 1UL, 1UL, 2 );
943 vec[1](0,0) = 3;
944
945 checkSize ( vec, 3UL );
946 checkCapacity( vec, 1UL );
947 checkNonZeros( vec, 1UL );
948
949 checkRows ( vec[0], 0UL );
950 checkColumns ( vec[0], 0UL );
951 checkRows ( vec[1], 1UL );
952 checkColumns ( vec[1], 1UL );
953 checkCapacity( vec[1], 1UL );
954 checkNonZeros( vec[1], 1UL );
955 checkRows ( vec[2], 0UL );
956 checkColumns ( vec[2], 0UL );
957
958 if( vec[1](0,0) != DM( 1UL, 1UL, 3 ) ) {
959 std::ostringstream oss;
960 oss << " Test: " << test_ << "\n"
961 << " Error: Function call operator failed\n"
962 << " Details:\n"
963 << " Result:\n" << vec[1] << "\n"
964 << " Expected result:\n( 3 )\n";
965 throw std::runtime_error( oss.str() );
966 }
967 }
968 //*************************************************************************************************
969
970
971 //*************************************************************************************************
972 /*!\brief Test of the VectorAccessProxy iterator implementation.
973 //
974 // \return void
975 // \exception std::runtime_error Error detected.
976 //
977 // This function performs a test of the iterator implementation of the VectorAccessProxy class
978 // template. In case an error is detected, a \a std::runtime_error exception is thrown.
979 */
testIterator()980 void ProxyTest::testIterator()
981 {
982 //=====================================================================================
983 // Vector elements
984 //=====================================================================================
985
986 {
987 DVV vec( 3UL, 1UL );
988 vec[1] = DV( 4UL, 4 );
989
990 // Counting the number of elements via Iterator (end-begin)
991 {
992 test_ = "VectorAccessProxy::begin() and VectorAccessProxy::end()";
993
994 const ptrdiff_t number( end( vec[1] ) - begin( vec[1] ) );
995
996 if( number != 4L ) {
997 std::ostringstream oss;
998 oss << " Test: " << test_ << "\n"
999 << " Error: Invalid number of elements detected\n"
1000 << " Details:\n"
1001 << " Number of elements : " << number << "\n"
1002 << " Expected number of elements: 4\n";
1003 throw std::runtime_error( oss.str() );
1004 }
1005 }
1006
1007 // Counting the number of elements via ConstIterator (end-begin)
1008 {
1009 test_ = "VectorAccessProxy::cbegin() and VectorAccessProxy::cend()";
1010
1011 const ptrdiff_t number( cend( vec[1] ) - cbegin( vec[1] ) );
1012
1013 if( number != 4L ) {
1014 std::ostringstream oss;
1015 oss << " Test: " << test_ << "\n"
1016 << " Error: Invalid number of elements detected\n"
1017 << " Details:\n"
1018 << " Number of elements : " << number << "\n"
1019 << " Expected number of elements: 4\n";
1020 throw std::runtime_error( oss.str() );
1021 }
1022 }
1023 }
1024
1025
1026 //=====================================================================================
1027 // Matrix elements
1028 //=====================================================================================
1029
1030 {
1031 DMV vec( 3UL, 1UL );
1032 vec[1] = DM( 4UL, 4UL, 4 );
1033
1034 // Counting the number of elements via Iterator (end-begin)
1035 {
1036 test_ = "VectorAccessProxy::begin( size_t ) and VectorAccessProxy::end( size_t )";
1037
1038 const ptrdiff_t number( end( vec[1], 1UL ) - begin( vec[1], 1UL ) );
1039
1040 if( number != 4L ) {
1041 std::ostringstream oss;
1042 oss << " Test: " << test_ << "\n"
1043 << " Error: Invalid number of elements detected\n"
1044 << " Details:\n"
1045 << " Number of elements : " << number << "\n"
1046 << " Expected number of elements: 4\n";
1047 throw std::runtime_error( oss.str() );
1048 }
1049 }
1050
1051 // Counting the number of elements via ConstIterator (end-begin)
1052 {
1053 test_ = "VectorAccessProxy::cbegin( size_t ) and VectorAccessProxy::cend( size_t )";
1054
1055 const ptrdiff_t number( cend( vec[1], 1UL ) - cbegin( vec[1], 1UL ) );
1056
1057 if( number != 4L ) {
1058 std::ostringstream oss;
1059 oss << " Test: " << test_ << "\n"
1060 << " Error: Invalid number of elements detected\n"
1061 << " Details:\n"
1062 << " Number of elements : " << number << "\n"
1063 << " Expected number of elements: 4\n";
1064 throw std::runtime_error( oss.str() );
1065 }
1066 }
1067 }
1068 }
1069 //*************************************************************************************************
1070
1071
1072 //*************************************************************************************************
1073 /*!\brief Test of the \c nonZeros() member functions of the VectorAccessProxy class template.
1074 //
1075 // \return void
1076 // \exception std::runtime_error Error detected.
1077 //
1078 // This function performs a test of the \c nonZeros() member functions of the VectorAccessProxy
1079 // class template. In case an error is detected, a \a std::runtime_error exception is thrown.
1080 */
testNonZeros()1081 void ProxyTest::testNonZeros()
1082 {
1083 //=====================================================================================
1084 // Vector elements
1085 //=====================================================================================
1086
1087 {
1088 test_ = "VectorAccessProxy::nonZeros()";
1089
1090 DVV vec( 3UL, 1UL );
1091 vec[1] = DV( 8UL, 8 );
1092
1093 checkSize ( vec, 3UL );
1094 checkCapacity( vec, 1UL );
1095 checkNonZeros( vec, 1UL );
1096
1097 checkSize ( vec[0], 0UL );
1098 checkSize ( vec[1], 8UL );
1099 checkCapacity( vec[1], 8UL );
1100 checkNonZeros( vec[1], 8UL );
1101 checkSize ( vec[2], 0UL );
1102 }
1103
1104
1105 //=====================================================================================
1106 // Matrix elements
1107 //=====================================================================================
1108
1109 {
1110 test_ = "VectorAccessProxy::nonZeros( size_t )";
1111
1112 DMV vec( 3UL, 1UL );
1113 vec[1] = DM( 3UL, 3UL, 3 );
1114
1115 checkSize ( vec, 3UL );
1116 checkCapacity( vec, 1UL );
1117 checkNonZeros( vec, 1UL );
1118
1119 checkRows ( vec[0], 0UL );
1120 checkColumns ( vec[0], 0UL );
1121 checkRows ( vec[1], 3UL );
1122 checkColumns ( vec[1], 3UL );
1123 checkCapacity( vec[1], 9UL );
1124 checkNonZeros( vec[1], 0UL, 3UL );
1125 checkNonZeros( vec[1], 1UL, 3UL );
1126 checkNonZeros( vec[1], 2UL, 3UL );
1127 checkRows ( vec[2], 0UL );
1128 checkColumns ( vec[2], 0UL );
1129 }
1130 }
1131 //*************************************************************************************************
1132
1133
1134 //*************************************************************************************************
1135 /*!\brief Test of the \c reset() member functions of the VectorAccessProxy class template.
1136 //
1137 // \return void
1138 // \exception std::runtime_error Error detected.
1139 //
1140 // This function performs a test of the \c reset() member functions of the VectorAccessProxy
1141 // class template. In case an error is detected, a \a std::runtime_error exception is thrown.
1142 */
testReset()1143 void ProxyTest::testReset()
1144 {
1145 //=====================================================================================
1146 // Vector elements
1147 //=====================================================================================
1148
1149 {
1150 test_ = "VectorAccessProxy::reset()";
1151
1152 DVV vec( 3UL, 1UL );
1153 vec[1] = DV( 8UL, 8 );
1154 vec[1].reset();
1155
1156 checkSize ( vec, 3UL );
1157 checkCapacity( vec, 1UL );
1158 checkNonZeros( vec, 1UL );
1159
1160 checkSize ( vec[0], 0UL );
1161 checkSize ( vec[1], 8UL );
1162 checkCapacity( vec[1], 8UL );
1163 checkNonZeros( vec[1], 0UL );
1164 checkSize ( vec[2], 0UL );
1165 }
1166
1167
1168 //=====================================================================================
1169 // Matrix elements
1170 //=====================================================================================
1171
1172 {
1173 test_ = "VectorAccessProxy::reset( size_t )";
1174
1175 DMV vec( 3UL, 1UL );
1176 vec[1] = DM( 3UL, 3UL, 3 );
1177 vec[1].reset( 1UL );
1178
1179 checkSize ( vec, 3UL );
1180 checkCapacity( vec, 1UL );
1181 checkNonZeros( vec, 1UL );
1182
1183 checkRows ( vec[0], 0UL );
1184 checkColumns ( vec[0], 0UL );
1185 checkRows ( vec[1], 3UL );
1186 checkColumns ( vec[1], 3UL );
1187 checkCapacity( vec[1], 9UL );
1188 checkNonZeros( vec[1], 6UL );
1189 checkNonZeros( vec[1], 0UL, 3UL );
1190 checkNonZeros( vec[1], 1UL, 0UL );
1191 checkNonZeros( vec[1], 2UL, 3UL );
1192 checkRows ( vec[2], 0UL );
1193 checkColumns ( vec[2], 0UL );
1194 }
1195 }
1196 //*************************************************************************************************
1197
1198
1199 //*************************************************************************************************
1200 /*!\brief Test of the \c clear() member function of the VectorAccessProxy class template.
1201 //
1202 // \return void
1203 // \exception std::runtime_error Error detected.
1204 //
1205 // This function performs a test of the \c clear() member function of the VectorAccessProxy
1206 // class template. In case an error is detected, a \a std::runtime_error exception is thrown.
1207 */
testClear()1208 void ProxyTest::testClear()
1209 {
1210 test_ = "VectorAccessProxy::clear()";
1211
1212 DVV vec( 3UL, 1UL );
1213 vec[1] = DV( 8UL, 8 );
1214 vec[1].clear();
1215
1216 checkSize ( vec, 3UL );
1217 checkCapacity( vec, 1UL );
1218 checkNonZeros( vec, 0UL );
1219
1220 checkSize( vec[0], 0UL );
1221 checkSize( vec[1], 0UL );
1222 checkSize( vec[2], 0UL );
1223 }
1224 //*************************************************************************************************
1225
1226
1227 //*************************************************************************************************
1228 /*!\brief Test of the \c resize() member functions of the VectorAccessProxy class template.
1229 //
1230 // \return void
1231 // \exception std::runtime_error Error detected.
1232 //
1233 // This function performs a test of the \c resize() member functions of the VectorAccessProxy
1234 // class template. In case an error is detected, a \a std::runtime_error exception is thrown.
1235 */
testResize()1236 void ProxyTest::testResize()
1237 {
1238 //=====================================================================================
1239 // Vector elements
1240 //=====================================================================================
1241
1242 {
1243 test_ = "VectorAccessProxy::resize( size_t )";
1244
1245 DVV vec( 3UL, 1UL );
1246 vec[1].resize( 10UL );
1247
1248 checkSize ( vec, 3UL );
1249 checkCapacity( vec, 1UL );
1250 checkNonZeros( vec, 1UL );
1251
1252 checkSize ( vec[0], 0UL );
1253 checkSize ( vec[1], 10UL );
1254 checkCapacity( vec[1], 10UL );
1255 checkSize ( vec[2], 0UL );
1256 }
1257
1258 {
1259 test_ = "resize( VectorAccessProxy, size_t )";
1260
1261 DVV vec( 3UL, 1UL );
1262 resize( vec[1], 10UL );
1263
1264 checkSize ( vec, 3UL );
1265 checkCapacity( vec, 1UL );
1266 checkNonZeros( vec, 1UL );
1267
1268 checkSize ( vec[0], 0UL );
1269 checkSize ( vec[1], 10UL );
1270 checkCapacity( vec[1], 10UL );
1271 checkSize ( vec[2], 0UL );
1272 }
1273
1274
1275 //=====================================================================================
1276 // Matrix elements
1277 //=====================================================================================
1278
1279 {
1280 test_ = "VectorAccessProxy::resize( size_t, size_t )";
1281
1282 DMV vec( 3UL, 1UL );
1283 vec[1].resize( 5UL, 5UL );
1284
1285 checkSize ( vec, 3UL );
1286 checkCapacity( vec, 1UL );
1287 checkNonZeros( vec, 1UL );
1288
1289 checkRows ( vec[0], 0UL );
1290 checkColumns ( vec[0], 0UL );
1291 checkRows ( vec[1], 5UL );
1292 checkColumns ( vec[1], 5UL );
1293 checkCapacity( vec[1], 25UL );
1294 checkRows ( vec[2], 0UL );
1295 checkColumns ( vec[2], 0UL );
1296 }
1297
1298 {
1299 test_ = "resize( VectorAccessProxy, size_t, size_t )";
1300
1301 DMV vec( 3UL, 1UL );
1302 resize( vec[1], 5UL, 5UL );
1303
1304 checkSize ( vec, 3UL );
1305 checkCapacity( vec, 1UL );
1306 checkNonZeros( vec, 1UL );
1307
1308 checkRows ( vec[0], 0UL );
1309 checkColumns ( vec[0], 0UL );
1310 checkRows ( vec[1], 5UL );
1311 checkColumns ( vec[1], 5UL );
1312 checkCapacity( vec[1], 25UL );
1313 checkRows ( vec[2], 0UL );
1314 checkColumns ( vec[2], 0UL );
1315 }
1316 }
1317 //*************************************************************************************************
1318
1319
1320 //*************************************************************************************************
1321 /*!\brief Test of the \c extend() member functions of the VectorAccessProxy class template.
1322 //
1323 // \return void
1324 // \exception std::runtime_error Error detected.
1325 //
1326 // This function performs a test of the \c extend() member functions of the VectorAccessProxy
1327 // class template. In case an error is detected, a \a std::runtime_error exception is thrown.
1328 */
testExtend()1329 void ProxyTest::testExtend()
1330 {
1331 //=====================================================================================
1332 // Vector elements
1333 //=====================================================================================
1334
1335 {
1336 test_ = "VectorAccessProxy::extend( size_t )";
1337
1338 DVV vec( 3UL, 1UL );
1339 vec[1].extend( 10UL );
1340
1341 checkSize ( vec, 3UL );
1342 checkCapacity( vec, 1UL );
1343 checkNonZeros( vec, 1UL );
1344
1345 checkSize ( vec[0], 0UL );
1346 checkSize ( vec[1], 10UL );
1347 checkCapacity( vec[1], 10UL );
1348 checkSize ( vec[2], 0UL );
1349 }
1350
1351
1352 //=====================================================================================
1353 // Matrix elements
1354 //=====================================================================================
1355
1356 {
1357 test_ = "VectorAccessProxy::extend( size_t, size_t )";
1358
1359 DMV vec( 3UL, 1UL );
1360 vec[1].extend( 5UL, 5UL );
1361
1362 checkSize ( vec, 3UL );
1363 checkCapacity( vec, 1UL );
1364 checkNonZeros( vec, 1UL );
1365
1366 checkRows ( vec[0], 0UL );
1367 checkColumns ( vec[0], 0UL );
1368 checkRows ( vec[1], 5UL );
1369 checkColumns ( vec[1], 5UL );
1370 checkCapacity( vec[1], 25UL );
1371 checkRows ( vec[2], 0UL );
1372 checkColumns ( vec[2], 0UL );
1373 }
1374 }
1375 //*************************************************************************************************
1376
1377
1378 //*************************************************************************************************
1379 /*!\brief Test of the \c reserve() member functions of the VectorAccessProxy class template.
1380 //
1381 // \return void
1382 // \exception std::runtime_error Error detected.
1383 //
1384 // This function performs a test of the \c reserve() member functions of the VectorAccessProxy
1385 // class template. In case an error is detected, a \a std::runtime_error exception is thrown.
1386 */
testReserve()1387 void ProxyTest::testReserve()
1388 {
1389 //=====================================================================================
1390 // Vector elements
1391 //=====================================================================================
1392
1393 {
1394 test_ = "VectorAccessProxy::reserve( size_t )";
1395
1396 DVV vec( 3UL, 1UL );
1397 vec[0].resize( 5UL );
1398 vec[0].reserve( 10UL );
1399
1400 checkSize ( vec, 3UL );
1401 checkCapacity( vec, 1UL );
1402 checkNonZeros( vec, 1UL );
1403
1404 checkSize ( vec[0], 5UL );
1405 checkCapacity( vec[0], 10UL );
1406 checkSize ( vec[1], 0UL );
1407 checkSize ( vec[2], 0UL );
1408 }
1409
1410
1411 //=====================================================================================
1412 // Matrix elements
1413 //=====================================================================================
1414
1415 {
1416 test_ = "VectorAccessProxy::reserve( size_t, size_t )";
1417
1418 SMV vec( 3UL, 1UL );
1419 vec[0] = SM( 2UL, 2UL, 1UL );
1420 vec[0].reserve( 0UL, 1UL );
1421
1422 checkSize ( vec, 3UL );
1423 checkCapacity( vec, 1UL );
1424 checkNonZeros( vec, 1UL );
1425
1426 checkRows ( vec[0], 2UL );
1427 checkColumns ( vec[0], 2UL );
1428 checkCapacity( vec[0], 1UL );
1429 checkCapacity( vec[0], 0UL, 1UL );
1430 checkCapacity( vec[0], 0UL, 0UL );
1431 checkRows ( vec[1], 0UL );
1432 checkColumns ( vec[1], 0UL );
1433 checkRows ( vec[2], 0UL );
1434 checkColumns ( vec[2], 0UL );
1435 }
1436 }
1437 //*************************************************************************************************
1438
1439
1440 //*************************************************************************************************
1441 /*!\brief Test of the \c trim() member functions of the VectorAccessProxy class template.
1442 //
1443 // \return void
1444 // \exception std::runtime_error Error detected.
1445 //
1446 // This function performs a test of the \c trim() member functions of the VectorAccessProxy
1447 // class template. In case an error is detected, a \a std::runtime_error exception is thrown.
1448 */
testTrim()1449 void ProxyTest::testTrim()
1450 {
1451 {
1452 test_ = "VectorAccessProxy::trim()";
1453
1454 SMV vec( 3UL, 3UL );
1455 vec[0].resize( 2UL, 2UL );
1456 vec[0].reserve( 10UL );
1457 vec[0].reserve( 0UL, 6UL );
1458 vec[0].reserve( 1UL, 4UL );
1459
1460 checkSize ( vec, 3UL );
1461 checkCapacity( vec, 3UL );
1462 checkNonZeros( vec, 1UL );
1463
1464 checkRows ( vec[0], 2UL );
1465 checkColumns ( vec[0], 2UL );
1466 checkCapacity( vec[0], 10UL );
1467 checkCapacity( vec[0], 0UL, 6UL );
1468 checkCapacity( vec[0], 1UL, 4UL );
1469 checkRows ( vec[1], 0UL );
1470 checkColumns ( vec[1], 0UL );
1471 checkRows ( vec[2], 0UL );
1472 checkColumns ( vec[2], 0UL );
1473
1474 vec[0].trim();
1475
1476 checkSize ( vec, 3UL );
1477 checkCapacity( vec, 3UL );
1478 checkNonZeros( vec, 1UL );
1479
1480 checkRows ( vec[0], 2UL );
1481 checkColumns ( vec[0], 2UL );
1482 checkCapacity( vec[0], 10UL );
1483 checkCapacity( vec[0], 0UL, 0UL );
1484 checkCapacity( vec[0], 1UL, 0UL );
1485 checkRows ( vec[1], 0UL );
1486 checkColumns ( vec[1], 0UL );
1487 checkRows ( vec[2], 0UL );
1488 checkColumns ( vec[2], 0UL );
1489 }
1490
1491 {
1492 test_ = "VectorAccessProxy::trim( size_t )";
1493
1494 SMV vec( 3UL, 3UL );
1495 vec[0].resize( 2UL, 2UL );
1496 vec[0].reserve( 10UL );
1497 vec[0].reserve( 0UL, 6UL );
1498 vec[0].reserve( 1UL, 4UL );
1499
1500 checkSize ( vec, 3UL );
1501 checkCapacity( vec, 1UL );
1502 checkNonZeros( vec, 1UL );
1503
1504 checkRows ( vec[0], 2UL );
1505 checkColumns ( vec[0], 2UL );
1506 checkCapacity( vec[0], 10UL );
1507 checkCapacity( vec[0], 0UL, 6UL );
1508 checkCapacity( vec[0], 1UL, 4UL );
1509 checkRows ( vec[1], 0UL );
1510 checkColumns ( vec[1], 0UL );
1511 checkRows ( vec[2], 0UL );
1512 checkColumns ( vec[2], 0UL );
1513
1514 vec[0].trim( 0UL );
1515
1516 checkSize ( vec, 3UL );
1517 checkCapacity( vec, 1UL );
1518 checkNonZeros( vec, 1UL );
1519
1520 checkRows ( vec[0], 2UL );
1521 checkColumns ( vec[0], 2UL );
1522 checkCapacity( vec[0], 10UL );
1523 checkCapacity( vec[0], 0UL, 0UL );
1524 checkCapacity( vec[0], 1UL, 4UL );
1525 checkRows ( vec[1], 0UL );
1526 checkColumns ( vec[1], 0UL );
1527 checkRows ( vec[2], 0UL );
1528 checkColumns ( vec[2], 0UL );
1529 }
1530 }
1531 //*************************************************************************************************
1532
1533
1534 //*************************************************************************************************
1535 /*!\brief Test of the \c swap() functionality of the VectorAccessProxy class template.
1536 //
1537 // \return void
1538 // \exception std::runtime_error Error detected.
1539 //
1540 // This function performs a test of the \c swap() function of the VectorAccessProxy class
1541 // template. In case an error is detected, a \a std::runtime_error exception is thrown.
1542 */
testSwap()1543 void ProxyTest::testSwap()
1544 {
1545 test_ = "VectorAccessProxy swap";
1546
1547 {
1548 DVV vec( 3UL, 2UL );
1549 vec[0].resize( 2UL );
1550 vec[0] = 0;
1551 vec[2].resize( 6UL );
1552 vec[2] = 0;
1553
1554 swap( vec[0], vec[2] );
1555
1556 checkSize ( vec, 3UL );
1557 checkCapacity( vec, 2UL );
1558 checkNonZeros( vec, 2UL );
1559
1560 checkSize ( vec[0], 6UL );
1561 checkCapacity( vec[0], 6UL );
1562 checkNonZeros( vec[0], 0UL );
1563 checkSize ( vec[1], 0UL );
1564 checkSize ( vec[2], 2UL );
1565 checkCapacity( vec[2], 2UL );
1566 checkNonZeros( vec[2], 0UL );
1567 }
1568
1569 {
1570 DVV vec( 3UL, 1UL );
1571 vec[1] = DV( 2UL, 2 );
1572 DV tmp( 6UL, 6 );
1573
1574 swap( vec[1], tmp );
1575
1576 checkSize ( vec, 3UL );
1577 checkCapacity( vec, 1UL );
1578 checkNonZeros( vec, 1UL );
1579
1580 checkSize ( vec[0], 0UL );
1581 checkSize ( vec[1], 6UL );
1582 checkCapacity( vec[1], 6UL );
1583 checkNonZeros( vec[1], 6UL );
1584 checkSize ( vec[2], 0UL );
1585 checkSize ( tmp , 2UL );
1586 checkCapacity( tmp , 2UL );
1587 checkNonZeros( tmp , 2UL );
1588 }
1589
1590 {
1591 DVV vec( 3UL, 1UL );
1592 vec[1] = DV( 2UL, 2 );
1593 DV tmp( 6UL, 6 );
1594
1595 swap( tmp, vec[1] );
1596
1597 checkSize ( vec, 3UL );
1598 checkCapacity( vec, 1UL );
1599 checkNonZeros( vec, 1UL );
1600
1601 checkSize ( vec[0], 0UL );
1602 checkSize ( vec[1], 6UL );
1603 checkCapacity( vec[1], 6UL );
1604 checkNonZeros( vec[1], 6UL );
1605 checkSize ( vec[2], 0UL );
1606 checkSize ( tmp , 2UL );
1607 checkCapacity( tmp , 2UL );
1608 checkNonZeros( tmp , 2UL );
1609 }
1610 }
1611 //*************************************************************************************************
1612
1613
1614 //*************************************************************************************************
1615 /*!\brief Test of the \c set() member functions of the VectorAccessProxy class template.
1616 //
1617 // \return void
1618 // \exception std::runtime_error Error detected.
1619 //
1620 // This function performs a test of the \c set() member functions of the VectorAccessProxy
1621 // class template. In case an error is detected, a \a std::runtime_error exception is thrown.
1622 */
testSet()1623 void ProxyTest::testSet()
1624 {
1625 //=====================================================================================
1626 // Vector elements
1627 //=====================================================================================
1628
1629 {
1630 test_ = "VectorAccessProxy::set( size_t, ElementType )";
1631
1632 SVV vec( 3UL, 1UL );
1633 vec[1] = SV( 3UL, 1UL );
1634 vec[1].set( 1UL, 5 );
1635
1636 checkSize ( vec, 3UL );
1637 checkCapacity( vec, 1UL );
1638 checkNonZeros( vec, 1UL );
1639
1640 checkSize ( vec[0], 0UL );
1641 checkSize ( vec[1], 3UL );
1642 checkCapacity( vec[1], 1UL );
1643 checkNonZeros( vec[1], 1UL );
1644 checkSize ( vec[2], 0UL );
1645
1646 if( vec[1][1] != 5 ) {
1647 std::ostringstream oss;
1648 oss << " Test: " << test_ << "\n"
1649 << " Error: Setting an element failed\n"
1650 << " Details:\n"
1651 << " Result:\n" << vec[1] << "\n"
1652 << " Expected result:\n( 0 5 0 )\n";
1653 throw std::runtime_error( oss.str() );
1654 }
1655 }
1656
1657
1658 //=====================================================================================
1659 // Matrix elements
1660 //=====================================================================================
1661
1662 {
1663 test_ = "VectorAccessProxy::set( size_t, size_t, ElementType )";
1664
1665 SMV vec( 3UL, 1UL );
1666 vec[1] = SM( 2UL, 2UL, 1UL );
1667 vec[1].set( 0UL, 1UL, 5 );
1668
1669 checkSize ( vec, 3UL );
1670 checkCapacity( vec, 1UL );
1671 checkNonZeros( vec, 1UL );
1672
1673 checkRows ( vec[0], 0UL );
1674 checkColumns ( vec[0], 0UL );
1675 checkRows ( vec[1], 2UL );
1676 checkColumns ( vec[1], 2UL );
1677 checkCapacity( vec[1], 1UL );
1678 checkNonZeros( vec[1], 1UL );
1679 checkRows ( vec[2], 0UL );
1680 checkColumns ( vec[2], 0UL );
1681
1682 if( vec[1](0,1) != 5 ) {
1683 std::ostringstream oss;
1684 oss << " Test: " << test_ << "\n"
1685 << " Error: Setting an element failed\n"
1686 << " Details:\n"
1687 << " Result:\n" << vec[1] << "\n"
1688 << " Expected result:\n( 0 5 )\n( 0 0 )\n";
1689 throw std::runtime_error( oss.str() );
1690 }
1691 }
1692 }
1693 //*************************************************************************************************
1694
1695
1696 //*************************************************************************************************
1697 /*!\brief Test of the \c insert() member functions of the VectorAccessProxy class template.
1698 //
1699 // \return void
1700 // \exception std::runtime_error Error detected.
1701 //
1702 // This function performs a test of the \c insert() member functions of the VectorAccessProxy
1703 // class template. In case an error is detected, a \a std::runtime_error exception is thrown.
1704 */
testInsert()1705 void ProxyTest::testInsert()
1706 {
1707 //=====================================================================================
1708 // Vector elements
1709 //=====================================================================================
1710
1711 {
1712 test_ = "VectorAccessProxy::insert( size_t, ElementType )";
1713
1714 SVV vec( 3UL, 1UL );
1715 vec[1] = SV( 3UL, 1UL );
1716 vec[1].insert( 1UL, 5 );
1717
1718 checkSize ( vec, 3UL );
1719 checkCapacity( vec, 1UL );
1720 checkNonZeros( vec, 1UL );
1721
1722 checkSize ( vec[0], 0UL );
1723 checkSize ( vec[1], 3UL );
1724 checkCapacity( vec[1], 1UL );
1725 checkNonZeros( vec[1], 1UL );
1726 checkSize ( vec[2], 0UL );
1727
1728 if( vec[1][1] != 5 ) {
1729 std::ostringstream oss;
1730 oss << " Test: " << test_ << "\n"
1731 << " Error: Inserting an element failed\n"
1732 << " Details:\n"
1733 << " Result:\n" << vec[1] << "\n"
1734 << " Expected result:\n( 0 5 0 )\n";
1735 throw std::runtime_error( oss.str() );
1736 }
1737 }
1738
1739
1740 //=====================================================================================
1741 // Matrix elements
1742 //=====================================================================================
1743
1744 {
1745 test_ = "VectorAccessProxy::insert( size_t, size_t, ElementType )";
1746
1747 SMV vec( 3UL, 1UL );
1748 vec[1] = SM( 2UL, 2UL, 1UL );
1749 vec[1].insert( 0UL, 1UL, 5 );
1750
1751 checkSize ( vec, 3UL );
1752 checkCapacity( vec, 1UL );
1753 checkNonZeros( vec, 1UL );
1754
1755 checkRows ( vec[0], 0UL );
1756 checkColumns ( vec[0], 0UL );
1757 checkRows ( vec[1], 2UL );
1758 checkColumns ( vec[1], 2UL );
1759 checkCapacity( vec[1], 1UL );
1760 checkNonZeros( vec[1], 1UL );
1761 checkRows ( vec[2], 0UL );
1762 checkColumns ( vec[2], 0UL );
1763
1764 if( vec[1](0,1) != 5 ) {
1765 std::ostringstream oss;
1766 oss << " Test: " << test_ << "\n"
1767 << " Error: Inserting an element failed\n"
1768 << " Details:\n"
1769 << " Result:\n" << vec[1] << "\n"
1770 << " Expected result:\n( 0 5 )\n( 0 0 )\n";
1771 throw std::runtime_error( oss.str() );
1772 }
1773 }
1774 }
1775 //*************************************************************************************************
1776
1777
1778 //*************************************************************************************************
1779 /*!\brief Test of the \c append() member functions of the VectorAccessProxy class template.
1780 //
1781 // \return void
1782 // \exception std::runtime_error Error detected.
1783 //
1784 // This function performs a test of the \c append() member functions of the VectorAccessProxy
1785 // class template. In case an error is detected, a \a std::runtime_error exception is thrown.
1786 */
testAppend()1787 void ProxyTest::testAppend()
1788 {
1789 //=====================================================================================
1790 // Vector elements
1791 //=====================================================================================
1792
1793 {
1794 test_ = "VectorAccessProxy::append( size_t, ElementType )";
1795
1796 SVV vec( 3UL, 1UL );
1797 vec[1] = SV( 3UL );
1798 vec[1].reserve( 1UL );
1799 vec[1].append( 1UL, 5 );
1800
1801 checkSize ( vec, 3UL );
1802 checkCapacity( vec, 1UL );
1803 checkNonZeros( vec, 1UL );
1804
1805 checkSize ( vec[0], 0UL );
1806 checkSize ( vec[1], 3UL );
1807 checkCapacity( vec[1], 1UL );
1808 checkNonZeros( vec[1], 1UL );
1809 checkSize ( vec[2], 0UL );
1810
1811 if( vec[1][1] != 5 ) {
1812 std::ostringstream oss;
1813 oss << " Test: " << test_ << "\n"
1814 << " Error: Append operation failed\n"
1815 << " Details:\n"
1816 << " Result:\n" << vec[1] << "\n"
1817 << " Expected result:\n( 0 5 0 )\n";
1818 throw std::runtime_error( oss.str() );
1819 }
1820 }
1821
1822
1823 //=====================================================================================
1824 // Matrix elements
1825 //=====================================================================================
1826
1827 {
1828 test_ = "VectorAccessProxy::append( size_t, size_t, ElementType )";
1829
1830 SMV vec( 3UL, 1UL );
1831 vec[1] = SM( 2UL, 2UL );
1832 vec[1].reserve( 0UL, 1UL );
1833 vec[1].append( 0UL, 1UL, 5 );
1834 vec[1].finalize( 0UL );
1835
1836 checkSize ( vec, 3UL );
1837 checkCapacity( vec, 1UL );
1838 checkNonZeros( vec, 1UL );
1839
1840 checkRows ( vec[0], 0UL );
1841 checkColumns ( vec[0], 0UL );
1842 checkRows ( vec[1], 2UL );
1843 checkColumns ( vec[1], 2UL );
1844 checkCapacity( vec[1], 1UL );
1845 checkNonZeros( vec[1], 1UL );
1846 checkRows ( vec[2], 0UL );
1847 checkColumns ( vec[2], 0UL );
1848
1849 if( vec[1](0,1) != 5 ) {
1850 std::ostringstream oss;
1851 oss << " Test: " << test_ << "\n"
1852 << " Error: Append operation failed\n"
1853 << " Details:\n"
1854 << " Result:\n" << vec[1] << "\n"
1855 << " Expected result:\n( 0 5 )\n( 0 0 )\n";
1856 throw std::runtime_error( oss.str() );
1857 }
1858 }
1859 }
1860 //*************************************************************************************************
1861
1862
1863 //*************************************************************************************************
1864 /*!\brief Test of the \c erase() member functions of the VectorAccessProxy class template.
1865 //
1866 // \return void
1867 // \exception std::runtime_error Error detected.
1868 //
1869 // This function performs a test of the \c erase() member functions of the VectorAccessProxy
1870 // class template. In case an error is detected, a \a std::runtime_error exception is thrown.
1871 */
testErase()1872 void ProxyTest::testErase()
1873 {
1874 //=====================================================================================
1875 // Vector elements
1876 //=====================================================================================
1877
1878 {
1879 test_ = "VectorAccessProxy::erase( size_t )";
1880
1881 SVV vec( 3UL, 1UL );
1882 vec[1] = SV( 3UL, 1UL );
1883 vec[1].insert( 1UL, 5 );
1884 vec[1].erase( 1UL );
1885
1886 checkSize ( vec, 3UL );
1887 checkCapacity( vec, 1UL );
1888 checkNonZeros( vec, 1UL );
1889
1890 checkSize ( vec[0], 0UL );
1891 checkSize ( vec[1], 3UL );
1892 checkNonZeros( vec[1], 0UL );
1893 checkSize ( vec[2], 0UL );
1894 }
1895
1896 {
1897 test_ = "VectorAccessProxy::erase( Iterator )";
1898
1899 SVV vec( 3UL, 1UL );
1900 vec[1] = SV( 3UL, 1UL );
1901 vec[1].erase( vec[1].insert( 1UL, 5 ) );
1902
1903 checkSize ( vec, 3UL );
1904 checkCapacity( vec, 1UL );
1905 checkNonZeros( vec, 1UL );
1906
1907 checkSize ( vec[0], 0UL );
1908 checkSize ( vec[1], 3UL );
1909 checkNonZeros( vec[1], 0UL );
1910 checkSize ( vec[2], 0UL );
1911 }
1912
1913 {
1914 test_ = "VectorAccessProxy::erase( Iterator, Iterator )";
1915
1916 SVV vec( 3UL, 1UL );
1917 vec[1] = SV( 3UL, 1UL );
1918 vec[1].insert( 0UL, 1 );
1919 vec[1].insert( 1UL, 2 );
1920 vec[1].insert( 2UL, 3 );
1921 vec[1].erase( begin( vec[1] ), end( vec[1] ) );
1922
1923 checkSize ( vec, 3UL );
1924 checkCapacity( vec, 1UL );
1925 checkNonZeros( vec, 1UL );
1926
1927 checkSize ( vec[0], 0UL );
1928 checkSize ( vec[1], 3UL );
1929 checkNonZeros( vec[1], 0UL );
1930 checkSize ( vec[2], 0UL );
1931 }
1932
1933 {
1934 test_ = "VectorAccessProxy::erase( Predicate )";
1935
1936 SVV vec( 3UL, 1UL );
1937 vec[1] = SV( 3UL, 1UL );
1938 vec[1].insert( 1UL, 5 );
1939 vec[1].erase( []( int value ){ return value == 5; } );
1940
1941 checkSize ( vec, 3UL );
1942 checkCapacity( vec, 1UL );
1943 checkNonZeros( vec, 1UL );
1944
1945 checkSize ( vec[0], 0UL );
1946 checkSize ( vec[1], 3UL );
1947 checkNonZeros( vec[1], 0UL );
1948 checkSize ( vec[2], 0UL );
1949 }
1950
1951 {
1952 test_ = "VectorAccessProxy::erase( Iterator, Iterator, Predicate )";
1953
1954 SVV vec( 3UL, 1UL );
1955 vec[1] = SV( 3UL, 1UL );
1956 vec[1].insert( 1UL, 5 );
1957 vec[1].erase( begin( vec[1] ), end( vec[1] ), []( int value ){ return value == 5; } );
1958
1959 checkSize ( vec, 3UL );
1960 checkCapacity( vec, 1UL );
1961 checkNonZeros( vec, 1UL );
1962
1963 checkSize ( vec[0], 0UL );
1964 checkSize ( vec[1], 3UL );
1965 checkNonZeros( vec[1], 0UL );
1966 checkSize ( vec[2], 0UL );
1967 }
1968
1969
1970 //=====================================================================================
1971 // Matrix elements
1972 //=====================================================================================
1973
1974 {
1975 test_ = "VectorAccessProxy::erase( size_t, size_t )";
1976
1977 SMV vec( 3UL, 1UL );
1978 vec[1] = SM( 2UL, 2UL, 1UL );
1979 vec[1].insert( 0UL, 1UL, 5 );
1980 vec[1].erase( 0UL, 1UL );
1981
1982 checkSize ( vec, 3UL );
1983 checkCapacity( vec, 1UL );
1984 checkNonZeros( vec, 1UL );
1985
1986 checkRows ( vec[0], 0UL );
1987 checkColumns ( vec[0], 0UL );
1988 checkRows ( vec[1], 2UL );
1989 checkColumns ( vec[1], 2UL );
1990 checkNonZeros( vec[1], 0UL );
1991 checkRows ( vec[2], 0UL );
1992 checkColumns ( vec[2], 0UL );
1993 }
1994
1995 {
1996 test_ = "VectorAccessProxy::erase( size_t, Iterator )";
1997
1998 SMV vec( 3UL, 1UL );
1999 vec[1] = SM( 2UL, 2UL, 1UL );
2000 vec[1].erase( 0UL, vec[1].insert( 0UL, 1UL, 5 ) );
2001
2002 checkSize ( vec, 3UL );
2003 checkCapacity( vec, 1UL );
2004 checkNonZeros( vec, 1UL );
2005
2006 checkRows ( vec[0], 0UL );
2007 checkColumns ( vec[0], 0UL );
2008 checkRows ( vec[1], 2UL );
2009 checkColumns ( vec[1], 2UL );
2010 checkNonZeros( vec[1], 0UL );
2011 checkRows ( vec[2], 0UL );
2012 checkColumns ( vec[2], 0UL );
2013 }
2014
2015 {
2016 test_ = "VectorAccessProxy::erase( size_t, Iterator, Iterator )";
2017
2018 SMV vec( 3UL, 1UL );
2019 vec[1] = SM( 2UL, 2UL, 1UL );
2020 vec[1].insert( 0UL, 0UL, 1 );
2021 vec[1].insert( 0UL, 1UL, 2 );
2022 vec[1].erase( 0UL, begin( vec[1], 0UL ), end( vec[1], 0UL ) );
2023
2024 checkSize ( vec, 3UL );
2025 checkCapacity( vec, 1UL );
2026 checkNonZeros( vec, 1UL );
2027
2028 checkRows ( vec[0], 0UL );
2029 checkColumns ( vec[0], 0UL );
2030 checkRows ( vec[1], 2UL );
2031 checkColumns ( vec[1], 2UL );
2032 checkNonZeros( vec[1], 0UL );
2033 checkRows ( vec[2], 0UL );
2034 checkColumns ( vec[2], 0UL );
2035 }
2036
2037 {
2038 test_ = "VectorAccessProxy::erase( Predicate )";
2039
2040 SMV vec( 3UL, 1UL );
2041 vec[1] = SM( 2UL, 2UL, 1UL );
2042 vec[1].insert( 0UL, 1UL, 5 );
2043 vec[1].erase( []( int value ){ return value == 5; } );
2044
2045 checkSize ( vec, 3UL );
2046 checkCapacity( vec, 1UL );
2047 checkNonZeros( vec, 1UL );
2048
2049 checkRows ( vec[0], 0UL );
2050 checkColumns ( vec[0], 0UL );
2051 checkRows ( vec[1], 2UL );
2052 checkColumns ( vec[1], 2UL );
2053 checkNonZeros( vec[1], 0UL );
2054 checkRows ( vec[2], 0UL );
2055 checkColumns ( vec[2], 0UL );
2056 }
2057
2058 {
2059 test_ = "VectorAccessProxy::erase( size_t, Iterator, Iterator, Predicate )";
2060
2061 SMV vec( 3UL, 1UL );
2062 vec[1] = SM( 2UL, 2UL, 1UL );
2063 vec[1].insert( 0UL, 1UL, 5 );
2064 vec[1].erase( 0UL, begin( vec[1], 0UL ), end( vec[1], 0UL ),
2065 []( int value ){ return value == 5; } );
2066
2067 checkSize ( vec, 3UL );
2068 checkCapacity( vec, 1UL );
2069 checkNonZeros( vec, 1UL );
2070
2071 checkRows ( vec[0], 0UL );
2072 checkColumns ( vec[0], 0UL );
2073 checkRows ( vec[1], 2UL );
2074 checkColumns ( vec[1], 2UL );
2075 checkNonZeros( vec[1], 0UL );
2076 checkRows ( vec[2], 0UL );
2077 checkColumns ( vec[2], 0UL );
2078 }
2079 }
2080 //*************************************************************************************************
2081
2082
2083 //*************************************************************************************************
2084 /*!\brief Test of the \c find() member functions of the VectorAccessProxy class template.
2085 //
2086 // \return void
2087 // \exception std::runtime_error Error detected.
2088 //
2089 // This function performs a test of the \c find() member functions of the VectorAccessProxy
2090 // class template. In case an error is detected, a \a std::runtime_error exception is thrown.
2091 */
testFind()2092 void ProxyTest::testFind()
2093 {
2094 //=====================================================================================
2095 // Vector elements
2096 //=====================================================================================
2097
2098 {
2099 test_ = "VectorAccessProxy::find( size_t )";
2100
2101 SVV vec( 3UL, 1UL );
2102 vec[0] = SV( 5UL, 3UL );
2103 vec[0][1] = 2;
2104 vec[0][2] = 3;
2105 vec[0][4] = 5;
2106
2107 SV::Iterator pos( vec[0].find( 2UL ) );
2108
2109 checkSize ( vec, 3UL );
2110 checkCapacity( vec, 1UL );
2111 checkNonZeros( vec, 1UL );
2112
2113 checkSize ( vec[0], 5UL );
2114 checkCapacity( vec[0], 3UL );
2115 checkNonZeros( vec[0], 3UL );
2116 checkSize ( vec[1], 0UL );
2117 checkSize ( vec[2], 0UL );
2118
2119 if( pos == vec[0].end() ) {
2120 std::ostringstream oss;
2121 oss << " Test: " << test_ << "\n"
2122 << " Error: Element could not be found\n"
2123 << " Details:\n"
2124 << " Required index = 2\n"
2125 << " Current vector:\n" << vec[0] << "\n";
2126 throw std::runtime_error( oss.str() );
2127 }
2128 else if( pos->index() != 2 || pos->value() != 3 ) {
2129 std::ostringstream oss;
2130 oss << " Test: " << test_ << "\n"
2131 << " Error: Wrong element found\n"
2132 << " Details:\n"
2133 << " Required index = 2\n"
2134 << " Found index = " << pos->index() << "\n"
2135 << " Expected value = 3\n"
2136 << " Value at index = " << pos->value() << "\n"
2137 << " Current vector:\n" << vec[0] << "\n";
2138 throw std::runtime_error( oss.str() );
2139 }
2140 }
2141
2142 {
2143 test_ = "find( VectorAccessProxy, size_t )";
2144
2145 SVV vec( 3UL, 1UL );
2146 vec[0] = SV( 5UL, 3UL );
2147 vec[0][1] = 2;
2148 vec[0][2] = 3;
2149 vec[0][4] = 5;
2150
2151 SV::Iterator pos( find( vec[0], 2UL ) );
2152
2153 checkSize ( vec, 3UL );
2154 checkCapacity( vec, 1UL );
2155 checkNonZeros( vec, 1UL );
2156
2157 checkSize ( vec[0], 5UL );
2158 checkCapacity( vec[0], 3UL );
2159 checkNonZeros( vec[0], 3UL );
2160 checkSize ( vec[1], 0UL );
2161 checkSize ( vec[2], 0UL );
2162
2163 if( pos == vec[0].end() ) {
2164 std::ostringstream oss;
2165 oss << " Test: " << test_ << "\n"
2166 << " Error: Element could not be found\n"
2167 << " Details:\n"
2168 << " Required index = 2\n"
2169 << " Current vector:\n" << vec[0] << "\n";
2170 throw std::runtime_error( oss.str() );
2171 }
2172 else if( pos->index() != 2 || pos->value() != 3 ) {
2173 std::ostringstream oss;
2174 oss << " Test: " << test_ << "\n"
2175 << " Error: Wrong element found\n"
2176 << " Details:\n"
2177 << " Required index = 2\n"
2178 << " Found index = " << pos->index() << "\n"
2179 << " Expected value = 3\n"
2180 << " Value at index = " << pos->value() << "\n"
2181 << " Current vector:\n" << vec[0] << "\n";
2182 throw std::runtime_error( oss.str() );
2183 }
2184 }
2185
2186
2187 //=====================================================================================
2188 // Matrix elements
2189 //=====================================================================================
2190
2191 {
2192 test_ = "VectorAccessProxy::find( size_t, size_t )";
2193
2194 SMV vec( 3UL, 1UL );
2195 vec[0] = SM( 2UL, 5UL, 3UL );
2196 vec[0](1,1) = 2;
2197 vec[0](1,2) = 3;
2198 vec[0](1,4) = 5;
2199
2200 SM::Iterator pos( vec[0].find( 1UL, 2UL ) );
2201
2202 checkSize ( vec, 3UL );
2203 checkCapacity( vec, 1UL );
2204 checkNonZeros( vec, 1UL );
2205
2206 checkRows ( vec[0], 2UL );
2207 checkColumns ( vec[0], 5UL );
2208 checkCapacity( vec[0], 3UL );
2209 checkNonZeros( vec[0], 3UL );
2210 checkRows ( vec[1], 0UL );
2211 checkColumns ( vec[1], 0UL );
2212 checkRows ( vec[2], 0UL );
2213 checkColumns ( vec[2], 0UL );
2214
2215 if( pos == vec[0].end( 1UL ) ) {
2216 std::ostringstream oss;
2217 oss << " Test: " << test_ << "\n"
2218 << " Error: Element could not be found\n"
2219 << " Details:\n"
2220 << " Required index = 2\n"
2221 << " Current matrix:\n" << vec[0] << "\n";
2222 throw std::runtime_error( oss.str() );
2223 }
2224 else if( pos->index() != 2 || pos->value() != 3 ) {
2225 std::ostringstream oss;
2226 oss << " Test: " << test_ << "\n"
2227 << " Error: Wrong element found\n"
2228 << " Details:\n"
2229 << " Required index = 2\n"
2230 << " Found index = " << pos->index() << "\n"
2231 << " Expected value = 3\n"
2232 << " Value at index = " << pos->value() << "\n"
2233 << " Current matrix:\n" << vec[0] << "\n";
2234 throw std::runtime_error( oss.str() );
2235 }
2236 }
2237
2238 {
2239 test_ = "find( VectorAccessProxy, size_t, size_t )";
2240
2241 SMV vec( 3UL, 1UL );
2242 vec[0] = SM( 2UL, 5UL, 3UL );
2243 vec[0](1,1) = 2;
2244 vec[0](1,2) = 3;
2245 vec[0](1,4) = 5;
2246
2247 SM::Iterator pos( find( vec[0], 1UL, 2UL ) );
2248
2249 checkSize ( vec, 3UL );
2250 checkCapacity( vec, 1UL );
2251 checkNonZeros( vec, 1UL );
2252
2253 checkRows ( vec[0], 2UL );
2254 checkColumns ( vec[0], 5UL );
2255 checkCapacity( vec[0], 3UL );
2256 checkNonZeros( vec[0], 3UL );
2257 checkRows ( vec[1], 0UL );
2258 checkColumns ( vec[1], 0UL );
2259 checkRows ( vec[2], 0UL );
2260 checkColumns ( vec[2], 0UL );
2261
2262 if( pos == vec[0].end( 1UL ) ) {
2263 std::ostringstream oss;
2264 oss << " Test: " << test_ << "\n"
2265 << " Error: Element could not be found\n"
2266 << " Details:\n"
2267 << " Required index = 2\n"
2268 << " Current matrix:\n" << vec[0] << "\n";
2269 throw std::runtime_error( oss.str() );
2270 }
2271 else if( pos->index() != 2 || pos->value() != 3 ) {
2272 std::ostringstream oss;
2273 oss << " Test: " << test_ << "\n"
2274 << " Error: Wrong element found\n"
2275 << " Details:\n"
2276 << " Required index = 2\n"
2277 << " Found index = " << pos->index() << "\n"
2278 << " Expected value = 3\n"
2279 << " Value at index = " << pos->value() << "\n"
2280 << " Current matrix:\n" << vec[0] << "\n";
2281 throw std::runtime_error( oss.str() );
2282 }
2283 }
2284 }
2285 //*************************************************************************************************
2286
2287
2288 //*************************************************************************************************
2289 /*!\brief Test of the \c lowerBound() member functions of the VectorAccessProxy class template.
2290 //
2291 // \return void
2292 // \exception std::runtime_error Error detected.
2293 //
2294 // This function performs a test of the \c lowerBound() member functions of the VectorAccessProxy
2295 // class template. In case an error is detected, a \a std::runtime_error exception is thrown.
2296 */
testLowerBound()2297 void ProxyTest::testLowerBound()
2298 {
2299 //=====================================================================================
2300 // Vector elements
2301 //=====================================================================================
2302
2303 {
2304 test_ = "VectorAccessProxy::lowerBound( size_t )";
2305
2306 SVV vec( 3UL, 1UL );
2307 vec[0] = SV( 5UL, 3UL );
2308 vec[0][1] = 2;
2309 vec[0][2] = 3;
2310 vec[0][4] = 5;
2311
2312 SV::Iterator pos( vec[0].lowerBound( 3UL ) );
2313
2314 checkSize ( vec, 3UL );
2315 checkCapacity( vec, 1UL );
2316 checkNonZeros( vec, 1UL );
2317
2318 checkSize ( vec[0], 5UL );
2319 checkCapacity( vec[0], 3UL );
2320 checkNonZeros( vec[0], 3UL );
2321 checkSize ( vec[1], 0UL );
2322 checkSize ( vec[2], 0UL );
2323
2324 if( pos == vec[0].end() ) {
2325 std::ostringstream oss;
2326 oss << " Test: " << test_ << "\n"
2327 << " Error: Element could not be found\n"
2328 << " Details:\n"
2329 << " Required index = 3\n"
2330 << " Current vector:\n" << vec[0] << "\n";
2331 throw std::runtime_error( oss.str() );
2332 }
2333 else if( pos->index() != 4 || pos->value() != 5 ) {
2334 std::ostringstream oss;
2335 oss << " Test: " << test_ << "\n"
2336 << " Error: Wrong element found\n"
2337 << " Details:\n"
2338 << " Required index = 4\n"
2339 << " Found index = " << pos->index() << "\n"
2340 << " Expected value = 5\n"
2341 << " Value at index = " << pos->value() << "\n"
2342 << " Current vector:\n" << vec[0] << "\n";
2343 throw std::runtime_error( oss.str() );
2344 }
2345 }
2346
2347 {
2348 test_ = "lowerBound( VectorAccessProxy, size_t )";
2349
2350 SVV vec( 3UL, 1UL );
2351 vec[0] = SV( 5UL, 3UL );
2352 vec[0][1] = 2;
2353 vec[0][2] = 3;
2354 vec[0][4] = 5;
2355
2356 SV::Iterator pos( lowerBound( vec[0], 3UL ) );
2357
2358 checkSize ( vec, 3UL );
2359 checkCapacity( vec, 1UL );
2360 checkNonZeros( vec, 1UL );
2361
2362 checkSize ( vec[0], 5UL );
2363 checkCapacity( vec[0], 3UL );
2364 checkNonZeros( vec[0], 3UL );
2365 checkSize ( vec[1], 0UL );
2366 checkSize ( vec[2], 0UL );
2367
2368 if( pos == vec[0].end() ) {
2369 std::ostringstream oss;
2370 oss << " Test: " << test_ << "\n"
2371 << " Error: Element could not be found\n"
2372 << " Details:\n"
2373 << " Required index = 3\n"
2374 << " Current vector:\n" << vec[0] << "\n";
2375 throw std::runtime_error( oss.str() );
2376 }
2377 else if( pos->index() != 4 || pos->value() != 5 ) {
2378 std::ostringstream oss;
2379 oss << " Test: " << test_ << "\n"
2380 << " Error: Wrong element found\n"
2381 << " Details:\n"
2382 << " Required index = 4\n"
2383 << " Found index = " << pos->index() << "\n"
2384 << " Expected value = 5\n"
2385 << " Value at index = " << pos->value() << "\n"
2386 << " Current vector:\n" << vec[0] << "\n";
2387 throw std::runtime_error( oss.str() );
2388 }
2389 }
2390
2391
2392 //=====================================================================================
2393 // Matrix elements
2394 //=====================================================================================
2395
2396 {
2397 test_ = "VectorAccessProxy::lowerBound( size_t, size_t )";
2398
2399 SMV vec( 3UL, 1UL );
2400 vec[0] = SM( 2UL, 5UL, 3UL );
2401 vec[0](1,1) = 2;
2402 vec[0](1,2) = 3;
2403 vec[0](1,4) = 5;
2404
2405 SM::Iterator pos( vec[0].lowerBound( 1UL, 3 ) );
2406
2407 checkSize ( vec, 3UL );
2408 checkCapacity( vec, 1UL );
2409 checkNonZeros( vec, 1UL );
2410
2411 checkRows ( vec[0], 2UL );
2412 checkColumns ( vec[0], 5UL );
2413 checkCapacity( vec[0], 3UL );
2414 checkNonZeros( vec[0], 3UL );
2415 checkRows ( vec[1], 0UL );
2416 checkColumns ( vec[1], 0UL );
2417 checkRows ( vec[2], 0UL );
2418 checkColumns ( vec[2], 0UL );
2419
2420 if( pos == vec[0].end( 1UL ) ) {
2421 std::ostringstream oss;
2422 oss << " Test: " << test_ << "\n"
2423 << " Error: Element could not be found\n"
2424 << " Details:\n"
2425 << " Required index = 3\n"
2426 << " Current matrix:\n" << vec[0] << "\n";
2427 throw std::runtime_error( oss.str() );
2428 }
2429 else if( pos->index() != 4 || pos->value() != 5 ) {
2430 std::ostringstream oss;
2431 oss << " Test: " << test_ << "\n"
2432 << " Error: Wrong element found\n"
2433 << " Details:\n"
2434 << " Required index = 4\n"
2435 << " Found index = " << pos->index() << "\n"
2436 << " Expected value = 5\n"
2437 << " Value at index = " << pos->value() << "\n"
2438 << " Current matrix:\n" << vec[0] << "\n";
2439 throw std::runtime_error( oss.str() );
2440 }
2441 }
2442
2443 {
2444 test_ = "lowerBound( VectorAccessProxy, size_t, size_t )";
2445
2446 SMV vec( 3UL, 1UL );
2447 vec[0] = SM( 2UL, 5UL, 3UL );
2448 vec[0](1,1) = 2;
2449 vec[0](1,2) = 3;
2450 vec[0](1,4) = 5;
2451
2452 SM::Iterator pos( lowerBound( vec[0], 1UL, 3UL ) );
2453
2454 checkSize ( vec, 3UL );
2455 checkCapacity( vec, 1UL );
2456 checkNonZeros( vec, 1UL );
2457
2458 checkRows ( vec[0], 2UL );
2459 checkColumns ( vec[0], 5UL );
2460 checkCapacity( vec[0], 3UL );
2461 checkNonZeros( vec[0], 3UL );
2462 checkRows ( vec[1], 0UL );
2463 checkColumns ( vec[1], 0UL );
2464 checkRows ( vec[2], 0UL );
2465 checkColumns ( vec[2], 0UL );
2466
2467 if( pos == vec[0].end( 1UL ) ) {
2468 std::ostringstream oss;
2469 oss << " Test: " << test_ << "\n"
2470 << " Error: Element could not be found\n"
2471 << " Details:\n"
2472 << " Required index = 3\n"
2473 << " Current matrix:\n" << vec[0] << "\n";
2474 throw std::runtime_error( oss.str() );
2475 }
2476 else if( pos->index() != 4 || pos->value() != 5 ) {
2477 std::ostringstream oss;
2478 oss << " Test: " << test_ << "\n"
2479 << " Error: Wrong element found\n"
2480 << " Details:\n"
2481 << " Required index = 4\n"
2482 << " Found index = " << pos->index() << "\n"
2483 << " Expected value = 5\n"
2484 << " Value at index = " << pos->value() << "\n"
2485 << " Current matrix:\n" << vec[0] << "\n";
2486 throw std::runtime_error( oss.str() );
2487 }
2488 }
2489 }
2490 //*************************************************************************************************
2491
2492
2493 //*************************************************************************************************
2494 /*!\brief Test of the \c upperBound() member functions of the VectorAccessProxy class template.
2495 //
2496 // \return void
2497 // \exception std::runtime_error Error detected.
2498 //
2499 // This function performs a test of the \c upperBound() member functions of the VectorAccessProxy
2500 // class template. In case an error is detected, a \a std::runtime_error exception is thrown.
2501 */
testUpperBound()2502 void ProxyTest::testUpperBound()
2503 {
2504 //=====================================================================================
2505 // Vector elements
2506 //=====================================================================================
2507
2508 {
2509 test_ = "VectorAccessProxy::upperBound( size_t )";
2510
2511 SVV vec( 3UL, 1UL );
2512 vec[0] = SV( 5UL, 3UL );
2513 vec[0][1] = 2;
2514 vec[0][2] = 3;
2515 vec[0][4] = 5;
2516
2517 SV::Iterator pos( vec[0].upperBound( 3UL ) );
2518
2519 checkSize ( vec, 3UL );
2520 checkCapacity( vec, 1UL );
2521 checkNonZeros( vec, 1UL );
2522
2523 checkSize ( vec[0], 5UL );
2524 checkCapacity( vec[0], 3UL );
2525 checkNonZeros( vec[0], 3UL );
2526 checkSize ( vec[1], 0UL );
2527 checkSize ( vec[2], 0UL );
2528
2529 if( pos == vec[0].end() ) {
2530 std::ostringstream oss;
2531 oss << " Test: " << test_ << "\n"
2532 << " Error: Element could not be found\n"
2533 << " Details:\n"
2534 << " Required index = 3\n"
2535 << " Current vector:\n" << vec[0] << "\n";
2536 throw std::runtime_error( oss.str() );
2537 }
2538 else if( pos->index() != 4 || pos->value() != 5 ) {
2539 std::ostringstream oss;
2540 oss << " Test: " << test_ << "\n"
2541 << " Error: Wrong element found\n"
2542 << " Details:\n"
2543 << " Required index = 4\n"
2544 << " Found index = " << pos->index() << "\n"
2545 << " Expected value = 5\n"
2546 << " Value at index = " << pos->value() << "\n"
2547 << " Current vector:\n" << vec[0] << "\n";
2548 throw std::runtime_error( oss.str() );
2549 }
2550 }
2551
2552 {
2553 test_ = "upperBound( VectorAccessProxy, size_t )";
2554
2555 SVV vec( 3UL, 1UL );
2556 vec[0] = SV( 5UL, 3UL );
2557 vec[0][1] = 2;
2558 vec[0][2] = 3;
2559 vec[0][4] = 5;
2560
2561 SV::Iterator pos( upperBound( vec[0], 3UL ) );
2562
2563 checkSize ( vec, 3UL );
2564 checkCapacity( vec, 1UL );
2565 checkNonZeros( vec, 1UL );
2566
2567 checkSize ( vec[0], 5UL );
2568 checkCapacity( vec[0], 3UL );
2569 checkNonZeros( vec[0], 3UL );
2570 checkSize ( vec[1], 0UL );
2571 checkSize ( vec[2], 0UL );
2572
2573 if( pos == vec[0].end() ) {
2574 std::ostringstream oss;
2575 oss << " Test: " << test_ << "\n"
2576 << " Error: Element could not be found\n"
2577 << " Details:\n"
2578 << " Required index = 3\n"
2579 << " Current vector:\n" << vec[0] << "\n";
2580 throw std::runtime_error( oss.str() );
2581 }
2582 else if( pos->index() != 4 || pos->value() != 5 ) {
2583 std::ostringstream oss;
2584 oss << " Test: " << test_ << "\n"
2585 << " Error: Wrong element found\n"
2586 << " Details:\n"
2587 << " Required index = 4\n"
2588 << " Found index = " << pos->index() << "\n"
2589 << " Expected value = 5\n"
2590 << " Value at index = " << pos->value() << "\n"
2591 << " Current vector:\n" << vec[0] << "\n";
2592 throw std::runtime_error( oss.str() );
2593 }
2594 }
2595
2596
2597 //=====================================================================================
2598 // Matrix elements
2599 //=====================================================================================
2600
2601 {
2602 test_ = "VectorAccessProxy::upperBound( size_t, size_t )";
2603
2604 SMV vec( 3UL, 1UL );
2605 vec[0] = SM( 2UL, 5UL, 3UL );
2606 vec[0](1,1) = 2;
2607 vec[0](1,2) = 3;
2608 vec[0](1,4) = 5;
2609
2610 SM::Iterator pos( vec[0].upperBound( 1UL, 3 ) );
2611
2612 checkSize ( vec, 3UL );
2613 checkCapacity( vec, 1UL );
2614 checkNonZeros( vec, 1UL );
2615
2616 checkRows ( vec[0], 2UL );
2617 checkColumns ( vec[0], 5UL );
2618 checkCapacity( vec[0], 3UL );
2619 checkNonZeros( vec[0], 3UL );
2620 checkRows ( vec[1], 0UL );
2621 checkColumns ( vec[1], 0UL );
2622 checkRows ( vec[2], 0UL );
2623 checkColumns ( vec[2], 0UL );
2624
2625 if( pos == vec[0].end( 1UL ) ) {
2626 std::ostringstream oss;
2627 oss << " Test: " << test_ << "\n"
2628 << " Error: Element could not be found\n"
2629 << " Details:\n"
2630 << " Required index = 3\n"
2631 << " Current matrix:\n" << vec[0] << "\n";
2632 throw std::runtime_error( oss.str() );
2633 }
2634 else if( pos->index() != 4 || pos->value() != 5 ) {
2635 std::ostringstream oss;
2636 oss << " Test: " << test_ << "\n"
2637 << " Error: Wrong element found\n"
2638 << " Details:\n"
2639 << " Required index = 4\n"
2640 << " Found index = " << pos->index() << "\n"
2641 << " Expected value = 5\n"
2642 << " Value at index = " << pos->value() << "\n"
2643 << " Current matrix:\n" << vec[0] << "\n";
2644 throw std::runtime_error( oss.str() );
2645 }
2646 }
2647
2648 {
2649 test_ = "upperBound( VectorAccessProxy, size_t, size_t )";
2650
2651 SMV vec( 3UL, 1UL );
2652 vec[0] = SM( 2UL, 5UL, 3UL );
2653 vec[0](1,1) = 2;
2654 vec[0](1,2) = 3;
2655 vec[0](1,4) = 5;
2656
2657 SM::Iterator pos( upperBound( vec[0], 1UL, 3UL ) );
2658
2659 checkSize ( vec, 3UL );
2660 checkCapacity( vec, 1UL );
2661 checkNonZeros( vec, 1UL );
2662
2663 checkRows ( vec[0], 2UL );
2664 checkColumns ( vec[0], 5UL );
2665 checkCapacity( vec[0], 3UL );
2666 checkNonZeros( vec[0], 3UL );
2667 checkRows ( vec[1], 0UL );
2668 checkColumns ( vec[1], 0UL );
2669 checkRows ( vec[2], 0UL );
2670 checkColumns ( vec[2], 0UL );
2671
2672 if( pos == vec[0].end( 1UL ) ) {
2673 std::ostringstream oss;
2674 oss << " Test: " << test_ << "\n"
2675 << " Error: Element could not be found\n"
2676 << " Details:\n"
2677 << " Required index = 3\n"
2678 << " Current matrix:\n" << vec[0] << "\n";
2679 throw std::runtime_error( oss.str() );
2680 }
2681 else if( pos->index() != 4 || pos->value() != 5 ) {
2682 std::ostringstream oss;
2683 oss << " Test: " << test_ << "\n"
2684 << " Error: Wrong element found\n"
2685 << " Details:\n"
2686 << " Required index = 4\n"
2687 << " Found index = " << pos->index() << "\n"
2688 << " Expected value = 5\n"
2689 << " Value at index = " << pos->value() << "\n"
2690 << " Current matrix:\n" << vec[0] << "\n";
2691 throw std::runtime_error( oss.str() );
2692 }
2693 }
2694 }
2695 //*************************************************************************************************
2696
2697
2698 //*************************************************************************************************
2699 /*!\brief Test of the \c transpose() functions of the VectorAccessProxy class template.
2700 //
2701 // \return void
2702 // \exception std::runtime_error Error detected.
2703 //
2704 // This function performs a test of the \c transpose() functions of the VectorAccessProxy class
2705 // template. In case an error is detected, a \a std::runtime_error exception is thrown.
2706 */
testTranspose()2707 void ProxyTest::testTranspose()
2708 {
2709 {
2710 test_ = "VectorAccessProxy::transpose()";
2711
2712 DMV vec( 3UL, 1UL );
2713 vec[0].resize( 5UL, 3UL );
2714 vec[0].transpose();
2715
2716 checkSize ( vec, 3UL );
2717 checkCapacity( vec, 1UL );
2718 checkNonZeros( vec, 1UL );
2719
2720 checkRows ( vec[0], 3UL );
2721 checkColumns ( vec[0], 5UL );
2722 checkCapacity( vec[0], 15UL );
2723 checkRows ( vec[1], 0UL );
2724 checkColumns ( vec[1], 0UL );
2725 checkRows ( vec[2], 0UL );
2726 checkColumns ( vec[2], 0UL );
2727 }
2728
2729 {
2730 test_ = "transpose( VectorAccessProxy )";
2731
2732 DMV vec( 3UL, 1UL );
2733 vec[0].resize( 5UL, 3UL );
2734 transpose( vec[0] );
2735
2736 checkSize ( vec, 3UL );
2737 checkCapacity( vec, 1UL );
2738 checkNonZeros( vec, 1UL );
2739
2740 checkRows ( vec[0], 3UL );
2741 checkColumns ( vec[0], 5UL );
2742 checkCapacity( vec[0], 15UL );
2743 checkRows ( vec[1], 0UL );
2744 checkColumns ( vec[1], 0UL );
2745 checkRows ( vec[2], 0UL );
2746 checkColumns ( vec[2], 0UL );
2747 }
2748 }
2749 //*************************************************************************************************
2750
2751
2752 //*************************************************************************************************
2753 /*!\brief Test of the \c ctranspose() functions of the VectorAccessProxy class template.
2754 //
2755 // \return void
2756 // \exception std::runtime_error Error detected.
2757 //
2758 // This function performs a test of the \c ctranspose() functions of the VectorAccessProxy class
2759 // template. In case an error is detected, a \a std::runtime_error exception is thrown.
2760 */
testCTranspose()2761 void ProxyTest::testCTranspose()
2762 {
2763 {
2764 test_ = "VectorAccessProxy::ctranspose()";
2765
2766 DMV vec( 3UL, 1UL );
2767 vec[0].resize( 5UL, 3UL );
2768 vec[0].ctranspose();
2769
2770 checkSize ( vec, 3UL );
2771 checkCapacity( vec, 1UL );
2772 checkNonZeros( vec, 1UL );
2773
2774 checkRows ( vec[0], 3UL );
2775 checkColumns ( vec[0], 5UL );
2776 checkCapacity( vec[0], 15UL );
2777 checkRows ( vec[1], 0UL );
2778 checkColumns ( vec[1], 0UL );
2779 checkRows ( vec[2], 0UL );
2780 checkColumns ( vec[2], 0UL );
2781 }
2782
2783 {
2784 test_ = "ctranspose( VectorAccessProxy )";
2785
2786 DMV vec( 3UL, 1UL );
2787 vec[0].resize( 5UL, 3UL );
2788 ctranspose( vec[0] );
2789
2790 checkSize ( vec, 3UL );
2791 checkCapacity( vec, 1UL );
2792 checkNonZeros( vec, 1UL );
2793
2794 checkRows ( vec[0], 3UL );
2795 checkColumns ( vec[0], 5UL );
2796 checkCapacity( vec[0], 15UL );
2797 checkRows ( vec[1], 0UL );
2798 checkColumns ( vec[1], 0UL );
2799 checkRows ( vec[2], 0UL );
2800 checkColumns ( vec[2], 0UL );
2801 }
2802 }
2803 //*************************************************************************************************
2804
2805
2806 //*************************************************************************************************
2807 /*!\brief Test of the \c invert() function with the VectorAccessProxy class template.
2808 //
2809 // \return void
2810 // \exception std::runtime_error Error detected.
2811 //
2812 // This function performs a test of the \c invert() functions with the VectorAccessProxy class
2813 // template. In case an error is detected, a \a std::runtime_error exception is thrown.
2814 */
testInvert()2815 void ProxyTest::testInvert()
2816 {
2817 #if BLAZETEST_MATHTEST_LAPACK_MODE
2818
2819 using blaze::invert;
2820 using blaze::byLU;
2821 using blaze::byLLH;
2822
2823
2824 {
2825 test_ = "invert( VectorAccessProxy )";
2826
2827 blaze::CompressedVector< blaze::DynamicMatrix<double> > vec( 3UL, 1UL );
2828 vec[0].resize( 3UL, 3UL );
2829 vec[0] = 0.0;
2830 vec[0](0,0) = 1.0;
2831 vec[0](1,1) = 1.0;
2832 vec[0](2,2) = 1.0;
2833 invert( vec[0] );
2834
2835 checkSize ( vec, 3UL );
2836 checkCapacity( vec, 1UL );
2837 checkNonZeros( vec, 1UL );
2838
2839 checkRows ( vec[0], 3UL );
2840 checkColumns ( vec[0], 3UL );
2841 checkCapacity( vec[0], 9UL );
2842 checkNonZeros( vec[0], 3UL );
2843 checkRows ( vec[1], 0UL );
2844 checkColumns ( vec[1], 0UL );
2845 checkRows ( vec[2], 0UL );
2846 checkColumns ( vec[2], 0UL );
2847 }
2848
2849 {
2850 test_ = "invert<byLU>( VectorAccessProxy )";
2851
2852 blaze::CompressedVector< blaze::DynamicMatrix<double> > vec( 3UL, 1UL );
2853 vec[0].resize( 3UL, 3UL );
2854 vec[0] = 0.0;
2855 vec[0](0,0) = 1.0;
2856 vec[0](1,1) = 1.0;
2857 vec[0](2,2) = 1.0;
2858 invert<byLU>( vec[0] );
2859
2860 checkSize ( vec, 3UL );
2861 checkCapacity( vec, 1UL );
2862 checkNonZeros( vec, 1UL );
2863
2864 checkRows ( vec[0], 3UL );
2865 checkColumns ( vec[0], 3UL );
2866 checkCapacity( vec[0], 9UL );
2867 checkNonZeros( vec[0], 3UL );
2868 checkRows ( vec[1], 0UL );
2869 checkColumns ( vec[1], 0UL );
2870 checkRows ( vec[2], 0UL );
2871 checkColumns ( vec[2], 0UL );
2872 }
2873
2874 {
2875 test_ = "invert<byLLH>( VectorAccessProxy )";
2876
2877 blaze::CompressedVector< blaze::DynamicMatrix<double> > vec( 3UL, 1UL );
2878 vec[0].resize( 3UL, 3UL );
2879 vec[0] = 0.0;
2880 vec[0](0,0) = 1.0;
2881 vec[0](1,1) = 1.0;
2882 vec[0](2,2) = 1.0;
2883 invert<byLLH>( vec[0] );
2884
2885 checkSize ( vec, 3UL );
2886 checkCapacity( vec, 1UL );
2887 checkNonZeros( vec, 1UL );
2888
2889 checkRows ( vec[0], 3UL );
2890 checkColumns ( vec[0], 3UL );
2891 checkCapacity( vec[0], 9UL );
2892 checkNonZeros( vec[0], 3UL );
2893 checkRows ( vec[1], 0UL );
2894 checkColumns ( vec[1], 0UL );
2895 checkRows ( vec[2], 0UL );
2896 checkColumns ( vec[2], 0UL );
2897 }
2898
2899 #endif
2900 }
2901 //*************************************************************************************************
2902
2903 } // namespace compressedvector
2904
2905 } // namespace vectors
2906
2907 } // namespace mathtest
2908
2909 } // namespace blazetest
2910
2911
2912
2913
2914 //=================================================================================================
2915 //
2916 // MAIN FUNCTION
2917 //
2918 //=================================================================================================
2919
2920 //*************************************************************************************************
main()2921 int main()
2922 {
2923 std::cout << " Running CompressedVector proxy test..." << std::endl;
2924
2925 try
2926 {
2927 RUN_COMPRESSEDVECTOR_PROXY_TEST;
2928 }
2929 catch( std::exception& ex ) {
2930 std::cerr << "\n\n ERROR DETECTED during CompressedVector proxy test:\n"
2931 << ex.what() << "\n";
2932 return EXIT_FAILURE;
2933 }
2934
2935 return EXIT_SUCCESS;
2936 }
2937 //*************************************************************************************************
2938