1 //=================================================================================================
2 /*!
3 // \file src/mathtest/views/band/DenseTest.cpp
4 // \brief Source file for the Band dense 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 <memory>
43 #include <blaze/math/CompressedVector.h>
44 #include <blaze/math/CustomVector.h>
45 #include <blaze/math/DynamicVector.h>
46 #include <blaze/math/Views.h>
47 #include <blaze/util/policies/Deallocate.h>
48 #include <blazetest/mathtest/views/band/DenseTest.h>
49
50 #ifdef BLAZE_USE_HPX_THREADS
51 # include <hpx/hpx_main.hpp>
52 #endif
53
54
55 namespace blazetest {
56
57 namespace mathtest {
58
59 namespace views {
60
61 namespace band {
62
63 //=================================================================================================
64 //
65 // CONSTRUCTORS
66 //
67 //=================================================================================================
68
69 //*************************************************************************************************
70 /*!\brief Constructor for the Band dense test.
71 //
72 // \exception std::runtime_error Operation error detected.
73 */
DenseTest()74 DenseTest::DenseTest()
75 : mat_ ( 4UL, 6UL )
76 , tmat_( 6UL, 4UL )
77 {
78 testConstructors();
79 testAssignment();
80 testAddAssign();
81 testSubAssign();
82 testMultAssign();
83 testDivAssign();
84 testCrossAssign();
85 testScaling();
86 testSubscript();
87 testIterator();
88 testNonZeros();
89 testReset();
90 testClear();
91 testIsDefault();
92 testIsSame();
93 testSubvector();
94 testElements();
95 }
96 //*************************************************************************************************
97
98
99
100
101 //=================================================================================================
102 //
103 // TEST FUNCTIONS
104 //
105 //=================================================================================================
106
107 //*************************************************************************************************
108 /*!\brief Test of the Band constructors.
109 //
110 // \return void
111 // \exception std::runtime_error Error detected.
112 //
113 // This function performs a test of all constructors of the Band specialization. In case an
114 // error is detected, a \a std::runtime_error exception is thrown.
115 */
testConstructors()116 void DenseTest::testConstructors()
117 {
118 //=====================================================================================
119 // Row-major matrix tests
120 //=====================================================================================
121
122 {
123 test_ = "Row-major Band constructor (0x0)";
124
125 MT mat;
126
127 // 1st lower matrix band
128 try {
129 blaze::band( mat, -1L );
130 }
131 catch( std::invalid_argument& ) {}
132
133 // 0th matrix band (diagonal)
134 {
135 BT band0 = blaze::band( mat, 0L );
136
137 checkSize ( band0, 0UL );
138 checkCapacity( band0, 0UL );
139 checkNonZeros( band0, 0UL );
140 }
141
142 // 1st upper matrix band
143 try {
144 blaze::band( mat, 1L );
145 }
146 catch( std::invalid_argument& ) {}
147 }
148
149 {
150 test_ = "Row-major Band constructor (0x2)";
151
152 MT mat( 0UL, 2UL );
153
154 // 1st lower matrix band
155 try {
156 blaze::band( mat, -1L );
157 }
158 catch( std::invalid_argument& ) {}
159
160 // 0th matrix band (diagonal)
161 {
162 BT band0 = blaze::band( mat, 0L );
163
164 checkSize ( band0, 0UL );
165 checkCapacity( band0, 0UL );
166 checkNonZeros( band0, 0UL );
167 }
168
169 // 1st upper matrix
170 {
171 BT band1 = blaze::band( mat, 1L );
172
173 checkSize ( band1, 0UL );
174 checkCapacity( band1, 0UL );
175 checkNonZeros( band1, 0UL );
176 }
177
178 // 2nd upper matrix band
179 try {
180 blaze::band( mat, 2L );
181 }
182 catch( std::invalid_argument& ) {}
183 }
184
185 {
186 test_ = "Row-major Band constructor (2x0)";
187
188 MT mat( 2UL, 0UL );
189
190 // 2nd lower matrix band
191 try {
192 blaze::band( mat, -2L );
193 }
194 catch( std::invalid_argument& ) {}
195
196 // 1st lower matrix band
197 {
198 BT band1 = blaze::band( mat, -1L );
199
200 checkSize ( band1, 0UL );
201 checkCapacity( band1, 0UL );
202 checkNonZeros( band1, 0UL );
203 }
204
205 // 0th matrix band (diagonal)
206 {
207 BT band0 = blaze::band( mat, 0L );
208
209 checkSize ( band0, 0UL );
210 checkCapacity( band0, 0UL );
211 checkNonZeros( band0, 0UL );
212 }
213
214 // 1st upper matrix band
215 try {
216 blaze::band( mat, 1L );
217 }
218 catch( std::invalid_argument& ) {}
219 }
220
221 {
222 test_ = "Row-major Band constructor (4x6)";
223
224 initialize();
225
226 // 4th lower matrix band
227 try {
228 blaze::band( mat_, -4L );
229 }
230 catch( std::invalid_argument& ) {}
231
232 // 3rd lower matrix band
233 {
234 BT band3 = blaze::band( mat_, -3L );
235
236 checkSize ( band3, 1UL );
237 checkCapacity( band3, 1UL );
238 checkNonZeros( band3, 0UL );
239
240 if( band3[0] != 0 ) {
241 std::ostringstream oss;
242 oss << " Test: " << test_ << "\n"
243 << " Error: Setup of 3rd lower band failed\n"
244 << " Details:\n"
245 << " Result:\n" << band3 << "\n"
246 << " Expected result:\n( 0 )\n";
247 throw std::runtime_error( oss.str() );
248 }
249 }
250
251 // 2nd lower matrix band
252 {
253 BT band2 = blaze::band( mat_, -2L );
254
255 checkSize ( band2, 2UL );
256 checkCapacity( band2, 2UL );
257 checkNonZeros( band2, 0UL );
258
259 if( band2[0] != 0 || band2[1] != 0 ) {
260 std::ostringstream oss;
261 oss << " Test: " << test_ << "\n"
262 << " Error: Setup of 2nd lower band failed\n"
263 << " Details:\n"
264 << " Result:\n" << band2 << "\n"
265 << " Expected result:\n( 0 0 )\n";
266 throw std::runtime_error( oss.str() );
267 }
268 }
269
270 // 1st lower matrix band
271 {
272 BT band1 = blaze::band( mat_, -1L );
273
274 checkSize ( band1, 3UL );
275 checkCapacity( band1, 3UL );
276 checkNonZeros( band1, 1UL );
277
278 if( band1[0] != 0 || band1[1] != 1 || band1[2] != 0 ) {
279 std::ostringstream oss;
280 oss << " Test: " << test_ << "\n"
281 << " Error: Setup of 1st lower band failed\n"
282 << " Details:\n"
283 << " Result:\n" << band1 << "\n"
284 << " Expected result:\n( 0 1 0 )\n";
285 throw std::runtime_error( oss.str() );
286 }
287 }
288
289 // 0th matrix band (diagonal)
290 {
291 BT band0 = blaze::band( mat_, 0L );
292
293 checkSize ( band0, 4UL );
294 checkCapacity( band0, 4UL );
295 checkNonZeros( band0, 2UL );
296
297 if( band0[0] != -2 || band0[1] != 0 || band0[2] != -3 || band0[3] != 0 ) {
298 std::ostringstream oss;
299 oss << " Test: " << test_ << "\n"
300 << " Error: Setup of 0th band (diagonal) failed\n"
301 << " Details:\n"
302 << " Result:\n" << band0 << "\n"
303 << " Expected result:\n( -2 0 -3 0 )\n";
304 throw std::runtime_error( oss.str() );
305 }
306 }
307
308 // 1st upper matrix band
309 {
310 BT band1 = blaze::band( mat_, 1L );
311
312 checkSize ( band1, 4UL );
313 checkCapacity( band1, 4UL );
314 checkNonZeros( band1, 3UL );
315
316 if( band1[0] != 0 || band1[1] != 4 || band1[2] != 5 || band1[3] != -6 ) {
317 std::ostringstream oss;
318 oss << " Test: " << test_ << "\n"
319 << " Error: Setup of 1st upper band failed\n"
320 << " Details:\n"
321 << " Result:\n" << band1 << "\n"
322 << " Expected result:\n( 0 4 5 -6 )\n";
323 throw std::runtime_error( oss.str() );
324 }
325 }
326
327 // 2nd upper matrix band
328 {
329 BT band2 = blaze::band( mat_, 2L );
330
331 checkSize ( band2, 4UL );
332 checkCapacity( band2, 4UL );
333 checkNonZeros( band2, 4UL );
334
335 if( band2[0] != 7 || band2[1] != -8 || band2[2] != 9 || band2[3] != 10 ) {
336 std::ostringstream oss;
337 oss << " Test: " << test_ << "\n"
338 << " Error: Setup of 2nd upper band failed\n"
339 << " Details:\n"
340 << " Result:\n" << band2 << "\n"
341 << " Expected result:\n( 7 -8 9 10 )\n";
342 throw std::runtime_error( oss.str() );
343 }
344 }
345
346 // 3rd upper matrix band
347 {
348 BT band3 = blaze::band( mat_, 3L );
349
350 checkSize ( band3, 3UL );
351 checkCapacity( band3, 3UL );
352 checkNonZeros( band3, 0UL );
353
354 if( band3[0] != 0 || band3[1] != 0 || band3[2] != 0 ) {
355 std::ostringstream oss;
356 oss << " Test: " << test_ << "\n"
357 << " Error: Setup of 3rd upper band failed\n"
358 << " Details:\n"
359 << " Result:\n" << band3 << "\n"
360 << " Expected result:\n( 0 0 0 )\n";
361 throw std::runtime_error( oss.str() );
362 }
363 }
364
365 // 4th upper matrix band
366 {
367 BT band4 = blaze::band( mat_, 4L );
368
369 checkSize ( band4, 2UL );
370 checkCapacity( band4, 2UL );
371 checkNonZeros( band4, 0UL );
372
373 if( band4[0] != 0 || band4[1] != 0 ) {
374 std::ostringstream oss;
375 oss << " Test: " << test_ << "\n"
376 << " Error: Setup of 4th upper band failed\n"
377 << " Details:\n"
378 << " Result:\n" << band4 << "\n"
379 << " Expected result:\n( 0 0 )\n";
380 throw std::runtime_error( oss.str() );
381 }
382 }
383
384 // 5th upper matrix band
385 {
386 BT band5 = blaze::band( mat_, 5L );
387
388 checkSize ( band5, 1UL );
389 checkCapacity( band5, 1UL );
390 checkNonZeros( band5, 0UL );
391
392 if( band5[0] != 0 ) {
393 std::ostringstream oss;
394 oss << " Test: " << test_ << "\n"
395 << " Error: Setup of 5th upper band failed\n"
396 << " Details:\n"
397 << " Result:\n" << band5 << "\n"
398 << " Expected result:\n( 0 )\n";
399 throw std::runtime_error( oss.str() );
400 }
401 }
402
403 // 6th upper matrix band
404 try {
405 blaze::band( mat_, 6L );
406 }
407 catch( std::invalid_argument& ) {}
408 }
409
410
411 //=====================================================================================
412 // Column-major matrix tests
413 //=====================================================================================
414
415 {
416 test_ = "Column-major Band constructor (0x0)";
417
418 OMT tmat;
419
420 // 1st lower matrix band
421 try {
422 blaze::band( tmat, -1L );
423 }
424 catch( std::invalid_argument& ) {}
425
426 // 0th matrix band (diagonal)
427 {
428 OBT band0 = blaze::band( tmat, 0L );
429
430 checkSize ( band0, 0UL );
431 checkCapacity( band0, 0UL );
432 checkNonZeros( band0, 0UL );
433 }
434
435 // 1st upper matrix band
436 try {
437 blaze::band( tmat, 1L );
438 }
439 catch( std::invalid_argument& ) {}
440 }
441
442 {
443 test_ = "Column-major Band constructor (0x2)";
444
445 OMT tmat( 0UL, 2UL );
446
447 // 1st lower matrix band
448 try {
449 blaze::band( tmat, -1L );
450 }
451 catch( std::invalid_argument& ) {}
452
453 // 0th matrix band (diagonal)
454 {
455 OBT band0 = blaze::band( tmat, 0L );
456
457 checkSize ( band0, 0UL );
458 checkCapacity( band0, 0UL );
459 checkNonZeros( band0, 0UL );
460 }
461
462 // 1st upper matrix
463 {
464 OBT band1 = blaze::band( tmat, 1L );
465
466 checkSize ( band1, 0UL );
467 checkCapacity( band1, 0UL );
468 checkNonZeros( band1, 0UL );
469 }
470
471 // 2nd upper matrix band
472 try {
473 blaze::band( tmat, 2L );
474 }
475 catch( std::invalid_argument& ) {}
476 }
477
478 {
479 test_ = "Column-major Band constructor (2x0)";
480
481 OMT tmat( 2UL, 0UL );
482
483 // 2nd lower matrix band
484 try {
485 blaze::band( tmat, -2L );
486 }
487 catch( std::invalid_argument& ) {}
488
489 // 1st lower matrix band
490 {
491 OBT band1 = blaze::band( tmat, -1L );
492
493 checkSize ( band1, 0UL );
494 checkCapacity( band1, 0UL );
495 checkNonZeros( band1, 0UL );
496 }
497
498 // 0th matrix band (diagonal)
499 {
500 OBT band0 = blaze::band( tmat, 0L );
501
502 checkSize ( band0, 0UL );
503 checkCapacity( band0, 0UL );
504 checkNonZeros( band0, 0UL );
505 }
506
507 // 1st upper matrix band
508 try {
509 blaze::band( tmat, 1L );
510 }
511 catch( std::invalid_argument& ) {}
512 }
513
514 {
515 test_ = "Column-major Band constructor (6x4)";
516
517 initialize();
518
519 // 6th lower matrix band
520 try {
521 blaze::band( tmat_, -6L );
522 }
523 catch( std::invalid_argument& ) {}
524
525 // 5th lower matrix band
526 {
527 OBT band5 = blaze::band( tmat_, -5L );
528
529 checkSize ( band5, 1UL );
530 checkCapacity( band5, 1UL );
531 checkNonZeros( band5, 0UL );
532
533 if( band5[0] != 0 ) {
534 std::ostringstream oss;
535 oss << " Test: " << test_ << "\n"
536 << " Error: Setup of 5th lower band failed\n"
537 << " Details:\n"
538 << " Result:\n" << band5 << "\n"
539 << " Expected result:\n( 0 )\n";
540 throw std::runtime_error( oss.str() );
541 }
542 }
543
544 // 4th lower matrix band
545 {
546 OBT band4 = blaze::band( tmat_, -4L );
547
548 checkSize ( band4, 2UL );
549 checkCapacity( band4, 2UL );
550 checkNonZeros( band4, 0UL );
551
552 if( band4[0] != 0 || band4[1] != 0 ) {
553 std::ostringstream oss;
554 oss << " Test: " << test_ << "\n"
555 << " Error: Setup of 4th lower band failed\n"
556 << " Details:\n"
557 << " Result:\n" << band4 << "\n"
558 << " Expected result:\n( 0 0 )\n";
559 throw std::runtime_error( oss.str() );
560 }
561 }
562
563 // 3rd lower matrix band
564 {
565 OBT band3 = blaze::band( tmat_, -3L );
566
567 checkSize ( band3, 3UL );
568 checkCapacity( band3, 3UL );
569 checkNonZeros( band3, 0UL );
570
571 if( band3[0] != 0 || band3[1] != 0 || band3[2] != 0 ) {
572 std::ostringstream oss;
573 oss << " Test: " << test_ << "\n"
574 << " Error: Setup of 3rd lower band failed\n"
575 << " Details:\n"
576 << " Result:\n" << band3 << "\n"
577 << " Expected result:\n( 0 0 0 )\n";
578 throw std::runtime_error( oss.str() );
579 }
580 }
581
582 // 2nd lower matrix band
583 {
584 OBT band2 = blaze::band( tmat_, -2L );
585
586 checkSize ( band2, 4UL );
587 checkCapacity( band2, 4UL );
588 checkNonZeros( band2, 4UL );
589
590 if( band2[0] != 7 || band2[1] != -8 || band2[2] != 9 || band2[3] != 10 ) {
591 std::ostringstream oss;
592 oss << " Test: " << test_ << "\n"
593 << " Error: Setup of 2nd lower band failed\n"
594 << " Details:\n"
595 << " Result:\n" << band2 << "\n"
596 << " Expected result:\n( 7 -8 9 10 )\n";
597 throw std::runtime_error( oss.str() );
598 }
599 }
600
601 // 1st lower matrix band
602 {
603 OBT band1 = blaze::band( tmat_, -1L );
604
605 checkSize ( band1, 4UL );
606 checkCapacity( band1, 4UL );
607 checkNonZeros( band1, 3UL );
608
609 if( band1[0] != 0 || band1[1] != 4 || band1[2] != 5 || band1[3] != -6 ) {
610 std::ostringstream oss;
611 oss << " Test: " << test_ << "\n"
612 << " Error: Setup of 1st lower band failed\n"
613 << " Details:\n"
614 << " Result:\n" << band1 << "\n"
615 << " Expected result:\n( 0 4 5 -6 )\n";
616 throw std::runtime_error( oss.str() );
617 }
618 }
619
620 // 0th matrix band (diagonal)
621 {
622 OBT band0 = blaze::band( tmat_, 0L );
623
624 checkSize ( band0, 4UL );
625 checkCapacity( band0, 4UL );
626 checkNonZeros( band0, 2UL );
627
628 if( band0[0] != -2 || band0[1] != 0 || band0[2] != -3 || band0[3] != 0 ) {
629 std::ostringstream oss;
630 oss << " Test: " << test_ << "\n"
631 << " Error: Setup of 0th band (diagonal) failed\n"
632 << " Details:\n"
633 << " Result:\n" << band0 << "\n"
634 << " Expected result:\n( -2 0 -3 0 )\n";
635 throw std::runtime_error( oss.str() );
636 }
637 }
638
639 // 1st upper matrix band
640 {
641 OBT band1 = blaze::band( tmat_, 1L );
642
643 checkSize ( band1, 3UL );
644 checkCapacity( band1, 3UL );
645 checkNonZeros( band1, 1UL );
646
647 if( band1[0] != 0 || band1[1] != 1 || band1[2] != 0 ) {
648 std::ostringstream oss;
649 oss << " Test: " << test_ << "\n"
650 << " Error: Setup of 1st upper band failed\n"
651 << " Details:\n"
652 << " Result:\n" << band1 << "\n"
653 << " Expected result:\n( 0 1 0 )\n";
654 throw std::runtime_error( oss.str() );
655 }
656 }
657
658 // 2nd upper matrix band
659 {
660 OBT band2 = blaze::band( tmat_, 2L );
661
662 checkSize ( band2, 2UL );
663 checkCapacity( band2, 2UL );
664 checkNonZeros( band2, 0UL );
665
666 if( band2[0] != 0 || band2[1] != 0 ) {
667 std::ostringstream oss;
668 oss << " Test: " << test_ << "\n"
669 << " Error: Setup of 2nd upper band failed\n"
670 << " Details:\n"
671 << " Result:\n" << band2 << "\n"
672 << " Expected result:\n( 0 0 )\n";
673 throw std::runtime_error( oss.str() );
674 }
675 }
676
677 // 3rd upper matrix band
678 {
679 OBT band3 = blaze::band( tmat_, 3L );
680
681 checkSize ( band3, 1UL );
682 checkCapacity( band3, 1UL );
683 checkNonZeros( band3, 0UL );
684
685 if( band3[0] != 0 ) {
686 std::ostringstream oss;
687 oss << " Test: " << test_ << "\n"
688 << " Error: Setup of 3rd upper band failed\n"
689 << " Details:\n"
690 << " Result:\n" << band3 << "\n"
691 << " Expected result:\n( 0 )\n";
692 throw std::runtime_error( oss.str() );
693 }
694 }
695
696 // 4th upper matrix band
697 try {
698 blaze::band( tmat_, 4L );
699 }
700 catch( std::invalid_argument& ) {}
701 }
702 }
703 //*************************************************************************************************
704
705
706 //*************************************************************************************************
707 /*!\brief Test of the Band assignment operators.
708 //
709 // \return void
710 // \exception std::runtime_error Error detected.
711 //
712 // This function performs a test of all assignment operators of the Band specialization.
713 // In case an error is detected, a \a std::runtime_error exception is thrown.
714 */
testAssignment()715 void DenseTest::testAssignment()
716 {
717 //=====================================================================================
718 // Row-major homogeneous assignment
719 //=====================================================================================
720
721 {
722 test_ = "Row-major Band homogeneous assignment";
723
724 initialize();
725
726 BT band1 = blaze::band( mat_, -1L );
727 band1 = 8;
728
729 checkSize ( band1, 3UL );
730 checkCapacity( band1, 3UL );
731 checkNonZeros( band1, 3UL );
732 checkRows ( mat_ , 4UL );
733 checkColumns ( mat_ , 6UL );
734 checkNonZeros( mat_ , 12UL );
735
736 if( band1[0] != 8 || band1[1] != 8 || band1[2] != 8 ) {
737 std::ostringstream oss;
738 oss << " Test: " << test_ << "\n"
739 << " Error: Assignment failed\n"
740 << " Details:\n"
741 << " Result:\n" << band1 << "\n"
742 << " Expected result:\n( 8 8 8 )\n";
743 throw std::runtime_error( oss.str() );
744 }
745
746 if( mat_(0,0) != -2 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
747 mat_(1,0) != 8 || mat_(1,1) != 0 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
748 mat_(2,0) != 0 || mat_(2,1) != 8 || mat_(2,2) != -3 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
749 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 8 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
750 std::ostringstream oss;
751 oss << " Test: " << test_ << "\n"
752 << " Error: Assignment failed\n"
753 << " Details:\n"
754 << " Result:\n" << mat_ << "\n"
755 << " Expected result:\n( -2 0 7 0 0 0 )\n"
756 "( 8 0 4 -8 0 0 )\n"
757 "( 0 8 -3 5 9 0 )\n"
758 "( 0 0 8 0 -6 10 )\n";
759 throw std::runtime_error( oss.str() );
760 }
761 }
762
763
764 //=====================================================================================
765 // Row-major list assignment
766 //=====================================================================================
767
768 {
769 test_ = "Row-major initializer list assignment (complete list)";
770
771 initialize();
772
773 BT band1 = blaze::band( mat_, 1L );
774 band1 = { 1, 2, 3, 4 };
775
776 checkSize ( band1, 4UL );
777 checkCapacity( band1, 4UL );
778 checkNonZeros( band1, 4UL );
779 checkRows ( mat_ , 4UL );
780 checkColumns ( mat_ , 6UL );
781 checkNonZeros( mat_ , 11UL );
782
783 if( band1[0] != 1 || band1[1] != 2 || band1[2] != 3 || band1[3] != 4 ) {
784 std::ostringstream oss;
785 oss << " Test: " << test_ << "\n"
786 << " Error: Assignment failed\n"
787 << " Details:\n"
788 << " Result:\n" << band1 << "\n"
789 << " Expected result:\n( 1 2 3 4 )\n";
790 throw std::runtime_error( oss.str() );
791 }
792
793 if( mat_(0,0) != -2 || mat_(0,1) != 1 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
794 mat_(1,0) != 0 || mat_(1,1) != 0 || mat_(1,2) != 2 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
795 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != -3 || mat_(2,3) != 3 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
796 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != 4 || mat_(3,5) != 10 ) {
797 std::ostringstream oss;
798 oss << " Test: " << test_ << "\n"
799 << " Error: Assignment failed\n"
800 << " Details:\n"
801 << " Result:\n" << mat_ << "\n"
802 << " Expected result:\n( -2 1 7 0 0 0 )\n"
803 "( 0 0 2 -8 0 0 )\n"
804 "( 0 1 -3 3 9 0 )\n"
805 "( 0 0 0 0 4 10 )\n";
806 throw std::runtime_error( oss.str() );
807 }
808 }
809
810 {
811 test_ = "Row-major initializer list assignment (incomplete list)";
812
813 initialize();
814
815 BT band1 = blaze::band( mat_, 1L );
816 band1 = { 1, 2 };
817
818 checkSize ( band1, 4UL );
819 checkCapacity( band1, 4UL );
820 checkNonZeros( band1, 2UL );
821 checkRows ( mat_ , 4UL );
822 checkColumns ( mat_ , 6UL );
823 checkNonZeros( mat_ , 9UL );
824
825 if( band1[0] != 1 || band1[1] != 2 || band1[2] != 0 || band1[3] != 0 ) {
826 std::ostringstream oss;
827 oss << " Test: " << test_ << "\n"
828 << " Error: Assignment failed\n"
829 << " Details:\n"
830 << " Result:\n" << band1 << "\n"
831 << " Expected result:\n( 1 2 0 0 )\n";
832 throw std::runtime_error( oss.str() );
833 }
834
835 if( mat_(0,0) != -2 || mat_(0,1) != 1 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
836 mat_(1,0) != 0 || mat_(1,1) != 0 || mat_(1,2) != 2 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
837 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != -3 || mat_(2,3) != 0 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
838 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != 0 || mat_(3,5) != 10 ) {
839 std::ostringstream oss;
840 oss << " Test: " << test_ << "\n"
841 << " Error: Assignment failed\n"
842 << " Details:\n"
843 << " Result:\n" << mat_ << "\n"
844 << " Expected result:\n( -2 1 7 0 0 0 )\n"
845 "( 0 0 2 -8 0 0 )\n"
846 "( 0 1 -3 0 9 0 )\n"
847 "( 0 0 0 0 0 10 )\n";
848 throw std::runtime_error( oss.str() );
849 }
850 }
851
852
853 //=====================================================================================
854 // Row-major copy assignment
855 //=====================================================================================
856
857 {
858 test_ = "Row-major Band copy assignment";
859
860 initialize();
861
862 BT band0 = blaze::band( mat_, 0L );
863 band0 = blaze::band( mat_, 1L );
864
865 checkSize ( band0, 4UL );
866 checkCapacity( band0, 4UL );
867 checkNonZeros( band0, 3UL );
868 checkRows ( mat_ , 4UL );
869 checkColumns ( mat_ , 6UL );
870 checkNonZeros( mat_ , 11UL );
871
872 if( band0[0] != 0 || band0[1] != 4 || band0[2] != 5 || band0[3] != -6 ) {
873 std::ostringstream oss;
874 oss << " Test: " << test_ << "\n"
875 << " Error: Assignment failed\n"
876 << " Details:\n"
877 << " Result:\n" << band0 << "\n"
878 << " Expected result:\n( 0 4 5 -6 )\n";
879 throw std::runtime_error( oss.str() );
880 }
881
882 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
883 mat_(1,0) != 0 || mat_(1,1) != 4 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
884 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != 5 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
885 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != -6 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
886 std::ostringstream oss;
887 oss << " Test: " << test_ << "\n"
888 << " Error: Assignment failed\n"
889 << " Details:\n"
890 << " Result:\n" << mat_ << "\n"
891 << " Expected result:\n( 0 0 7 0 0 0 )\n"
892 "( 0 4 4 -8 0 0 )\n"
893 "( 0 1 5 5 9 0 )\n"
894 "( 0 0 0 -6 -6 10 )\n";
895 throw std::runtime_error( oss.str() );
896 }
897 }
898
899
900 //=====================================================================================
901 // Row-major dense vector assignment
902 //=====================================================================================
903
904 {
905 test_ = "Row-major dense vector assignment (mixed type)";
906
907 initialize();
908
909 BT band1 = blaze::band( mat_, -1L );
910
911 const blaze::DynamicVector<short,blaze::columnVector> vec1{ 8, 0, 9 };
912
913 band1 = vec1;
914
915 checkSize ( band1, 3UL );
916 checkCapacity( band1, 3UL );
917 checkNonZeros( band1, 2UL );
918 checkRows ( mat_ , 4UL );
919 checkColumns ( mat_ , 6UL );
920 checkNonZeros( mat_ , 11UL );
921
922 if( band1[0] != 8 || band1[1] != 0 || band1[2] != 9 ) {
923 std::ostringstream oss;
924 oss << " Test: " << test_ << "\n"
925 << " Error: Assignment failed\n"
926 << " Details:\n"
927 << " Result:\n" << band1 << "\n"
928 << " Expected result:\n( 8 0 9 )\n";
929 throw std::runtime_error( oss.str() );
930 }
931
932 if( mat_(0,0) != -2 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
933 mat_(1,0) != 8 || mat_(1,1) != 0 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
934 mat_(2,0) != 0 || mat_(2,1) != 0 || mat_(2,2) != -3 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
935 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 9 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
936 std::ostringstream oss;
937 oss << " Test: " << test_ << "\n"
938 << " Error: Assignment failed\n"
939 << " Details:\n"
940 << " Result:\n" << mat_ << "\n"
941 << " Expected result:\n( -2 0 7 0 0 0 )\n"
942 "( 8 0 4 -8 0 0 )\n"
943 "( 0 0 -3 5 9 0 )\n"
944 "( 0 0 9 0 -6 10 )\n";
945 throw std::runtime_error( oss.str() );
946 }
947 }
948
949 {
950 test_ = "Row-major dense vector assignment (aligned/padded)";
951
952 using blaze::aligned;
953 using blaze::padded;
954 using blaze::columnVector;
955
956 initialize();
957
958 BT band1 = blaze::band( mat_, -1L );
959
960 using AlignedPadded = blaze::CustomVector<int,aligned,padded,columnVector>;
961 std::unique_ptr<int[],blaze::Deallocate> memory( blaze::allocate<int>( 16UL ) );
962 AlignedPadded vec1( memory.get(), 3UL, 16UL );
963 vec1[0] = 8;
964 vec1[1] = 0;
965 vec1[2] = 9;
966
967 band1 = vec1;
968
969 checkSize ( band1, 3UL );
970 checkCapacity( band1, 3UL );
971 checkNonZeros( band1, 2UL );
972 checkRows ( mat_ , 4UL );
973 checkColumns ( mat_ , 6UL );
974 checkNonZeros( mat_ , 11UL );
975
976 if( band1[0] != 8 || band1[1] != 0 || band1[2] != 9 ) {
977 std::ostringstream oss;
978 oss << " Test: " << test_ << "\n"
979 << " Error: Assignment failed\n"
980 << " Details:\n"
981 << " Result:\n" << band1 << "\n"
982 << " Expected result:\n( 8 0 9 )\n";
983 throw std::runtime_error( oss.str() );
984 }
985
986 if( mat_(0,0) != -2 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
987 mat_(1,0) != 8 || mat_(1,1) != 0 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
988 mat_(2,0) != 0 || mat_(2,1) != 0 || mat_(2,2) != -3 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
989 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 9 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
990 std::ostringstream oss;
991 oss << " Test: " << test_ << "\n"
992 << " Error: Assignment failed\n"
993 << " Details:\n"
994 << " Result:\n" << mat_ << "\n"
995 << " Expected result:\n( -2 0 7 0 0 0 )\n"
996 "( 8 0 4 -8 0 0 )\n"
997 "( 0 0 -3 5 9 0 )\n"
998 "( 0 0 9 0 -6 10 )\n";
999 throw std::runtime_error( oss.str() );
1000 }
1001 }
1002
1003 {
1004 test_ = "Row-major dense vector assignment (unaligned/unpadded)";
1005
1006 using blaze::unaligned;
1007 using blaze::unpadded;
1008 using blaze::columnVector;
1009
1010 initialize();
1011
1012 BT band1 = blaze::band( mat_, -1L );
1013
1014 using UnalignedUnpadded = blaze::CustomVector<int,unaligned,unpadded,columnVector>;
1015 std::unique_ptr<int[]> memory( new int[4] );
1016 UnalignedUnpadded vec1( memory.get()+1UL, 3UL );
1017 vec1[0] = 8;
1018 vec1[1] = 0;
1019 vec1[2] = 9;
1020
1021 band1 = vec1;
1022
1023 checkSize ( band1, 3UL );
1024 checkCapacity( band1, 3UL );
1025 checkNonZeros( band1, 2UL );
1026 checkRows ( mat_ , 4UL );
1027 checkColumns ( mat_ , 6UL );
1028 checkNonZeros( mat_ , 11UL );
1029
1030 if( band1[0] != 8 || band1[1] != 0 || band1[2] != 9 ) {
1031 std::ostringstream oss;
1032 oss << " Test: " << test_ << "\n"
1033 << " Error: Assignment failed\n"
1034 << " Details:\n"
1035 << " Result:\n" << band1 << "\n"
1036 << " Expected result:\n( 8 0 9 )\n";
1037 throw std::runtime_error( oss.str() );
1038 }
1039
1040 if( mat_(0,0) != -2 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
1041 mat_(1,0) != 8 || mat_(1,1) != 0 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
1042 mat_(2,0) != 0 || mat_(2,1) != 0 || mat_(2,2) != -3 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
1043 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 9 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
1044 std::ostringstream oss;
1045 oss << " Test: " << test_ << "\n"
1046 << " Error: Assignment failed\n"
1047 << " Details:\n"
1048 << " Result:\n" << mat_ << "\n"
1049 << " Expected result:\n( -2 0 7 0 0 0 )\n"
1050 "( 8 0 4 -8 0 0 )\n"
1051 "( 0 0 -3 5 9 0 )\n"
1052 "( 0 0 9 0 -6 10 )\n";
1053 throw std::runtime_error( oss.str() );
1054 }
1055 }
1056
1057
1058 //=====================================================================================
1059 // Row-major sparse vector assignment
1060 //=====================================================================================
1061
1062 {
1063 test_ = "Row-major sparse vector assignment";
1064
1065 initialize();
1066
1067 BT band2 = blaze::band( mat_, 2L );
1068
1069 blaze::CompressedVector<int,blaze::columnVector> vec1( 4UL );
1070 vec1[3] = 9;
1071
1072 band2 = vec1;
1073
1074 checkSize ( band2, 4UL );
1075 checkCapacity( band2, 4UL );
1076 checkNonZeros( band2, 1UL );
1077 checkRows ( mat_ , 4UL );
1078 checkColumns ( mat_ , 6UL );
1079 checkNonZeros( mat_ , 7UL );
1080
1081 if( band2[0] != 0 || band2[1] != 0 || band2[2] != 0 || band2[3] != 9 ) {
1082 std::ostringstream oss;
1083 oss << " Test: " << test_ << "\n"
1084 << " Error: Assignment failed\n"
1085 << " Details:\n"
1086 << " Result:\n" << band2 << "\n"
1087 << " Expected result:\n( 0 0 0 9 )\n";
1088 throw std::runtime_error( oss.str() );
1089 }
1090
1091 if( mat_(0,0) != -2 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
1092 mat_(1,0) != 0 || mat_(1,1) != 0 || mat_(1,2) != 4 || mat_(1,3) != 0 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
1093 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != -3 || mat_(2,3) != 5 || mat_(2,4) != 0 || mat_(2,5) != 0 ||
1094 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 9 ) {
1095 std::ostringstream oss;
1096 oss << " Test: " << test_ << "\n"
1097 << " Error: Assignment failed\n"
1098 << " Details:\n"
1099 << " Result:\n" << mat_ << "\n"
1100 << " Expected result:\n( -2 0 0 0 0 0 )\n"
1101 "( 0 0 4 0 0 0 )\n"
1102 "( 0 1 -3 5 0 0 )\n"
1103 "( 0 0 0 0 -6 9 )\n";
1104 throw std::runtime_error( oss.str() );
1105 }
1106 }
1107
1108
1109 //=====================================================================================
1110 // Column-major homogeneous assignment
1111 //=====================================================================================
1112
1113 {
1114 test_ = "Column-major Band homogeneous assignment";
1115
1116 initialize();
1117
1118 OBT band1 = blaze::band( tmat_, 1L );
1119 band1 = 8;
1120
1121 checkSize ( band1, 3UL );
1122 checkCapacity( band1, 3UL );
1123 checkNonZeros( band1, 3UL );
1124 checkRows ( tmat_, 6UL );
1125 checkColumns ( tmat_, 4UL );
1126 checkNonZeros( tmat_, 12UL );
1127
1128 if( band1[0] != 8 || band1[1] != 8 || band1[2] != 8 ) {
1129 std::ostringstream oss;
1130 oss << " Test: " << test_ << "\n"
1131 << " Error: Assignment failed\n"
1132 << " Details:\n"
1133 << " Result:\n" << band1 << "\n"
1134 << " Expected result:\n( 8 8 8 )\n";
1135 throw std::runtime_error( oss.str() );
1136 }
1137
1138 if( tmat_(0,0) != -2 || tmat_(0,1) != 8 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
1139 tmat_(1,0) != 0 || tmat_(1,1) != 0 || tmat_(1,2) != 8 || tmat_(1,3) != 0 ||
1140 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != -3 || tmat_(2,3) != 8 ||
1141 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
1142 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
1143 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
1144 std::ostringstream oss;
1145 oss << " Test: " << test_ << "\n"
1146 << " Error: Assignment failed\n"
1147 << " Details:\n"
1148 << " Result:\n" << tmat_ << "\n"
1149 << " Expected result:\n( -2 8 0 0 )\n"
1150 "( 0 0 8 0 )\n"
1151 "( 7 4 -3 8 )\n"
1152 "( 0 -8 5 0 )\n"
1153 "( 0 0 9 -6 )\n"
1154 "( 0 0 0 10 )\n";
1155 throw std::runtime_error( oss.str() );
1156 }
1157 }
1158
1159
1160 //=====================================================================================
1161 // Column-major list assignment
1162 //=====================================================================================
1163
1164 {
1165 test_ = "Column-major initializer list assignment (complete list)";;
1166
1167 initialize();
1168
1169 OBT band1 = blaze::band( tmat_, -1L );
1170 band1 = { 1, 2, 3, 4 };
1171
1172 checkSize ( band1, 4UL );
1173 checkCapacity( band1, 4UL );
1174 checkNonZeros( band1, 4UL );
1175 checkRows ( tmat_, 6UL );
1176 checkColumns ( tmat_, 4UL );
1177 checkNonZeros( tmat_, 11UL );
1178
1179 if( band1[0] != 1 || band1[1] != 2 || band1[2] != 3 || band1[3] != 4 ) {
1180 std::ostringstream oss;
1181 oss << " Test: " << test_ << "\n"
1182 << " Error: Assignment failed\n"
1183 << " Details:\n"
1184 << " Result:\n" << band1 << "\n"
1185 << " Expected result:\n( 1 2 3 4 )\n";
1186 throw std::runtime_error( oss.str() );
1187 }
1188
1189 if( tmat_(0,0) != -2 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
1190 tmat_(1,0) != 1 || tmat_(1,1) != 0 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
1191 tmat_(2,0) != 7 || tmat_(2,1) != 2 || tmat_(2,2) != -3 || tmat_(2,3) != 0 ||
1192 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 3 || tmat_(3,3) != 0 ||
1193 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != 4 ||
1194 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
1195 std::ostringstream oss;
1196 oss << " Test: " << test_ << "\n"
1197 << " Error: Assignment failed\n"
1198 << " Details:\n"
1199 << " Result:\n" << tmat_ << "\n"
1200 << " Expected result:\n( -2 0 0 0 )\n"
1201 "( 1 0 1 0 )\n"
1202 "( 7 2 -3 0 )\n"
1203 "( 0 -8 3 0 )\n"
1204 "( 0 0 9 4 )\n"
1205 "( 0 0 0 10 )\n";
1206 throw std::runtime_error( oss.str() );
1207 }
1208 }
1209
1210 {
1211 test_ = "Column-major initializer list assignment (incomplete list)";
1212
1213 initialize();
1214
1215 OBT band1 = blaze::band( tmat_, -1L );
1216 band1 = { 1, 2 };
1217
1218 checkSize ( band1, 4UL );
1219 checkCapacity( band1, 4UL );
1220 checkNonZeros( band1, 2UL );
1221 checkRows ( tmat_, 6UL );
1222 checkColumns ( tmat_, 4UL );
1223 checkNonZeros( tmat_, 9UL );
1224
1225 if( band1[0] != 1 || band1[1] != 2 || band1[2] != 0 || band1[3] != 0 ) {
1226 std::ostringstream oss;
1227 oss << " Test: " << test_ << "\n"
1228 << " Error: Assignment failed\n"
1229 << " Details:\n"
1230 << " Result:\n" << band1 << "\n"
1231 << " Expected result:\n( 1 2 0 0 )\n";
1232 throw std::runtime_error( oss.str() );
1233 }
1234
1235 if( tmat_(0,0) != -2 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
1236 tmat_(1,0) != 1 || tmat_(1,1) != 0 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
1237 tmat_(2,0) != 7 || tmat_(2,1) != 2 || tmat_(2,2) != -3 || tmat_(2,3) != 0 ||
1238 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 0 || tmat_(3,3) != 0 ||
1239 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != 0 ||
1240 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
1241 std::ostringstream oss;
1242 oss << " Test: " << test_ << "\n"
1243 << " Error: Assignment failed\n"
1244 << " Details:\n"
1245 << " Result:\n" << tmat_ << "\n"
1246 << " Expected result:\n( -2 0 0 0 )\n"
1247 "( 1 0 1 0 )\n"
1248 "( 7 2 -3 0 )\n"
1249 "( 0 -8 0 0 )\n"
1250 "( 0 0 9 0 )\n"
1251 "( 0 0 0 10 )\n";
1252 throw std::runtime_error( oss.str() );
1253 }
1254 }
1255
1256
1257 //=====================================================================================
1258 // Column-major copy assignment
1259 //=====================================================================================
1260
1261 {
1262 test_ = "Column-major Band copy assignment";
1263
1264 initialize();
1265
1266 OBT band0 = blaze::band( tmat_, 0L );
1267 band0 = blaze::band( tmat_, -1L );
1268
1269 checkSize ( band0, 4UL );
1270 checkCapacity( band0, 4UL );
1271 checkNonZeros( band0, 3UL );
1272 checkRows ( tmat_, 6UL );
1273 checkColumns ( tmat_, 4UL );
1274 checkNonZeros( tmat_, 11UL );
1275
1276 if( band0[0] != 0 || band0[1] != 4 || band0[2] != 5 || band0[3] != -6 ) {
1277 std::ostringstream oss;
1278 oss << " Test: " << test_ << "\n"
1279 << " Error: Assignment failed\n"
1280 << " Details:\n"
1281 << " Result:\n" << band0 << "\n"
1282 << " Expected result:\n( 0 4 5 -6 )\n";
1283 throw std::runtime_error( oss.str() );
1284 }
1285
1286 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
1287 tmat_(1,0) != 0 || tmat_(1,1) != 4 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
1288 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != 5 || tmat_(2,3) != 0 ||
1289 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != -6 ||
1290 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
1291 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
1292 std::ostringstream oss;
1293 oss << " Test: " << test_ << "\n"
1294 << " Error: Assignment failed\n"
1295 << " Details:\n"
1296 << " Result:\n" << tmat_ << "\n"
1297 << " Expected result:\n( 0 0 0 0 )\n"
1298 "( 0 4 1 0 )\n"
1299 "( 7 4 5 0 )\n"
1300 "( 0 -8 5 -6 )\n"
1301 "( 0 0 9 -6 )\n"
1302 "( 0 0 0 10 )\n";
1303 throw std::runtime_error( oss.str() );
1304 }
1305 }
1306
1307
1308 //=====================================================================================
1309 // Column-major dense vector assignment
1310 //=====================================================================================
1311
1312 {
1313 test_ = "Column-major dense vector assignment (mixed type)";
1314
1315 initialize();
1316
1317 OBT band1 = blaze::band( tmat_, 1L );
1318
1319 const blaze::DynamicVector<short,blaze::columnVector> vec1{ 8, 0, 9 };
1320
1321 band1 = vec1;
1322
1323 checkSize ( band1, 3UL );
1324 checkCapacity( band1, 3UL );
1325 checkNonZeros( band1, 2UL );
1326 checkRows ( tmat_, 6UL );
1327 checkColumns ( tmat_, 4UL );
1328 checkNonZeros( tmat_, 11UL );
1329
1330 if( band1[0] != 8 || band1[1] != 0 || band1[2] != 9 ) {
1331 std::ostringstream oss;
1332 oss << " Test: " << test_ << "\n"
1333 << " Error: Assignment failed\n"
1334 << " Details:\n"
1335 << " Result:\n" << band1 << "\n"
1336 << " Expected result:\n( 8 0 9 )\n";
1337 throw std::runtime_error( oss.str() );
1338 }
1339
1340 if( tmat_(0,0) != -2 || tmat_(0,1) != 8 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
1341 tmat_(1,0) != 0 || tmat_(1,1) != 0 || tmat_(1,2) != 0 || tmat_(1,3) != 0 ||
1342 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != -3 || tmat_(2,3) != 9 ||
1343 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
1344 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
1345 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
1346 std::ostringstream oss;
1347 oss << " Test: " << test_ << "\n"
1348 << " Error: Assignment failed\n"
1349 << " Details:\n"
1350 << " Result:\n" << tmat_ << "\n"
1351 << " Expected result:\n( -2 8 0 0 )\n"
1352 "( 0 0 0 0 )\n"
1353 "( 7 4 -3 9 )\n"
1354 "( 0 -8 5 0 )\n"
1355 "( 0 0 9 -6 )\n"
1356 "( 0 0 0 10 )\n";
1357 throw std::runtime_error( oss.str() );
1358 }
1359 }
1360
1361 {
1362 test_ = "Column-major dense vector assignment (aligned/padded)";
1363
1364 using blaze::aligned;
1365 using blaze::padded;
1366 using blaze::columnVector;
1367
1368 initialize();
1369
1370 OBT band1 = blaze::band( tmat_, 1L );
1371
1372 using AlignedPadded = blaze::CustomVector<int,aligned,padded,columnVector>;
1373 std::unique_ptr<int[],blaze::Deallocate> memory( blaze::allocate<int>( 16UL ) );
1374 AlignedPadded vec1( memory.get(), 3UL, 16UL );
1375 vec1[0] = 8;
1376 vec1[1] = 0;
1377 vec1[2] = 9;
1378
1379 band1 = vec1;
1380
1381 checkSize ( band1, 3UL );
1382 checkCapacity( band1, 3UL );
1383 checkNonZeros( band1, 2UL );
1384 checkRows ( tmat_, 6UL );
1385 checkColumns ( tmat_, 4UL );
1386 checkNonZeros( tmat_, 11UL );
1387
1388 if( band1[0] != 8 || band1[1] != 0 || band1[2] != 9 ) {
1389 std::ostringstream oss;
1390 oss << " Test: " << test_ << "\n"
1391 << " Error: Assignment failed\n"
1392 << " Details:\n"
1393 << " Result:\n" << band1 << "\n"
1394 << " Expected result:\n( 8 0 9 )\n";
1395 throw std::runtime_error( oss.str() );
1396 }
1397
1398 if( tmat_(0,0) != -2 || tmat_(0,1) != 8 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
1399 tmat_(1,0) != 0 || tmat_(1,1) != 0 || tmat_(1,2) != 0 || tmat_(1,3) != 0 ||
1400 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != -3 || tmat_(2,3) != 9 ||
1401 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
1402 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
1403 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
1404 std::ostringstream oss;
1405 oss << " Test: " << test_ << "\n"
1406 << " Error: Assignment failed\n"
1407 << " Details:\n"
1408 << " Result:\n" << tmat_ << "\n"
1409 << " Expected result:\n( -2 8 0 0 )\n"
1410 "( 0 0 0 0 )\n"
1411 "( 7 4 -3 9 )\n"
1412 "( 0 -8 5 0 )\n"
1413 "( 0 0 9 -6 )\n"
1414 "( 0 0 0 10 )\n";
1415 throw std::runtime_error( oss.str() );
1416 }
1417 }
1418
1419 {
1420 test_ = "Column-major dense vector assignment (unaligned/unpadded)";
1421
1422 using blaze::unaligned;
1423 using blaze::unpadded;
1424 using blaze::columnVector;
1425
1426 initialize();
1427
1428 OBT band1 = blaze::band( tmat_, 1L );
1429
1430 using UnalignedUnpadded = blaze::CustomVector<int,unaligned,unpadded,columnVector>;
1431 std::unique_ptr<int[]> memory( new int[4] );
1432 UnalignedUnpadded vec1( memory.get()+1UL, 3UL );
1433 vec1[0] = 8;
1434 vec1[1] = 0;
1435 vec1[2] = 9;
1436
1437 band1 = vec1;
1438
1439 checkSize ( band1, 3UL );
1440 checkCapacity( band1, 3UL );
1441 checkNonZeros( band1, 2UL );
1442 checkRows ( tmat_, 6UL );
1443 checkColumns ( tmat_, 4UL );
1444 checkNonZeros( tmat_, 11UL );
1445
1446 if( band1[0] != 8 || band1[1] != 0 || band1[2] != 9 ) {
1447 std::ostringstream oss;
1448 oss << " Test: " << test_ << "\n"
1449 << " Error: Assignment failed\n"
1450 << " Details:\n"
1451 << " Result:\n" << band1 << "\n"
1452 << " Expected result:\n( 8 0 9 )\n";
1453 throw std::runtime_error( oss.str() );
1454 }
1455
1456 if( tmat_(0,0) != -2 || tmat_(0,1) != 8 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
1457 tmat_(1,0) != 0 || tmat_(1,1) != 0 || tmat_(1,2) != 0 || tmat_(1,3) != 0 ||
1458 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != -3 || tmat_(2,3) != 9 ||
1459 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
1460 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
1461 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
1462 std::ostringstream oss;
1463 oss << " Test: " << test_ << "\n"
1464 << " Error: Assignment failed\n"
1465 << " Details:\n"
1466 << " Result:\n" << tmat_ << "\n"
1467 << " Expected result:\n( -2 8 0 0 )\n"
1468 "( 0 0 0 0 )\n"
1469 "( 7 4 -3 9 )\n"
1470 "( 0 -8 5 0 )\n"
1471 "( 0 0 9 -6 )\n"
1472 "( 0 0 0 10 )\n";
1473 throw std::runtime_error( oss.str() );
1474 }
1475 }
1476
1477
1478 //=====================================================================================
1479 // Column-major sparse vector assignment
1480 //=====================================================================================
1481
1482 {
1483 test_ = "Column-major sparse vector assignment";
1484
1485 initialize();
1486
1487 OBT band2 = blaze::band( tmat_, -2L );
1488
1489 blaze::CompressedVector<int,blaze::columnVector> vec1( 4UL );
1490 vec1[3] = 9;
1491
1492 band2 = vec1;
1493
1494 checkSize ( band2, 4UL );
1495 checkCapacity( band2, 4UL );
1496 checkNonZeros( band2, 1UL );
1497 checkRows ( tmat_, 6UL );
1498 checkColumns ( tmat_, 4UL );
1499 checkNonZeros( tmat_, 7UL );
1500
1501 if( band2[0] != 0 || band2[1] != 0 || band2[2] != 0 || band2[3] != 9 ) {
1502 std::ostringstream oss;
1503 oss << " Test: " << test_ << "\n"
1504 << " Error: Assignment failed\n"
1505 << " Details:\n"
1506 << " Result:\n" << band2 << "\n"
1507 << " Expected result:\n( 0 0 0 9 )\n";
1508 throw std::runtime_error( oss.str() );
1509 }
1510
1511 if( tmat_(0,0) != -2 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
1512 tmat_(1,0) != 0 || tmat_(1,1) != 0 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
1513 tmat_(2,0) != 0 || tmat_(2,1) != 4 || tmat_(2,2) != -3 || tmat_(2,3) != 0 ||
1514 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
1515 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 0 || tmat_(4,3) != -6 ||
1516 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 9 ) {
1517 std::ostringstream oss;
1518 oss << " Test: " << test_ << "\n"
1519 << " Error: Assignment failed\n"
1520 << " Details:\n"
1521 << " Result:\n" << tmat_ << "\n"
1522 << " Expected result:\n( -2 0 0 0 )\n"
1523 "( 0 0 1 0 )\n"
1524 "( 0 4 -3 0 )\n"
1525 "( 0 0 5 0 )\n"
1526 "( 0 0 0 -6 )\n"
1527 "( 0 0 0 9 )\n";
1528 throw std::runtime_error( oss.str() );
1529 }
1530 }
1531 }
1532 //*************************************************************************************************
1533
1534
1535 //*************************************************************************************************
1536 /*!\brief Test of the Band addition assignment operators.
1537 //
1538 // \return void
1539 // \exception std::runtime_error Error detected.
1540 //
1541 // This function performs a test of the addition assignment operators of the Band specialization.
1542 // In case an error is detected, a \a std::runtime_error exception is thrown.
1543 */
testAddAssign()1544 void DenseTest::testAddAssign()
1545 {
1546 //=====================================================================================
1547 // Row-major Band addition assignment
1548 //=====================================================================================
1549
1550 {
1551 test_ = "Row-major Band addition assignment";
1552
1553 initialize();
1554
1555 BT band0 = blaze::band( mat_, 0L );
1556 band0 += blaze::band( mat_, 1L );
1557
1558 checkSize ( band0, 4UL );
1559 checkCapacity( band0, 4UL );
1560 checkNonZeros( band0, 4UL );
1561 checkRows ( mat_ , 4UL );
1562 checkColumns ( mat_ , 6UL );
1563 checkNonZeros( mat_ , 12UL );
1564
1565 if( band0[0] != -2 || band0[1] != 4 || band0[2] != 2 || band0[3] != -6 ) {
1566 std::ostringstream oss;
1567 oss << " Test: " << test_ << "\n"
1568 << " Error: Addition assignment failed\n"
1569 << " Details:\n"
1570 << " Result:\n" << band0 << "\n"
1571 << " Expected result:\n( -2 4 2 -6 )\n";
1572 throw std::runtime_error( oss.str() );
1573 }
1574
1575 if( mat_(0,0) != -2 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
1576 mat_(1,0) != 0 || mat_(1,1) != 4 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
1577 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != 2 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
1578 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != -6 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
1579 std::ostringstream oss;
1580 oss << " Test: " << test_ << "\n"
1581 << " Error: Addition assignment failed\n"
1582 << " Details:\n"
1583 << " Result:\n" << mat_ << "\n"
1584 << " Expected result:\n( -2 0 7 0 0 0 )\n"
1585 "( 0 4 4 -8 0 0 )\n"
1586 "( 0 1 2 5 9 0 )\n"
1587 "( 0 0 0 -6 -6 10 )\n";
1588 throw std::runtime_error( oss.str() );
1589 }
1590 }
1591
1592
1593 //=====================================================================================
1594 // Row-major dense vector addition assignment
1595 //=====================================================================================
1596
1597 {
1598 test_ = "Row-major dense vector addition assignment (mixed type)";
1599
1600 initialize();
1601
1602 BT band0 = blaze::band( mat_, 0L );
1603
1604 const blaze::DynamicVector<short,blaze::columnVector> vec{ 2, -4, 0, 0 };
1605
1606 band0 += vec;
1607
1608 checkSize ( band0, 4UL );
1609 checkCapacity( band0, 4UL );
1610 checkNonZeros( band0, 2UL );
1611 checkRows ( mat_ , 4UL );
1612 checkColumns ( mat_ , 6UL );
1613 checkNonZeros( mat_ , 10UL );
1614
1615 if( band0[0] != 0 || band0[1] != -4 || band0[2] != -3 || band0[3] != 0 ) {
1616 std::ostringstream oss;
1617 oss << " Test: " << test_ << "\n"
1618 << " Error: Addition assignment failed\n"
1619 << " Details:\n"
1620 << " Result:\n" << band0 << "\n"
1621 << " Expected result:\n( 0 -4 -3 0 )\n";
1622 throw std::runtime_error( oss.str() );
1623 }
1624
1625 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
1626 mat_(1,0) != 0 || mat_(1,1) != -4 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
1627 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != -3 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
1628 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
1629 std::ostringstream oss;
1630 oss << " Test: " << test_ << "\n"
1631 << " Error: Addition assignment failed\n"
1632 << " Details:\n"
1633 << " Result:\n" << mat_ << "\n"
1634 << " Expected result:\n( 0 0 7 0 0 0 )\n"
1635 "( 0 -4 4 -8 0 0 )\n"
1636 "( 0 1 -3 5 9 0 )\n"
1637 "( 0 0 0 0 -6 10 )\n";
1638 throw std::runtime_error( oss.str() );
1639 }
1640 }
1641
1642 {
1643 test_ = "Row-major dense vector addition assignment (aligned/padded)";
1644
1645 using blaze::aligned;
1646 using blaze::padded;
1647 using blaze::columnVector;
1648
1649 initialize();
1650
1651 BT band0 = blaze::band( mat_, 0L );
1652
1653 using AlignedPadded = blaze::CustomVector<int,aligned,padded,columnVector>;
1654 std::unique_ptr<int[],blaze::Deallocate> memory( blaze::allocate<int>( 16UL ) );
1655 AlignedPadded vec( memory.get(), 4UL, 16UL );
1656 vec[0] = 2;
1657 vec[1] = -4;
1658 vec[2] = 0;
1659 vec[3] = 0;
1660
1661 band0 += vec;
1662
1663 checkSize ( band0, 4UL );
1664 checkCapacity( band0, 4UL );
1665 checkNonZeros( band0, 2UL );
1666 checkRows ( mat_ , 4UL );
1667 checkColumns ( mat_ , 6UL );
1668 checkNonZeros( mat_ , 10UL );
1669
1670 if( band0[0] != 0 || band0[1] != -4 || band0[2] != -3 || band0[3] != 0 ) {
1671 std::ostringstream oss;
1672 oss << " Test: " << test_ << "\n"
1673 << " Error: Addition assignment failed\n"
1674 << " Details:\n"
1675 << " Result:\n" << band0 << "\n"
1676 << " Expected result:\n( 0 -4 -3 0 )\n";
1677 throw std::runtime_error( oss.str() );
1678 }
1679
1680 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
1681 mat_(1,0) != 0 || mat_(1,1) != -4 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
1682 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != -3 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
1683 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
1684 std::ostringstream oss;
1685 oss << " Test: " << test_ << "\n"
1686 << " Error: Addition assignment failed\n"
1687 << " Details:\n"
1688 << " Result:\n" << mat_ << "\n"
1689 << " Expected result:\n( 0 0 7 0 0 0 )\n"
1690 "( 0 -4 4 -8 0 0 )\n"
1691 "( 0 1 -3 5 9 0 )\n"
1692 "( 0 0 0 0 -6 10 )\n";
1693 throw std::runtime_error( oss.str() );
1694 }
1695 }
1696
1697 {
1698 test_ = "Row-major dense vector addition assignment (unaligned/unpadded)";
1699
1700 using blaze::unaligned;
1701 using blaze::unpadded;
1702 using blaze::columnVector;
1703
1704 initialize();
1705
1706 BT band0 = blaze::band( mat_, 0L );
1707
1708 using UnalignedUnpadded = blaze::CustomVector<int,unaligned,unpadded,columnVector>;
1709 std::unique_ptr<int[]> memory( new int[5] );
1710 UnalignedUnpadded vec( memory.get()+1UL, 4UL );
1711 vec[0] = 2;
1712 vec[1] = -4;
1713 vec[2] = 0;
1714 vec[3] = 0;
1715
1716 band0 += vec;
1717
1718 checkSize ( band0, 4UL );
1719 checkCapacity( band0, 4UL );
1720 checkNonZeros( band0, 2UL );
1721 checkRows ( mat_ , 4UL );
1722 checkColumns ( mat_ , 6UL );
1723 checkNonZeros( mat_ , 10UL );
1724
1725 if( band0[0] != 0 || band0[1] != -4 || band0[2] != -3 || band0[3] != 0 ) {
1726 std::ostringstream oss;
1727 oss << " Test: " << test_ << "\n"
1728 << " Error: Addition assignment failed\n"
1729 << " Details:\n"
1730 << " Result:\n" << band0 << "\n"
1731 << " Expected result:\n( 0 -4 -3 0 )\n";
1732 throw std::runtime_error( oss.str() );
1733 }
1734
1735 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
1736 mat_(1,0) != 0 || mat_(1,1) != -4 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
1737 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != -3 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
1738 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
1739 std::ostringstream oss;
1740 oss << " Test: " << test_ << "\n"
1741 << " Error: Addition assignment failed\n"
1742 << " Details:\n"
1743 << " Result:\n" << mat_ << "\n"
1744 << " Expected result:\n( 0 0 7 0 0 0 )\n"
1745 "( 0 -4 4 -8 0 0 )\n"
1746 "( 0 1 -3 5 9 0 )\n"
1747 "( 0 0 0 0 -6 10 )\n";
1748 throw std::runtime_error( oss.str() );
1749 }
1750 }
1751
1752
1753 //=====================================================================================
1754 // Row-major sparse vector addition assignment
1755 //=====================================================================================
1756
1757 {
1758 test_ = "Row-major sparse vector addition assignment";
1759
1760 initialize();
1761
1762 BT band0 = blaze::band( mat_, 0L );
1763
1764 blaze::CompressedVector<int,blaze::columnVector> vec( 4UL );
1765 vec[0] = 2;
1766 vec[1] = -4;
1767
1768 band0 += vec;
1769
1770 checkSize ( band0, 4UL );
1771 checkCapacity( band0, 4UL );
1772 checkNonZeros( band0, 2UL );
1773 checkRows ( mat_ , 4UL );
1774 checkColumns ( mat_ , 6UL );
1775 checkNonZeros( mat_ , 10UL );
1776
1777 if( band0[0] != 0 || band0[1] != -4 || band0[2] != -3 || band0[3] != 0 ) {
1778 std::ostringstream oss;
1779 oss << " Test: " << test_ << "\n"
1780 << " Error: Addition assignment failed\n"
1781 << " Details:\n"
1782 << " Result:\n" << band0 << "\n"
1783 << " Expected result:\n( 0 -4 -3 0 )\n";
1784 throw std::runtime_error( oss.str() );
1785 }
1786
1787 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
1788 mat_(1,0) != 0 || mat_(1,1) != -4 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
1789 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != -3 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
1790 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
1791 std::ostringstream oss;
1792 oss << " Test: " << test_ << "\n"
1793 << " Error: Addition assignment failed\n"
1794 << " Details:\n"
1795 << " Result:\n" << mat_ << "\n"
1796 << " Expected result:\n( 0 0 7 0 0 0 )\n"
1797 "( 0 -4 4 -8 0 0 )\n"
1798 "( 0 1 -3 5 9 0 )\n"
1799 "( 0 0 0 0 -6 10 )\n";
1800 throw std::runtime_error( oss.str() );
1801 }
1802 }
1803
1804
1805 //=====================================================================================
1806 // Column-major Band addition assignment
1807 //=====================================================================================
1808
1809 {
1810 test_ = "Column-major Band addition assignment";
1811
1812 initialize();
1813
1814 OBT band0 = blaze::band( tmat_, 0L );
1815 band0 += blaze::band( tmat_, -1L );
1816
1817 checkSize ( band0, 4UL );
1818 checkCapacity( band0, 4UL );
1819 checkNonZeros( band0, 4UL );
1820 checkRows ( tmat_, 6UL );
1821 checkColumns ( tmat_, 4UL );
1822 checkNonZeros( tmat_, 12UL );
1823
1824 if( band0[0] != -2 || band0[1] != 4 || band0[2] != 2 || band0[3] != -6 ) {
1825 std::ostringstream oss;
1826 oss << " Test: " << test_ << "\n"
1827 << " Error: Addition assignment failed\n"
1828 << " Details:\n"
1829 << " Result:\n" << band0 << "\n"
1830 << " Expected result:\n( -2 4 2 -6 )\n";
1831 throw std::runtime_error( oss.str() );
1832 }
1833
1834 if( tmat_(0,0) != -2 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
1835 tmat_(1,0) != 0 || tmat_(1,1) != 4 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
1836 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != 2 || tmat_(2,3) != 0 ||
1837 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != -6 ||
1838 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
1839 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
1840 std::ostringstream oss;
1841 oss << " Test: " << test_ << "\n"
1842 << " Error: Addition assignment failed\n"
1843 << " Details:\n"
1844 << " Result:\n" << tmat_ << "\n"
1845 << " Expected result:\n( -2 0 0 0 )\n"
1846 "( 0 4 1 0 )\n"
1847 "( 7 4 2 0 )\n"
1848 "( 0 -8 5 -6 )\n"
1849 "( 0 0 9 -6 )\n"
1850 "( 0 0 0 10 )\n";
1851 throw std::runtime_error( oss.str() );
1852 }
1853 }
1854
1855
1856 //=====================================================================================
1857 // Column-major dense vector addition assignment
1858 //=====================================================================================
1859
1860 {
1861 test_ = "Column-major dense vector addition assignment (mixed type)";
1862
1863 initialize();
1864
1865 OBT band0 = blaze::band( tmat_, 0L );
1866
1867 const blaze::DynamicVector<short,blaze::columnVector> vec{ 2, -4, 0, 0 };
1868
1869 band0 += vec;
1870
1871 checkSize ( band0, 4UL );
1872 checkCapacity( band0, 4UL );
1873 checkNonZeros( band0, 2UL );
1874 checkRows ( tmat_, 6UL );
1875 checkColumns ( tmat_, 4UL );
1876 checkNonZeros( tmat_, 10UL );
1877
1878 if( band0[0] != 0 || band0[1] != -4 || band0[2] != -3 || band0[3] != 0 ) {
1879 std::ostringstream oss;
1880 oss << " Test: " << test_ << "\n"
1881 << " Error: Addition assignment failed\n"
1882 << " Details:\n"
1883 << " Result:\n" << band0 << "\n"
1884 << " Expected result:\n( 0 -4 -3 0 )\n";
1885 throw std::runtime_error( oss.str() );
1886 }
1887
1888 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
1889 tmat_(1,0) != 0 || tmat_(1,1) != -4 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
1890 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != -3 || tmat_(2,3) != 0 ||
1891 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
1892 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
1893 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
1894 std::ostringstream oss;
1895 oss << " Test: " << test_ << "\n"
1896 << " Error: Addition assignment failed\n"
1897 << " Details:\n"
1898 << " Result:\n" << tmat_ << "\n"
1899 << " Expected result:\n( 0 0 0 0 )\n"
1900 "( 0 -4 1 0 )\n"
1901 "( 7 4 -3 0 )\n"
1902 "( 0 -8 5 0 )\n"
1903 "( 0 0 9 -6 )\n"
1904 "( 0 0 0 10 )\n";
1905 throw std::runtime_error( oss.str() );
1906 }
1907 }
1908
1909 {
1910 test_ = "Column-major dense vector addition assignment (aligned/padded)";
1911
1912 using blaze::aligned;
1913 using blaze::padded;
1914 using blaze::columnVector;
1915
1916 initialize();
1917
1918 OBT band0 = blaze::band( tmat_, 0L );
1919
1920 using AlignedPadded = blaze::CustomVector<int,aligned,padded,columnVector>;
1921 std::unique_ptr<int[],blaze::Deallocate> memory( blaze::allocate<int>( 16UL ) );
1922 AlignedPadded vec( memory.get(), 4UL, 16UL );
1923 vec[0] = 2;
1924 vec[1] = -4;
1925 vec[2] = 0;
1926 vec[3] = 0;
1927
1928 band0 += vec;
1929
1930 checkSize ( band0, 4UL );
1931 checkCapacity( band0, 4UL );
1932 checkNonZeros( band0, 2UL );
1933 checkRows ( tmat_, 6UL );
1934 checkColumns ( tmat_, 4UL );
1935 checkNonZeros( tmat_, 10UL );
1936
1937 if( band0[0] != 0 || band0[1] != -4 || band0[2] != -3 || band0[3] != 0 ) {
1938 std::ostringstream oss;
1939 oss << " Test: " << test_ << "\n"
1940 << " Error: Addition assignment failed\n"
1941 << " Details:\n"
1942 << " Result:\n" << band0 << "\n"
1943 << " Expected result:\n( 0 -4 -3 0 )\n";
1944 throw std::runtime_error( oss.str() );
1945 }
1946
1947 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
1948 tmat_(1,0) != 0 || tmat_(1,1) != -4 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
1949 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != -3 || tmat_(2,3) != 0 ||
1950 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
1951 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
1952 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
1953 std::ostringstream oss;
1954 oss << " Test: " << test_ << "\n"
1955 << " Error: Addition assignment failed\n"
1956 << " Details:\n"
1957 << " Result:\n" << tmat_ << "\n"
1958 << " Expected result:\n( 0 0 0 0 )\n"
1959 "( 0 -4 1 0 )\n"
1960 "( 7 4 -3 0 )\n"
1961 "( 0 -8 5 0 )\n"
1962 "( 0 0 9 -6 )\n"
1963 "( 0 0 0 10 )\n";
1964 throw std::runtime_error( oss.str() );
1965 }
1966 }
1967
1968 {
1969 test_ = "Column-major dense vector addition assignment (unaligned/unpadded)";
1970
1971 using blaze::unaligned;
1972 using blaze::unpadded;
1973 using blaze::columnVector;
1974
1975 initialize();
1976
1977 OBT band0 = blaze::band( tmat_, 0L );
1978
1979 using UnalignedUnpadded = blaze::CustomVector<int,unaligned,unpadded,columnVector>;
1980 std::unique_ptr<int[]> memory( new int[5] );
1981 UnalignedUnpadded vec( memory.get()+1UL, 4UL );
1982 vec[0] = 2;
1983 vec[1] = -4;
1984 vec[2] = 0;
1985 vec[3] = 0;
1986
1987 band0 += vec;
1988
1989 checkSize ( band0, 4UL );
1990 checkCapacity( band0, 4UL );
1991 checkNonZeros( band0, 2UL );
1992 checkRows ( tmat_, 6UL );
1993 checkColumns ( tmat_, 4UL );
1994 checkNonZeros( tmat_, 10UL );
1995
1996 if( band0[0] != 0 || band0[1] != -4 || band0[2] != -3 || band0[3] != 0 ) {
1997 std::ostringstream oss;
1998 oss << " Test: " << test_ << "\n"
1999 << " Error: Addition assignment failed\n"
2000 << " Details:\n"
2001 << " Result:\n" << band0 << "\n"
2002 << " Expected result:\n( 0 -4 -3 0 )\n";
2003 throw std::runtime_error( oss.str() );
2004 }
2005
2006 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
2007 tmat_(1,0) != 0 || tmat_(1,1) != -4 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
2008 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != -3 || tmat_(2,3) != 0 ||
2009 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
2010 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
2011 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
2012 std::ostringstream oss;
2013 oss << " Test: " << test_ << "\n"
2014 << " Error: Addition assignment failed\n"
2015 << " Details:\n"
2016 << " Result:\n" << tmat_ << "\n"
2017 << " Expected result:\n( 0 0 0 0 )\n"
2018 "( 0 -4 1 0 )\n"
2019 "( 7 4 -3 0 )\n"
2020 "( 0 -8 5 0 )\n"
2021 "( 0 0 9 -6 )\n"
2022 "( 0 0 0 10 )\n";
2023 throw std::runtime_error( oss.str() );
2024 }
2025 }
2026
2027
2028 //=====================================================================================
2029 // Column-major sparse vector addition assignment
2030 //=====================================================================================
2031
2032 {
2033 test_ = "Column-major sparse vector addition assignment";
2034
2035 initialize();
2036
2037 OBT band0 = blaze::band( tmat_, 0L );
2038
2039 blaze::CompressedVector<int,blaze::columnVector> vec( 4UL );
2040 vec[0] = 2;
2041 vec[1] = -4;
2042
2043 band0 += vec;
2044
2045 checkSize ( band0, 4UL );
2046 checkCapacity( band0, 4UL );
2047 checkNonZeros( band0, 2UL );
2048 checkRows ( tmat_, 6UL );
2049 checkColumns ( tmat_, 4UL );
2050 checkNonZeros( tmat_, 10UL );
2051
2052 if( band0[0] != 0 || band0[1] != -4 || band0[2] != -3 || band0[3] != 0 ) {
2053 std::ostringstream oss;
2054 oss << " Test: " << test_ << "\n"
2055 << " Error: Addition assignment failed\n"
2056 << " Details:\n"
2057 << " Result:\n" << band0 << "\n"
2058 << " Expected result:\n( 0 -4 -3 0 )\n";
2059 throw std::runtime_error( oss.str() );
2060 }
2061
2062 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
2063 tmat_(1,0) != 0 || tmat_(1,1) != -4 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
2064 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != -3 || tmat_(2,3) != 0 ||
2065 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
2066 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
2067 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
2068 std::ostringstream oss;
2069 oss << " Test: " << test_ << "\n"
2070 << " Error: Addition assignment failed\n"
2071 << " Details:\n"
2072 << " Result:\n" << tmat_ << "\n"
2073 << " Expected result:\n( 0 0 0 0 )\n"
2074 "( 0 -4 1 0 )\n"
2075 "( 7 4 -3 0 )\n"
2076 "( 0 -8 5 0 )\n"
2077 "( 0 0 9 -6 )\n"
2078 "( 0 0 0 10 )\n";
2079 throw std::runtime_error( oss.str() );
2080 }
2081 }
2082 }
2083 //*************************************************************************************************
2084
2085
2086 //*************************************************************************************************
2087 /*!\brief Test of the Band subtraction assignment operators.
2088 //
2089 // \return void
2090 // \exception std::runtime_error Error detected.
2091 //
2092 // This function performs a test of the subtraction assignment operators of the Band
2093 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
2094 */
testSubAssign()2095 void DenseTest::testSubAssign()
2096 {
2097 //=====================================================================================
2098 // Row-major Band subtraction assignment
2099 //=====================================================================================
2100
2101 {
2102 test_ = "Row-major Band subtraction assignment";
2103
2104 initialize();
2105
2106 BT band0 = blaze::band( mat_, 0L );
2107 band0 -= blaze::band( mat_, 1L );
2108
2109 checkSize ( band0, 4UL );
2110 checkCapacity( band0, 4UL );
2111 checkNonZeros( band0, 4UL );
2112 checkRows ( mat_ , 4UL );
2113 checkColumns ( mat_ , 6UL );
2114 checkNonZeros( mat_ , 12UL );
2115
2116 if( band0[0] != -2 || band0[1] != -4 || band0[2] != -8 || band0[3] != 6 ) {
2117 std::ostringstream oss;
2118 oss << " Test: " << test_ << "\n"
2119 << " Error: Subtraction assignment failed\n"
2120 << " Details:\n"
2121 << " Result:\n" << band0 << "\n"
2122 << " Expected result:\n( -2 -4 -8 6 )\n";
2123 throw std::runtime_error( oss.str() );
2124 }
2125
2126 if( mat_(0,0) != -2 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
2127 mat_(1,0) != 0 || mat_(1,1) != -4 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
2128 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != -8 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
2129 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 6 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
2130 std::ostringstream oss;
2131 oss << " Test: " << test_ << "\n"
2132 << " Error: Subtraction assignment failed\n"
2133 << " Details:\n"
2134 << " Result:\n" << mat_ << "\n"
2135 << " Expected result:\n( -2 0 7 0 0 0 )\n"
2136 "( 0 -4 4 -8 0 0 )\n"
2137 "( 0 1 -8 5 9 0 )\n"
2138 "( 0 0 0 6 -6 10 )\n";
2139 throw std::runtime_error( oss.str() );
2140 }
2141 }
2142
2143
2144 //=====================================================================================
2145 // Row-major dense vector subtraction assignment
2146 //=====================================================================================
2147
2148 {
2149 test_ = "Row-major dense vector subtraction assignment (mixed type)";
2150
2151 initialize();
2152
2153 BT band0 = blaze::band( mat_, 0L );
2154
2155 const blaze::DynamicVector<short,blaze::columnVector> vec{ 2, -4, 0, 0 };
2156
2157 band0 -= vec;
2158
2159 checkSize ( band0, 4UL );
2160 checkCapacity( band0, 4UL );
2161 checkNonZeros( band0, 3UL );
2162 checkRows ( mat_ , 4UL );
2163 checkColumns ( mat_ , 6UL );
2164 checkNonZeros( mat_ , 11UL );
2165
2166 if( band0[0] != -4 || band0[1] != 4 || band0[2] != -3 || band0[3] != 0 ) {
2167 std::ostringstream oss;
2168 oss << " Test: " << test_ << "\n"
2169 << " Error: Subtraction assignment failed\n"
2170 << " Details:\n"
2171 << " Result:\n" << band0 << "\n"
2172 << " Expected result:\n( -4 4 -3 0 )\n";
2173 throw std::runtime_error( oss.str() );
2174 }
2175
2176 if( mat_(0,0) != -4 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
2177 mat_(1,0) != 0 || mat_(1,1) != 4 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
2178 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != -3 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
2179 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
2180 std::ostringstream oss;
2181 oss << " Test: " << test_ << "\n"
2182 << " Error: Subtraction assignment failed\n"
2183 << " Details:\n"
2184 << " Result:\n" << mat_ << "\n"
2185 << " Expected result:\n( -4 0 7 0 0 0 )\n"
2186 "( 0 4 4 -8 0 0 )\n"
2187 "( 0 1 -3 5 9 0 )\n"
2188 "( 0 0 0 0 -6 10 )\n";
2189 throw std::runtime_error( oss.str() );
2190 }
2191 }
2192
2193 {
2194 test_ = "Row-major dense vector subtraction assignment (aligned/padded)";
2195
2196 using blaze::aligned;
2197 using blaze::padded;
2198 using blaze::columnVector;
2199
2200 initialize();
2201
2202 BT band0 = blaze::band( mat_, 0L );
2203
2204 using AlignedPadded = blaze::CustomVector<int,aligned,padded,columnVector>;
2205 std::unique_ptr<int[],blaze::Deallocate> memory( blaze::allocate<int>( 16UL ) );
2206 AlignedPadded vec( memory.get(), 4UL, 16UL );
2207 vec[0] = 2;
2208 vec[1] = -4;
2209 vec[2] = 0;
2210 vec[3] = 0;
2211
2212 band0 -= vec;
2213
2214 checkSize ( band0, 4UL );
2215 checkCapacity( band0, 4UL );
2216 checkNonZeros( band0, 3UL );
2217 checkRows ( mat_ , 4UL );
2218 checkColumns ( mat_ , 6UL );
2219 checkNonZeros( mat_ , 11UL );
2220
2221 if( band0[0] != -4 || band0[1] != 4 || band0[2] != -3 || band0[3] != 0 ) {
2222 std::ostringstream oss;
2223 oss << " Test: " << test_ << "\n"
2224 << " Error: Subtraction assignment failed\n"
2225 << " Details:\n"
2226 << " Result:\n" << band0 << "\n"
2227 << " Expected result:\n( -4 4 -3 0 )\n";
2228 throw std::runtime_error( oss.str() );
2229 }
2230
2231 if( mat_(0,0) != -4 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
2232 mat_(1,0) != 0 || mat_(1,1) != 4 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
2233 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != -3 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
2234 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
2235 std::ostringstream oss;
2236 oss << " Test: " << test_ << "\n"
2237 << " Error: Subtraction assignment failed\n"
2238 << " Details:\n"
2239 << " Result:\n" << mat_ << "\n"
2240 << " Expected result:\n( -4 0 7 0 0 0 )\n"
2241 "( 0 4 4 -8 0 0 )\n"
2242 "( 0 1 -3 5 9 0 )\n"
2243 "( 0 0 0 0 -6 10 )\n";
2244 throw std::runtime_error( oss.str() );
2245 }
2246 }
2247
2248 {
2249 test_ = "Row-major dense vector subtraction assignment (unaligned/unpadded)";
2250
2251 using blaze::unaligned;
2252 using blaze::unpadded;
2253 using blaze::columnVector;
2254
2255 initialize();
2256
2257 BT band0 = blaze::band( mat_, 0L );
2258
2259 using UnalignedUnpadded = blaze::CustomVector<int,unaligned,unpadded,columnVector>;
2260 std::unique_ptr<int[]> memory( new int[5] );
2261 UnalignedUnpadded vec( memory.get()+1UL, 4UL );
2262 vec[0] = 2;
2263 vec[1] = -4;
2264 vec[2] = 0;
2265 vec[3] = 0;
2266
2267 band0 -= vec;
2268
2269 checkSize ( band0, 4UL );
2270 checkCapacity( band0, 4UL );
2271 checkNonZeros( band0, 3UL );
2272 checkRows ( mat_ , 4UL );
2273 checkColumns ( mat_ , 6UL );
2274 checkNonZeros( mat_ , 11UL );
2275
2276 if( band0[0] != -4 || band0[1] != 4 || band0[2] != -3 || band0[3] != 0 ) {
2277 std::ostringstream oss;
2278 oss << " Test: " << test_ << "\n"
2279 << " Error: Subtraction assignment failed\n"
2280 << " Details:\n"
2281 << " Result:\n" << band0 << "\n"
2282 << " Expected result:\n( -4 4 -3 0 )\n";
2283 throw std::runtime_error( oss.str() );
2284 }
2285
2286 if( mat_(0,0) != -4 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
2287 mat_(1,0) != 0 || mat_(1,1) != 4 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
2288 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != -3 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
2289 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
2290 std::ostringstream oss;
2291 oss << " Test: " << test_ << "\n"
2292 << " Error: Subtraction assignment failed\n"
2293 << " Details:\n"
2294 << " Result:\n" << mat_ << "\n"
2295 << " Expected result:\n( -4 0 7 0 0 0 )\n"
2296 "( 0 4 4 -8 0 0 )\n"
2297 "( 0 1 -3 5 9 0 )\n"
2298 "( 0 0 0 0 -6 10 )\n";
2299 throw std::runtime_error( oss.str() );
2300 }
2301 }
2302
2303
2304 //=====================================================================================
2305 // Row-major sparse vector subtraction assignment
2306 //=====================================================================================
2307
2308 {
2309 test_ = "Row-major sparse vector subtraction assignment";
2310
2311 initialize();
2312
2313 BT band0 = blaze::band( mat_, 0L );
2314
2315 blaze::CompressedVector<int,blaze::columnVector> vec( 4UL );
2316 vec[0] = 2;
2317 vec[1] = -4;
2318
2319 band0 -= vec;
2320
2321 checkSize ( band0, 4UL );
2322 checkCapacity( band0, 4UL );
2323 checkNonZeros( band0, 3UL );
2324 checkRows ( mat_ , 4UL );
2325 checkColumns ( mat_ , 6UL );
2326 checkNonZeros( mat_ , 11UL );
2327
2328 if( band0[0] != -4 || band0[1] != 4 || band0[2] != -3 || band0[3] != 0 ) {
2329 std::ostringstream oss;
2330 oss << " Test: " << test_ << "\n"
2331 << " Error: Subtraction assignment failed\n"
2332 << " Details:\n"
2333 << " Result:\n" << band0 << "\n"
2334 << " Expected result:\n( -4 4 -3 0 )\n";
2335 throw std::runtime_error( oss.str() );
2336 }
2337
2338 if( mat_(0,0) != -4 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
2339 mat_(1,0) != 0 || mat_(1,1) != 4 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
2340 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != -3 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
2341 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
2342 std::ostringstream oss;
2343 oss << " Test: " << test_ << "\n"
2344 << " Error: Subtraction assignment failed\n"
2345 << " Details:\n"
2346 << " Result:\n" << mat_ << "\n"
2347 << " Expected result:\n( -4 0 7 0 0 0 )\n"
2348 "( 0 4 4 -8 0 0 )\n"
2349 "( 0 1 -3 5 9 0 )\n"
2350 "( 0 0 0 0 -6 10 )\n";
2351 throw std::runtime_error( oss.str() );
2352 }
2353 }
2354
2355
2356 //=====================================================================================
2357 // Column-major Band subtraction assignment
2358 //=====================================================================================
2359
2360 {
2361 test_ = "Column-major Band subtraction assignment";
2362
2363 initialize();
2364
2365 OBT band0 = blaze::band( tmat_, 0L );
2366 band0 -= blaze::band( tmat_, -1L );
2367
2368 checkSize ( band0, 4UL );
2369 checkCapacity( band0, 4UL );
2370 checkNonZeros( band0, 4UL );
2371 checkRows ( tmat_, 6UL );
2372 checkColumns ( tmat_, 4UL );
2373 checkNonZeros( tmat_, 12UL );
2374
2375 if( band0[0] != -2 || band0[1] != -4 || band0[2] != -8 || band0[3] != 6 ) {
2376 std::ostringstream oss;
2377 oss << " Test: " << test_ << "\n"
2378 << " Error: Subtraction assignment failed\n"
2379 << " Details:\n"
2380 << " Result:\n" << band0 << "\n"
2381 << " Expected result:\n( -2 -4 -8 6 )\n";
2382 throw std::runtime_error( oss.str() );
2383 }
2384
2385 if( tmat_(0,0) != -2 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
2386 tmat_(1,0) != 0 || tmat_(1,1) != -4 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
2387 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != -8 || tmat_(2,3) != 0 ||
2388 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 6 ||
2389 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
2390 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
2391 std::ostringstream oss;
2392 oss << " Test: " << test_ << "\n"
2393 << " Error: Subtraction assignment failed\n"
2394 << " Details:\n"
2395 << " Result:\n" << tmat_ << "\n"
2396 << " Expected result:\n( -2 0 0 0 )\n"
2397 "( 0 -4 1 0 )\n"
2398 "( 7 4 -8 0 )\n"
2399 "( 0 -8 5 6 )\n"
2400 "( 0 0 9 -6 )\n"
2401 "( 0 0 0 10 )\n";
2402 throw std::runtime_error( oss.str() );
2403 }
2404 }
2405
2406
2407 //=====================================================================================
2408 // Column-major dense vector subtraction assignment
2409 //=====================================================================================
2410
2411 {
2412 test_ = "Column-major dense vector subtraction assignment (mixed type)";
2413
2414 initialize();
2415
2416 OBT band0 = blaze::band( tmat_, 0L );
2417
2418 const blaze::DynamicVector<short,blaze::columnVector> vec{ 2, -4, 0, 0 };
2419
2420 band0 -= vec;
2421
2422 checkSize ( band0, 4UL );
2423 checkCapacity( band0, 4UL );
2424 checkNonZeros( band0, 3UL );
2425 checkRows ( tmat_, 6UL );
2426 checkColumns ( tmat_, 4UL );
2427 checkNonZeros( tmat_, 11UL );
2428
2429 if( band0[0] != -4 || band0[1] != 4 || band0[2] != -3 || band0[3] != 0 ) {
2430 std::ostringstream oss;
2431 oss << " Test: " << test_ << "\n"
2432 << " Error: Subtraction assignment failed\n"
2433 << " Details:\n"
2434 << " Result:\n" << band0 << "\n"
2435 << " Expected result:\n( -4 4 -3 0 )\n";
2436 throw std::runtime_error( oss.str() );
2437 }
2438
2439 if( tmat_(0,0) != -4 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
2440 tmat_(1,0) != 0 || tmat_(1,1) != 4 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
2441 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != -3 || tmat_(2,3) != 0 ||
2442 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
2443 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
2444 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
2445 std::ostringstream oss;
2446 oss << " Test: " << test_ << "\n"
2447 << " Error: Subtraction assignment failed\n"
2448 << " Details:\n"
2449 << " Result:\n" << tmat_ << "\n"
2450 << " Expected result:\n( -4 0 0 0 )\n"
2451 "( 0 4 1 0 )\n"
2452 "( 7 4 -3 0 )\n"
2453 "( 0 -8 5 0 )\n"
2454 "( 0 0 9 -6 )\n"
2455 "( 0 0 0 10 )\n";
2456 throw std::runtime_error( oss.str() );
2457 }
2458 }
2459
2460 {
2461 test_ = "Column-major dense vector subtraction assignment (aligned/padded)";
2462
2463 using blaze::aligned;
2464 using blaze::padded;
2465 using blaze::columnVector;
2466
2467 initialize();
2468
2469 OBT band0 = blaze::band( tmat_, 0L );
2470
2471 using AlignedPadded = blaze::CustomVector<int,aligned,padded,columnVector>;
2472 std::unique_ptr<int[],blaze::Deallocate> memory( blaze::allocate<int>( 16UL ) );
2473 AlignedPadded vec( memory.get(), 4UL, 16UL );
2474 vec[0] = 2;
2475 vec[1] = -4;
2476 vec[2] = 0;
2477 vec[3] = 0;
2478
2479 band0 -= vec;
2480
2481 checkSize ( band0, 4UL );
2482 checkCapacity( band0, 4UL );
2483 checkNonZeros( band0, 3UL );
2484 checkRows ( tmat_, 6UL );
2485 checkColumns ( tmat_, 4UL );
2486 checkNonZeros( tmat_, 11UL );
2487
2488 if( band0[0] != -4 || band0[1] != 4 || band0[2] != -3 || band0[3] != 0 ) {
2489 std::ostringstream oss;
2490 oss << " Test: " << test_ << "\n"
2491 << " Error: Subtraction assignment failed\n"
2492 << " Details:\n"
2493 << " Result:\n" << band0 << "\n"
2494 << " Expected result:\n( -4 4 -3 0 )\n";
2495 throw std::runtime_error( oss.str() );
2496 }
2497
2498 if( tmat_(0,0) != -4 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
2499 tmat_(1,0) != 0 || tmat_(1,1) != 4 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
2500 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != -3 || tmat_(2,3) != 0 ||
2501 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
2502 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
2503 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
2504 std::ostringstream oss;
2505 oss << " Test: " << test_ << "\n"
2506 << " Error: Subtraction assignment failed\n"
2507 << " Details:\n"
2508 << " Result:\n" << tmat_ << "\n"
2509 << " Expected result:\n( -4 0 0 0 )\n"
2510 "( 0 4 1 0 )\n"
2511 "( 7 4 -3 0 )\n"
2512 "( 0 -8 5 0 )\n"
2513 "( 0 0 9 -6 )\n"
2514 "( 0 0 0 10 )\n";
2515 throw std::runtime_error( oss.str() );
2516 }
2517 }
2518
2519 {
2520 test_ = "Column-major dense vector subtraction assignment (unaligned/unpadded)";
2521
2522 using blaze::unaligned;
2523 using blaze::unpadded;
2524 using blaze::columnVector;
2525
2526 initialize();
2527
2528 OBT band0 = blaze::band( tmat_, 0L );
2529
2530 using UnalignedUnpadded = blaze::CustomVector<int,unaligned,unpadded,columnVector>;
2531 std::unique_ptr<int[]> memory( new int[5] );
2532 UnalignedUnpadded vec( memory.get()+1UL, 4UL );
2533 vec[0] = 2;
2534 vec[1] = -4;
2535 vec[2] = 0;
2536 vec[3] = 0;
2537
2538 band0 -= vec;
2539
2540 checkSize ( band0, 4UL );
2541 checkCapacity( band0, 4UL );
2542 checkNonZeros( band0, 3UL );
2543 checkRows ( tmat_, 6UL );
2544 checkColumns ( tmat_, 4UL );
2545 checkNonZeros( tmat_, 11UL );
2546
2547 if( band0[0] != -4 || band0[1] != 4 || band0[2] != -3 || band0[3] != 0 ) {
2548 std::ostringstream oss;
2549 oss << " Test: " << test_ << "\n"
2550 << " Error: Subtraction assignment failed\n"
2551 << " Details:\n"
2552 << " Result:\n" << band0 << "\n"
2553 << " Expected result:\n( -4 4 -3 0 )\n";
2554 throw std::runtime_error( oss.str() );
2555 }
2556
2557 if( tmat_(0,0) != -4 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
2558 tmat_(1,0) != 0 || tmat_(1,1) != 4 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
2559 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != -3 || tmat_(2,3) != 0 ||
2560 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
2561 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
2562 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
2563 std::ostringstream oss;
2564 oss << " Test: " << test_ << "\n"
2565 << " Error: Subtraction assignment failed\n"
2566 << " Details:\n"
2567 << " Result:\n" << tmat_ << "\n"
2568 << " Expected result:\n( -4 0 0 0 )\n"
2569 "( 0 4 1 0 )\n"
2570 "( 7 4 -3 0 )\n"
2571 "( 0 -8 5 0 )\n"
2572 "( 0 0 9 -6 )\n"
2573 "( 0 0 0 10 )\n";
2574 throw std::runtime_error( oss.str() );
2575 }
2576 }
2577
2578
2579 //=====================================================================================
2580 // Column-major sparse vector subtraction assignment
2581 //=====================================================================================
2582
2583 {
2584 test_ = "Column-major sparse vector subtraction assignment";
2585
2586 initialize();
2587
2588 OBT band0 = blaze::band( tmat_, 0L );
2589
2590 blaze::CompressedVector<int,blaze::columnVector> vec( 4UL );
2591 vec[0] = 2;
2592 vec[1] = -4;
2593
2594 band0 -= vec;
2595
2596 checkSize ( band0, 4UL );
2597 checkCapacity( band0, 4UL );
2598 checkNonZeros( band0, 3UL );
2599 checkRows ( tmat_, 6UL );
2600 checkColumns ( tmat_, 4UL );
2601 checkNonZeros( tmat_, 11UL );
2602
2603 if( band0[0] != -4 || band0[1] != 4 || band0[2] != -3 || band0[3] != 0 ) {
2604 std::ostringstream oss;
2605 oss << " Test: " << test_ << "\n"
2606 << " Error: Subtraction assignment failed\n"
2607 << " Details:\n"
2608 << " Result:\n" << band0 << "\n"
2609 << " Expected result:\n( -4 4 -3 0 )\n";
2610 throw std::runtime_error( oss.str() );
2611 }
2612
2613 if( tmat_(0,0) != -4 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
2614 tmat_(1,0) != 0 || tmat_(1,1) != 4 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
2615 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != -3 || tmat_(2,3) != 0 ||
2616 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
2617 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
2618 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
2619 std::ostringstream oss;
2620 oss << " Test: " << test_ << "\n"
2621 << " Error: Subtraction assignment failed\n"
2622 << " Details:\n"
2623 << " Result:\n" << tmat_ << "\n"
2624 << " Expected result:\n( -4 0 0 0 )\n"
2625 "( 0 4 1 0 )\n"
2626 "( 7 4 -3 0 )\n"
2627 "( 0 -8 5 0 )\n"
2628 "( 0 0 9 -6 )\n"
2629 "( 0 0 0 10 )\n";
2630 throw std::runtime_error( oss.str() );
2631 }
2632 }
2633 }
2634 //*************************************************************************************************
2635
2636
2637 //*************************************************************************************************
2638 /*!\brief Test of the Band multiplication assignment operators.
2639 //
2640 // \return void
2641 // \exception std::runtime_error Error detected.
2642 //
2643 // This function performs a test of the multiplication assignment operators of the Band
2644 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
2645 */
testMultAssign()2646 void DenseTest::testMultAssign()
2647 {
2648 //=====================================================================================
2649 // Row-major Band multiplication assignment
2650 //=====================================================================================
2651
2652 {
2653 test_ = "Row-major Band multiplication assignment";
2654
2655 initialize();
2656
2657 BT band0 = blaze::band( mat_, 0L );
2658 band0 *= blaze::band( mat_, 1L );
2659
2660 checkSize ( band0, 4UL );
2661 checkCapacity( band0, 4UL );
2662 checkNonZeros( band0, 1UL );
2663 checkRows ( mat_ , 4UL );
2664 checkColumns ( mat_ , 6UL );
2665 checkNonZeros( mat_ , 9UL );
2666
2667 if( band0[0] != 0 || band0[1] != 0 || band0[2] != -15 || band0[3] != 0 ) {
2668 std::ostringstream oss;
2669 oss << " Test: " << test_ << "\n"
2670 << " Error: Multiplication assignment failed\n"
2671 << " Details:\n"
2672 << " Result:\n" << band0 << "\n"
2673 << " Expected result:\n( 0 0 -15 0 )\n";
2674 throw std::runtime_error( oss.str() );
2675 }
2676
2677 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
2678 mat_(1,0) != 0 || mat_(1,1) != 0 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
2679 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != -15 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
2680 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
2681 std::ostringstream oss;
2682 oss << " Test: " << test_ << "\n"
2683 << " Error: Multiplication assignment failed\n"
2684 << " Details:\n"
2685 << " Result:\n" << mat_ << "\n"
2686 << " Expected result:\n( 0 0 7 0 0 0 )\n"
2687 "( 0 0 4 -8 0 0 )\n"
2688 "( 0 1 -15 5 9 0 )\n"
2689 "( 0 0 0 0 -6 10 )\n";
2690 throw std::runtime_error( oss.str() );
2691 }
2692 }
2693
2694
2695 //=====================================================================================
2696 // Row-major dense vector multiplication assignment
2697 //=====================================================================================
2698
2699 {
2700 test_ = "Row-major dense vector multiplication assignment (mixed type)";
2701
2702 initialize();
2703
2704 BT band0 = blaze::band( mat_, 0L );
2705
2706 const blaze::DynamicVector<short,blaze::columnVector> vec{ 2, -4, 0, 0 };
2707
2708 band0 *= vec;
2709
2710 checkSize ( band0, 4UL );
2711 checkCapacity( band0, 4UL );
2712 checkNonZeros( band0, 1UL );
2713 checkRows ( mat_ , 4UL );
2714 checkColumns ( mat_ , 6UL );
2715 checkNonZeros( mat_ , 9UL );
2716
2717 if( band0[0] != -4 || band0[1] != 0 || band0[2] != 0 || band0[3] != 0 ) {
2718 std::ostringstream oss;
2719 oss << " Test: " << test_ << "\n"
2720 << " Error: Multiplication assignment failed\n"
2721 << " Details:\n"
2722 << " Result:\n" << band0 << "\n"
2723 << " Expected result:\n( -4 0 0 0 )\n";
2724 throw std::runtime_error( oss.str() );
2725 }
2726
2727 if( mat_(0,0) != -4 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
2728 mat_(1,0) != 0 || mat_(1,1) != 0 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
2729 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != 0 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
2730 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
2731 std::ostringstream oss;
2732 oss << " Test: " << test_ << "\n"
2733 << " Error: Multiplication assignment failed\n"
2734 << " Details:\n"
2735 << " Result:\n" << mat_ << "\n"
2736 << " Expected result:\n( -4 0 7 0 0 0 )\n"
2737 "( 0 0 4 -8 0 0 )\n"
2738 "( 0 1 0 5 9 0 )\n"
2739 "( 0 0 0 0 -6 10 )\n";
2740 throw std::runtime_error( oss.str() );
2741 }
2742 }
2743
2744 {
2745 test_ = "Row-major dense vector multiplication assignment (aligned/padded)";
2746
2747 using blaze::aligned;
2748 using blaze::padded;
2749 using blaze::columnVector;
2750
2751 initialize();
2752
2753 BT band0 = blaze::band( mat_, 0L );
2754
2755 using AlignedPadded = blaze::CustomVector<int,aligned,padded,columnVector>;
2756 std::unique_ptr<int[],blaze::Deallocate> memory( blaze::allocate<int>( 16UL ) );
2757 AlignedPadded vec( memory.get(), 4UL, 16UL );
2758 vec[0] = 2;
2759 vec[1] = -4;
2760 vec[2] = 0;
2761 vec[3] = 0;
2762
2763 band0 *= vec;
2764
2765 checkSize ( band0, 4UL );
2766 checkCapacity( band0, 4UL );
2767 checkNonZeros( band0, 1UL );
2768 checkRows ( mat_ , 4UL );
2769 checkColumns ( mat_ , 6UL );
2770 checkNonZeros( mat_ , 9UL );
2771
2772 if( band0[0] != -4 || band0[1] != 0 || band0[2] != 0 || band0[3] != 0 ) {
2773 std::ostringstream oss;
2774 oss << " Test: " << test_ << "\n"
2775 << " Error: Multiplication assignment failed\n"
2776 << " Details:\n"
2777 << " Result:\n" << band0 << "\n"
2778 << " Expected result:\n( -4 0 0 0 )\n";
2779 throw std::runtime_error( oss.str() );
2780 }
2781
2782 if( mat_(0,0) != -4 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
2783 mat_(1,0) != 0 || mat_(1,1) != 0 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
2784 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != 0 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
2785 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
2786 std::ostringstream oss;
2787 oss << " Test: " << test_ << "\n"
2788 << " Error: Multiplication assignment failed\n"
2789 << " Details:\n"
2790 << " Result:\n" << mat_ << "\n"
2791 << " Expected result:\n( -4 0 7 0 0 0 )\n"
2792 "( 0 0 4 -8 0 0 )\n"
2793 "( 0 1 0 5 9 0 )\n"
2794 "( 0 0 0 0 -6 10 )\n";
2795 throw std::runtime_error( oss.str() );
2796 }
2797 }
2798
2799 {
2800 test_ = "Row-major dense vector multiplication assignment (unaligned/unpadded)";
2801
2802 using blaze::unaligned;
2803 using blaze::unpadded;
2804 using blaze::columnVector;
2805
2806 initialize();
2807
2808 BT band0 = blaze::band( mat_, 0L );
2809
2810 using UnalignedUnpadded = blaze::CustomVector<int,unaligned,unpadded,columnVector>;
2811 std::unique_ptr<int[]> memory( new int[5] );
2812 UnalignedUnpadded vec( memory.get()+1UL, 4UL );
2813 vec[0] = 2;
2814 vec[1] = -4;
2815 vec[2] = 0;
2816 vec[3] = 0;
2817
2818 band0 *= vec;
2819
2820 checkSize ( band0, 4UL );
2821 checkCapacity( band0, 4UL );
2822 checkNonZeros( band0, 1UL );
2823 checkRows ( mat_ , 4UL );
2824 checkColumns ( mat_ , 6UL );
2825 checkNonZeros( mat_ , 9UL );
2826
2827 if( band0[0] != -4 || band0[1] != 0 || band0[2] != 0 || band0[3] != 0 ) {
2828 std::ostringstream oss;
2829 oss << " Test: " << test_ << "\n"
2830 << " Error: Multiplication assignment failed\n"
2831 << " Details:\n"
2832 << " Result:\n" << band0 << "\n"
2833 << " Expected result:\n( -4 0 0 0 )\n";
2834 throw std::runtime_error( oss.str() );
2835 }
2836
2837 if( mat_(0,0) != -4 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
2838 mat_(1,0) != 0 || mat_(1,1) != 0 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
2839 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != 0 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
2840 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
2841 std::ostringstream oss;
2842 oss << " Test: " << test_ << "\n"
2843 << " Error: Multiplication assignment failed\n"
2844 << " Details:\n"
2845 << " Result:\n" << mat_ << "\n"
2846 << " Expected result:\n( -4 0 7 0 0 0 )\n"
2847 "( 0 0 4 -8 0 0 )\n"
2848 "( 0 1 0 5 9 0 )\n"
2849 "( 0 0 0 0 -6 10 )\n";
2850 throw std::runtime_error( oss.str() );
2851 }
2852 }
2853
2854
2855 //=====================================================================================
2856 // Row-major sparse vector multiplication assignment
2857 //=====================================================================================
2858
2859 {
2860 test_ = "Row-major sparse vector multiplication assignment";
2861
2862 initialize();
2863
2864 BT band0 = blaze::band( mat_, 0L );
2865
2866 blaze::CompressedVector<int,blaze::columnVector> vec( 4UL );
2867 vec[0] = 2;
2868 vec[1] = -4;
2869
2870 band0 *= vec;
2871
2872 checkSize ( band0, 4UL );
2873 checkCapacity( band0, 4UL );
2874 checkNonZeros( band0, 1UL );
2875 checkRows ( mat_ , 4UL );
2876 checkColumns ( mat_ , 6UL );
2877 checkNonZeros( mat_ , 9UL );
2878
2879 if( band0[0] != -4 || band0[1] != 0 || band0[2] != 0 || band0[3] != 0 ) {
2880 std::ostringstream oss;
2881 oss << " Test: " << test_ << "\n"
2882 << " Error: Multiplication assignment failed\n"
2883 << " Details:\n"
2884 << " Result:\n" << band0 << "\n"
2885 << " Expected result:\n( -4 0 0 0 )\n";
2886 throw std::runtime_error( oss.str() );
2887 }
2888
2889 if( mat_(0,0) != -4 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
2890 mat_(1,0) != 0 || mat_(1,1) != 0 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
2891 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != 0 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
2892 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
2893 std::ostringstream oss;
2894 oss << " Test: " << test_ << "\n"
2895 << " Error: Multiplication assignment failed\n"
2896 << " Details:\n"
2897 << " Result:\n" << mat_ << "\n"
2898 << " Expected result:\n( -4 0 7 0 0 0 )\n"
2899 "( 0 0 4 -8 0 0 )\n"
2900 "( 0 1 0 5 9 0 )\n"
2901 "( 0 0 0 0 -6 10 )\n";
2902 throw std::runtime_error( oss.str() );
2903 }
2904 }
2905
2906
2907 //=====================================================================================
2908 // Column-major Band multiplication assignment
2909 //=====================================================================================
2910
2911 {
2912 test_ = "Column-major Band multiplication assignment";
2913
2914 initialize();
2915
2916 OBT band0 = blaze::band( tmat_, 0L );
2917 band0 *= blaze::band( tmat_, -1L );
2918
2919 checkSize ( band0, 4UL );
2920 checkCapacity( band0, 4UL );
2921 checkNonZeros( band0, 1UL );
2922 checkRows ( tmat_, 6UL );
2923 checkColumns ( tmat_, 4UL );
2924 checkNonZeros( tmat_, 9UL );
2925
2926 if( band0[0] != 0 || band0[1] != 0 || band0[2] != -15 || band0[3] != 0 ) {
2927 std::ostringstream oss;
2928 oss << " Test: " << test_ << "\n"
2929 << " Error: Multiplication assignment failed\n"
2930 << " Details:\n"
2931 << " Result:\n" << band0 << "\n"
2932 << " Expected result:\n( 0 0 -15 0 )\n";
2933 throw std::runtime_error( oss.str() );
2934 }
2935
2936 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
2937 tmat_(1,0) != 0 || tmat_(1,1) != 0 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
2938 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != -15 || tmat_(2,3) != 0 ||
2939 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
2940 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
2941 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
2942 std::ostringstream oss;
2943 oss << " Test: " << test_ << "\n"
2944 << " Error: Multiplication assignment failed\n"
2945 << " Details:\n"
2946 << " Result:\n" << tmat_ << "\n"
2947 << " Expected result:\n( 0 0 0 0 )\n"
2948 "( 0 0 1 0 )\n"
2949 "( 7 4 -15 0 )\n"
2950 "( 0 -8 5 0 )\n"
2951 "( 0 0 9 -6 )\n"
2952 "( 0 0 0 10 )\n";
2953 throw std::runtime_error( oss.str() );
2954 }
2955 }
2956
2957
2958 //=====================================================================================
2959 // Column-major dense vector multiplication assignment
2960 //=====================================================================================
2961
2962 {
2963 test_ = "Column-major dense vector multiplication assignment (mixed type)";
2964
2965 initialize();
2966
2967 OBT band0 = blaze::band( tmat_, 0L );
2968
2969 const blaze::DynamicVector<short,blaze::columnVector> vec{ 2, -4, 0, 0 };
2970
2971 band0 *= vec;
2972
2973 checkSize ( band0, 4UL );
2974 checkCapacity( band0, 4UL );
2975 checkNonZeros( band0, 1UL );
2976 checkRows ( tmat_, 6UL );
2977 checkColumns ( tmat_, 4UL );
2978 checkNonZeros( tmat_, 9UL );
2979
2980 if( band0[0] != -4 || band0[1] != 0 || band0[2] != 0 || band0[3] != 0 ) {
2981 std::ostringstream oss;
2982 oss << " Test: " << test_ << "\n"
2983 << " Error: Multiplication assignment failed\n"
2984 << " Details:\n"
2985 << " Result:\n" << band0 << "\n"
2986 << " Expected result:\n( -4 0 0 0 )\n";
2987 throw std::runtime_error( oss.str() );
2988 }
2989
2990 if( tmat_(0,0) != -4 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
2991 tmat_(1,0) != 0 || tmat_(1,1) != 0 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
2992 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != 0 || tmat_(2,3) != 0 ||
2993 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
2994 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
2995 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
2996 std::ostringstream oss;
2997 oss << " Test: " << test_ << "\n"
2998 << " Error: Multiplication assignment failed\n"
2999 << " Details:\n"
3000 << " Result:\n" << tmat_ << "\n"
3001 << " Expected result:\n( -4 0 0 0 )\n"
3002 "( 0 0 1 0 )\n"
3003 "( 7 4 0 0 )\n"
3004 "( 0 -8 5 0 )\n"
3005 "( 0 0 9 -6 )\n"
3006 "( 0 0 0 10 )\n";
3007 throw std::runtime_error( oss.str() );
3008 }
3009 }
3010
3011 {
3012 test_ = "Column-major dense vector multiplication assignment (aligned/padded)";
3013
3014 using blaze::aligned;
3015 using blaze::padded;
3016 using blaze::columnVector;
3017
3018 initialize();
3019
3020 OBT band0 = blaze::band( tmat_, 0L );
3021
3022 using AlignedPadded = blaze::CustomVector<int,aligned,padded,columnVector>;
3023 std::unique_ptr<int[],blaze::Deallocate> memory( blaze::allocate<int>( 16UL ) );
3024 AlignedPadded vec( memory.get(), 4UL, 16UL );
3025 vec[0] = 2;
3026 vec[1] = -4;
3027 vec[2] = 0;
3028 vec[3] = 0;
3029
3030 band0 *= vec;
3031
3032 checkSize ( band0, 4UL );
3033 checkCapacity( band0, 4UL );
3034 checkNonZeros( band0, 1UL );
3035 checkRows ( tmat_, 6UL );
3036 checkColumns ( tmat_, 4UL );
3037 checkNonZeros( tmat_, 9UL );
3038
3039 if( band0[0] != -4 || band0[1] != 0 || band0[2] != 0 || band0[3] != 0 ) {
3040 std::ostringstream oss;
3041 oss << " Test: " << test_ << "\n"
3042 << " Error: Multiplication assignment failed\n"
3043 << " Details:\n"
3044 << " Result:\n" << band0 << "\n"
3045 << " Expected result:\n( -4 0 0 0 )\n";
3046 throw std::runtime_error( oss.str() );
3047 }
3048
3049 if( tmat_(0,0) != -4 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
3050 tmat_(1,0) != 0 || tmat_(1,1) != 0 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
3051 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != 0 || tmat_(2,3) != 0 ||
3052 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
3053 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
3054 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
3055 std::ostringstream oss;
3056 oss << " Test: " << test_ << "\n"
3057 << " Error: Multiplication assignment failed\n"
3058 << " Details:\n"
3059 << " Result:\n" << tmat_ << "\n"
3060 << " Expected result:\n( -4 0 0 0 )\n"
3061 "( 0 0 1 0 )\n"
3062 "( 7 4 0 0 )\n"
3063 "( 0 -8 5 0 )\n"
3064 "( 0 0 9 -6 )\n"
3065 "( 0 0 0 10 )\n";
3066 throw std::runtime_error( oss.str() );
3067 }
3068 }
3069
3070 {
3071 test_ = "Column-major dense vector multiplication assignment (unaligned/unpadded)";
3072
3073 using blaze::unaligned;
3074 using blaze::unpadded;
3075 using blaze::columnVector;
3076
3077 initialize();
3078
3079 OBT band0 = blaze::band( tmat_, 0L );
3080
3081 using UnalignedUnpadded = blaze::CustomVector<int,unaligned,unpadded,columnVector>;
3082 std::unique_ptr<int[]> memory( new int[5] );
3083 UnalignedUnpadded vec( memory.get()+1UL, 4UL );
3084 vec[0] = 2;
3085 vec[1] = -4;
3086 vec[2] = 0;
3087 vec[3] = 0;
3088
3089 band0 *= vec;
3090
3091 checkSize ( band0, 4UL );
3092 checkCapacity( band0, 4UL );
3093 checkNonZeros( band0, 1UL );
3094 checkRows ( tmat_, 6UL );
3095 checkColumns ( tmat_, 4UL );
3096 checkNonZeros( tmat_, 9UL );
3097
3098 if( band0[0] != -4 || band0[1] != 0 || band0[2] != 0 || band0[3] != 0 ) {
3099 std::ostringstream oss;
3100 oss << " Test: " << test_ << "\n"
3101 << " Error: Multiplication assignment failed\n"
3102 << " Details:\n"
3103 << " Result:\n" << band0 << "\n"
3104 << " Expected result:\n( -4 0 0 0 )\n";
3105 throw std::runtime_error( oss.str() );
3106 }
3107
3108 if( tmat_(0,0) != -4 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
3109 tmat_(1,0) != 0 || tmat_(1,1) != 0 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
3110 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != 0 || tmat_(2,3) != 0 ||
3111 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
3112 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
3113 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
3114 std::ostringstream oss;
3115 oss << " Test: " << test_ << "\n"
3116 << " Error: Multiplication assignment failed\n"
3117 << " Details:\n"
3118 << " Result:\n" << tmat_ << "\n"
3119 << " Expected result:\n( -4 0 0 0 )\n"
3120 "( 0 0 1 0 )\n"
3121 "( 7 4 0 0 )\n"
3122 "( 0 -8 5 0 )\n"
3123 "( 0 0 9 -6 )\n"
3124 "( 0 0 0 10 )\n";
3125 throw std::runtime_error( oss.str() );
3126 }
3127 }
3128
3129
3130 //=====================================================================================
3131 // Column-major sparse vector multiplication assignment
3132 //=====================================================================================
3133
3134 {
3135 test_ = "Column-major sparse vector multiplication assignment";
3136
3137 initialize();
3138
3139 OBT band0 = blaze::band( tmat_, 0L );
3140
3141 blaze::CompressedVector<int,blaze::columnVector> vec( 4UL );
3142 vec[0] = 2;
3143 vec[1] = -4;
3144
3145 band0 *= vec;
3146
3147 checkSize ( band0, 4UL );
3148 checkCapacity( band0, 4UL );
3149 checkNonZeros( band0, 1UL );
3150 checkRows ( tmat_, 6UL );
3151 checkColumns ( tmat_, 4UL );
3152 checkNonZeros( tmat_, 9UL );
3153
3154 if( band0[0] != -4 || band0[1] != 0 || band0[2] != 0 || band0[3] != 0 ) {
3155 std::ostringstream oss;
3156 oss << " Test: " << test_ << "\n"
3157 << " Error: Multiplication assignment failed\n"
3158 << " Details:\n"
3159 << " Result:\n" << band0 << "\n"
3160 << " Expected result:\n( -4 0 0 0 )\n";
3161 throw std::runtime_error( oss.str() );
3162 }
3163
3164 if( tmat_(0,0) != -4 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
3165 tmat_(1,0) != 0 || tmat_(1,1) != 0 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
3166 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != 0 || tmat_(2,3) != 0 ||
3167 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
3168 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
3169 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
3170 std::ostringstream oss;
3171 oss << " Test: " << test_ << "\n"
3172 << " Error: Multiplication assignment failed\n"
3173 << " Details:\n"
3174 << " Result:\n" << tmat_ << "\n"
3175 << " Expected result:\n( -4 0 0 0 )\n"
3176 "( 0 0 1 0 )\n"
3177 "( 7 4 0 0 )\n"
3178 "( 0 -8 5 0 )\n"
3179 "( 0 0 9 -6 )\n"
3180 "( 0 0 0 10 )\n";
3181 throw std::runtime_error( oss.str() );
3182 }
3183 }
3184 }
3185 //*************************************************************************************************
3186
3187
3188 //*************************************************************************************************
3189 /*!\brief Test of the Band division assignment operators.
3190 //
3191 // \return void
3192 // \exception std::runtime_error Error detected.
3193 //
3194 // This function performs a test of the division assignment operators of the Band specialization.
3195 // In case an error is detected, a \a std::runtime_error exception is thrown.
3196 */
testDivAssign()3197 void DenseTest::testDivAssign()
3198 {
3199 //=====================================================================================
3200 // Row-major Band division assignment
3201 //=====================================================================================
3202
3203 {
3204 test_ = "Row-major Band division assignment";
3205
3206 initialize();
3207
3208 BT band0 = blaze::band( mat_, 0L );
3209 band0 /= blaze::band( mat_, 2L );
3210
3211 checkSize ( band0, 4UL );
3212 checkCapacity( band0, 4UL );
3213 checkNonZeros( band0, 0UL );
3214 checkRows ( mat_ , 4UL );
3215 checkColumns ( mat_ , 6UL );
3216 checkNonZeros( mat_ , 8UL );
3217
3218 if( band0[0] != 0 || band0[1] != 0 || band0[2] != 0 || band0[3] != 0 ) {
3219 std::ostringstream oss;
3220 oss << " Test: " << test_ << "\n"
3221 << " Error: Division assignment failed\n"
3222 << " Details:\n"
3223 << " Result:\n" << band0 << "\n"
3224 << " Expected result:\n( 0 0 0 0 )\n";
3225 throw std::runtime_error( oss.str() );
3226 }
3227
3228 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
3229 mat_(1,0) != 0 || mat_(1,1) != 0 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
3230 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != 0 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
3231 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
3232 std::ostringstream oss;
3233 oss << " Test: " << test_ << "\n"
3234 << " Error: Division assignment failed\n"
3235 << " Details:\n"
3236 << " Result:\n" << mat_ << "\n"
3237 << " Expected result:\n( 0 0 7 0 0 0 )\n"
3238 "( 0 0 4 -8 0 0 )\n"
3239 "( 0 1 0 5 9 0 )\n"
3240 "( 0 0 0 0 -6 10 )\n";
3241 throw std::runtime_error( oss.str() );
3242 }
3243 }
3244
3245
3246 //=====================================================================================
3247 // Row-major dense vector division assignment
3248 //=====================================================================================
3249
3250 {
3251 test_ = "Row-major dense vector division assignment (mixed type)";
3252
3253 initialize();
3254
3255 BT band0 = blaze::band( mat_, 0L );
3256
3257 const blaze::DynamicVector<short,blaze::columnVector> vec{ -1, 2, 3, 4 };
3258
3259 band0 /= vec;
3260
3261 checkSize ( band0, 4UL );
3262 checkCapacity( band0, 4UL );
3263 checkNonZeros( band0, 2UL );
3264 checkRows ( mat_ , 4UL );
3265 checkColumns ( mat_ , 6UL );
3266 checkNonZeros( mat_ , 10UL );
3267
3268 if( band0[0] != 2 || band0[1] != 0 || band0[2] != -1 || band0[3] != 0 ) {
3269 std::ostringstream oss;
3270 oss << " Test: " << test_ << "\n"
3271 << " Error: Division assignment failed\n"
3272 << " Details:\n"
3273 << " Result:\n" << band0 << "\n"
3274 << " Expected result:\n( 2 0 -1 0 )\n";
3275 throw std::runtime_error( oss.str() );
3276 }
3277
3278 if( mat_(0,0) != 2 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
3279 mat_(1,0) != 0 || mat_(1,1) != 0 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
3280 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != -1 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
3281 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
3282 std::ostringstream oss;
3283 oss << " Test: " << test_ << "\n"
3284 << " Error: Division assignment failed\n"
3285 << " Details:\n"
3286 << " Result:\n" << mat_ << "\n"
3287 << " Expected result:\n( 2 0 7 0 0 0 )\n"
3288 "( 0 0 4 -8 0 0 )\n"
3289 "( 0 1 -1 5 9 0 )\n"
3290 "( 0 0 0 0 -6 10 )\n";
3291 throw std::runtime_error( oss.str() );
3292 }
3293 }
3294
3295 {
3296 test_ = "Row-major dense vector division assignment (aligned/padded)";
3297
3298 using blaze::aligned;
3299 using blaze::padded;
3300 using blaze::columnVector;
3301
3302 initialize();
3303
3304 BT band0 = blaze::band( mat_, 0L );
3305
3306 using AlignedPadded = blaze::CustomVector<int,aligned,padded,columnVector>;
3307 std::unique_ptr<int[],blaze::Deallocate> memory( blaze::allocate<int>( 16UL ) );
3308 AlignedPadded vec( memory.get(), 4UL, 16UL );
3309 vec[0] = -1;
3310 vec[1] = 2;
3311 vec[2] = 3;
3312 vec[3] = 4;
3313
3314 band0 /= vec;
3315
3316 checkSize ( band0, 4UL );
3317 checkCapacity( band0, 4UL );
3318 checkNonZeros( band0, 2UL );
3319 checkRows ( mat_ , 4UL );
3320 checkColumns ( mat_ , 6UL );
3321 checkNonZeros( mat_ , 10UL );
3322
3323 if( band0[0] != 2 || band0[1] != 0 || band0[2] != -1 || band0[3] != 0 ) {
3324 std::ostringstream oss;
3325 oss << " Test: " << test_ << "\n"
3326 << " Error: Division assignment failed\n"
3327 << " Details:\n"
3328 << " Result:\n" << band0 << "\n"
3329 << " Expected result:\n( 2 0 -1 0 )\n";
3330 throw std::runtime_error( oss.str() );
3331 }
3332
3333 if( mat_(0,0) != 2 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
3334 mat_(1,0) != 0 || mat_(1,1) != 0 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
3335 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != -1 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
3336 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
3337 std::ostringstream oss;
3338 oss << " Test: " << test_ << "\n"
3339 << " Error: Division assignment failed\n"
3340 << " Details:\n"
3341 << " Result:\n" << mat_ << "\n"
3342 << " Expected result:\n( 0 0 0 0 )\n"
3343 "( 0 1 0 0 )\n"
3344 "( 2 0 -1 0 )\n"
3345 "( 0 4 5 -6 )\n"
3346 "( 7 -8 9 10 )\n";
3347 throw std::runtime_error( oss.str() );
3348 }
3349 }
3350
3351 {
3352 test_ = "Row-major dense vector division assignment (unaligned/unpadded)";
3353
3354 using blaze::unaligned;
3355 using blaze::unpadded;
3356 using blaze::columnVector;
3357
3358 initialize();
3359
3360 BT band0 = blaze::band( mat_, 0L );
3361
3362 using UnalignedUnpadded = blaze::CustomVector<int,unaligned,unpadded,columnVector>;
3363 std::unique_ptr<int[]> memory( new int[5] );
3364 UnalignedUnpadded vec( memory.get()+1UL, 4UL );
3365 vec[0] = -1;
3366 vec[1] = 2;
3367 vec[2] = 3;
3368 vec[3] = 4;
3369
3370 band0 /= vec;
3371
3372 checkSize ( band0, 4UL );
3373 checkCapacity( band0, 4UL );
3374 checkNonZeros( band0, 2UL );
3375 checkRows ( mat_ , 4UL );
3376 checkColumns ( mat_ , 6UL );
3377 checkNonZeros( mat_ , 10UL );
3378
3379 if( band0[0] != 2 || band0[1] != 0 || band0[2] != -1 || band0[3] != 0 ) {
3380 std::ostringstream oss;
3381 oss << " Test: " << test_ << "\n"
3382 << " Error: Division assignment failed\n"
3383 << " Details:\n"
3384 << " Result:\n" << band0 << "\n"
3385 << " Expected result:\n( 2 0 -1 0 )\n";
3386 throw std::runtime_error( oss.str() );
3387 }
3388
3389 if( mat_(0,0) != 2 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
3390 mat_(1,0) != 0 || mat_(1,1) != 0 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
3391 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != -1 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
3392 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
3393 std::ostringstream oss;
3394 oss << " Test: " << test_ << "\n"
3395 << " Error: Division assignment failed\n"
3396 << " Details:\n"
3397 << " Result:\n" << mat_ << "\n"
3398 << " Expected result:\n( 0 0 0 0 )\n"
3399 "( 0 1 0 0 )\n"
3400 "( 2 0 -1 0 )\n"
3401 "( 0 4 5 -6 )\n"
3402 "( 7 -8 9 10 )\n";
3403 throw std::runtime_error( oss.str() );
3404 }
3405 }
3406
3407
3408 //=====================================================================================
3409 // Column-major Band division assignment
3410 //=====================================================================================
3411
3412 {
3413 test_ = "Column-major Band division assignment";
3414
3415 initialize();
3416
3417 OBT band0 = blaze::band( tmat_, 0L );
3418 band0 /= blaze::band( tmat_, -2L );
3419
3420 checkSize ( band0, 4UL );
3421 checkCapacity( band0, 4UL );
3422 checkNonZeros( band0, 0UL );
3423 checkRows ( tmat_, 6UL );
3424 checkColumns ( tmat_, 4UL );
3425 checkNonZeros( tmat_, 8UL );
3426
3427 if( band0[0] != 0 || band0[1] != 0 || band0[2] != 0 || band0[3] != 0 ) {
3428 std::ostringstream oss;
3429 oss << " Test: " << test_ << "\n"
3430 << " Error: Division assignment failed\n"
3431 << " Details:\n"
3432 << " Result:\n" << band0 << "\n"
3433 << " Expected result:\n( 0 0 0 0 )\n";
3434 throw std::runtime_error( oss.str() );
3435 }
3436
3437 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
3438 tmat_(1,0) != 0 || tmat_(1,1) != 0 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
3439 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != 0 || tmat_(2,3) != 0 ||
3440 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
3441 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
3442 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
3443 std::ostringstream oss;
3444 oss << " Test: " << test_ << "\n"
3445 << " Error: Division assignment failed\n"
3446 << " Details:\n"
3447 << " Result:\n" << tmat_ << "\n"
3448 << " Expected result:\n( 0 0 0 0 )\n"
3449 "( 0 0 1 0 )\n"
3450 "( 7 4 0 0 )\n"
3451 "( 0 -8 5 0 )\n"
3452 "( 0 0 9 -6 )\n"
3453 "( 0 0 0 10 )\n";
3454 throw std::runtime_error( oss.str() );
3455 }
3456 }
3457
3458
3459 //=====================================================================================
3460 // Column-major dense vector division assignment
3461 //=====================================================================================
3462
3463 {
3464 test_ = "Column-major dense vector division assignment (mixed type)";
3465
3466 initialize();
3467
3468 OBT band0 = blaze::band( tmat_, 0L );
3469
3470 const blaze::DynamicVector<short,blaze::columnVector> vec{ -1, 2, 3, 4 };
3471
3472 band0 /= vec;
3473
3474 checkSize ( band0, 4UL );
3475 checkCapacity( band0, 4UL );
3476 checkNonZeros( band0, 2UL );
3477 checkRows ( tmat_, 6UL );
3478 checkColumns ( tmat_, 4UL );
3479 checkNonZeros( tmat_, 10UL );
3480
3481 if( band0[0] != 2 || band0[1] != 0 || band0[2] != -1 || band0[3] != 0 ) {
3482 std::ostringstream oss;
3483 oss << " Test: " << test_ << "\n"
3484 << " Error: Division assignment failed\n"
3485 << " Details:\n"
3486 << " Result:\n" << band0 << "\n"
3487 << " Expected result:\n( 2 0 -1 0 )\n";
3488 throw std::runtime_error( oss.str() );
3489 }
3490
3491 if( tmat_(0,0) != 2 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
3492 tmat_(1,0) != 0 || tmat_(1,1) != 0 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
3493 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != -1 || tmat_(2,3) != 0 ||
3494 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
3495 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
3496 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
3497 std::ostringstream oss;
3498 oss << " Test: " << test_ << "\n"
3499 << " Error: Division assignment failed\n"
3500 << " Details:\n"
3501 << " Result:\n" << tmat_ << "\n"
3502 << " Expected result:\n( 2 0 0 0 )\n"
3503 "( 0 0 1 0 )\n"
3504 "( 7 4 -1 0 )\n"
3505 "( 0 -8 5 0 )\n"
3506 "( 0 0 9 -6 )\n"
3507 "( 0 0 0 10 )\n";
3508 throw std::runtime_error( oss.str() );
3509 }
3510 }
3511
3512 {
3513 test_ = "Column-major dense vector division assignment (aligned/padded)";
3514
3515 using blaze::aligned;
3516 using blaze::padded;
3517 using blaze::columnVector;
3518
3519 initialize();
3520
3521 OBT band0 = blaze::band( tmat_, 0L );
3522
3523 using AlignedPadded = blaze::CustomVector<int,aligned,padded,columnVector>;
3524 std::unique_ptr<int[],blaze::Deallocate> memory( blaze::allocate<int>( 16UL ) );
3525 AlignedPadded vec( memory.get(), 4UL, 16UL );
3526 vec[0] = -1;
3527 vec[1] = 2;
3528 vec[2] = 3;
3529 vec[3] = 4;
3530
3531 band0 /= vec;
3532
3533 checkSize ( band0, 4UL );
3534 checkCapacity( band0, 4UL );
3535 checkNonZeros( band0, 2UL );
3536 checkRows ( tmat_, 6UL );
3537 checkColumns ( tmat_, 4UL );
3538 checkNonZeros( tmat_, 10UL );
3539
3540 if( band0[0] != 2 || band0[1] != 0 || band0[2] != -1 || band0[3] != 0 ) {
3541 std::ostringstream oss;
3542 oss << " Test: " << test_ << "\n"
3543 << " Error: Division assignment failed\n"
3544 << " Details:\n"
3545 << " Result:\n" << band0 << "\n"
3546 << " Expected result:\n( 2 0 -1 0 )\n";
3547 throw std::runtime_error( oss.str() );
3548 }
3549
3550 if( tmat_(0,0) != 2 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
3551 tmat_(1,0) != 0 || tmat_(1,1) != 0 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
3552 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != -1 || tmat_(2,3) != 0 ||
3553 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
3554 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
3555 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
3556 std::ostringstream oss;
3557 oss << " Test: " << test_ << "\n"
3558 << " Error: Division assignment failed\n"
3559 << " Details:\n"
3560 << " Result:\n" << tmat_ << "\n"
3561 << " Expected result:\n( 2 0 0 0 )\n"
3562 "( 0 0 1 0 )\n"
3563 "( 7 4 -1 0 )\n"
3564 "( 0 -8 5 0 )\n"
3565 "( 0 0 9 -6 )\n"
3566 "( 0 0 0 10 )\n";
3567 throw std::runtime_error( oss.str() );
3568 }
3569 }
3570
3571 {
3572 test_ = "Column-major dense vector division assignment (unaligned/unpadded)";
3573
3574 using blaze::unaligned;
3575 using blaze::unpadded;
3576 using blaze::columnVector;
3577
3578 initialize();
3579
3580 OBT band0 = blaze::band( tmat_, 0L );
3581
3582 using UnalignedUnpadded = blaze::CustomVector<int,unaligned,unpadded,columnVector>;
3583 std::unique_ptr<int[]> memory( new int[5] );
3584 UnalignedUnpadded vec( memory.get()+1UL, 4UL );
3585 vec[0] = -1;
3586 vec[1] = 2;
3587 vec[2] = 3;
3588 vec[3] = 4;
3589
3590 band0 /= vec;
3591
3592 checkSize ( band0, 4UL );
3593 checkCapacity( band0, 4UL );
3594 checkNonZeros( band0, 2UL );
3595 checkRows ( tmat_, 6UL );
3596 checkColumns ( tmat_, 4UL );
3597 checkNonZeros( tmat_, 10UL );
3598
3599 if( band0[0] != 2 || band0[1] != 0 || band0[2] != -1 || band0[3] != 0 ) {
3600 std::ostringstream oss;
3601 oss << " Test: " << test_ << "\n"
3602 << " Error: Division assignment failed\n"
3603 << " Details:\n"
3604 << " Result:\n" << band0 << "\n"
3605 << " Expected result:\n( 2 0 -1 0 )\n";
3606 throw std::runtime_error( oss.str() );
3607 }
3608
3609 if( tmat_(0,0) != 2 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
3610 tmat_(1,0) != 0 || tmat_(1,1) != 0 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
3611 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != -1 || tmat_(2,3) != 0 ||
3612 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
3613 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
3614 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
3615 std::ostringstream oss;
3616 oss << " Test: " << test_ << "\n"
3617 << " Error: Division assignment failed\n"
3618 << " Details:\n"
3619 << " Result:\n" << tmat_ << "\n"
3620 << " Expected result:\n( 2 0 0 0 )\n"
3621 "( 0 0 1 0 )\n"
3622 "( 7 4 -1 0 )\n"
3623 "( 0 -8 5 0 )\n"
3624 "( 0 0 9 -6 )\n"
3625 "( 0 0 0 10 )\n";
3626 throw std::runtime_error( oss.str() );
3627 }
3628 }
3629 }
3630 //*************************************************************************************************
3631
3632
3633 //*************************************************************************************************
3634 /*!\brief Test of the Band cross product assignment operators.
3635 //
3636 // \return void
3637 // \exception std::runtime_error Error detected.
3638 //
3639 // This function performs a test of the cross product assignment operators of the Band
3640 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
3641 */
testCrossAssign()3642 void DenseTest::testCrossAssign()
3643 {
3644 //=====================================================================================
3645 // Row-major Band cross product assignment
3646 //=====================================================================================
3647
3648 {
3649 test_ = "Row-major Band cross product assignment";
3650
3651 MT mat{ { 2, 1, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, -1, -2 } };
3652
3653 BT band0 = blaze::band( mat, 0L );
3654 band0 %= blaze::band( mat, 1L );
3655
3656 checkSize ( band0, 3UL );
3657 checkCapacity( band0, 3UL );
3658 checkNonZeros( band0, 1UL );
3659 checkRows ( mat , 3UL );
3660 checkColumns ( mat , 4UL );
3661 checkNonZeros( mat , 3UL );
3662
3663 if( band0[0] != 0 || band0[1] != 3 || band0[2] != 0 ) {
3664 std::ostringstream oss;
3665 oss << " Test: " << test_ << "\n"
3666 << " Error: Cross product assignment failed\n"
3667 << " Details:\n"
3668 << " Result:\n" << band0 << "\n"
3669 << " Expected result:\n( 0 3 0 )\n";
3670 throw std::runtime_error( oss.str() );
3671 }
3672
3673 if( mat(0,0) != 0 || mat(0,1) != 1 || mat(0,2) != 0 || mat(0,3) != 0 ||
3674 mat(1,0) != 0 || mat(1,1) != 3 || mat(1,2) != 0 || mat(1,3) != 0 ||
3675 mat(2,0) != 0 || mat(2,1) != 0 || mat(2,2) != 0 || mat(2,3) != -2 ) {
3676 std::ostringstream oss;
3677 oss << " Test: " << test_ << "\n"
3678 << " Error: Cross product assignment failed\n"
3679 << " Details:\n"
3680 << " Result:\n" << mat << "\n"
3681 << " Expected result:\n( 0 1 0 0 )\n"
3682 "( 0 3 0 0 )\n"
3683 "( 0 0 0 -2 )\n";
3684 throw std::runtime_error( oss.str() );
3685 }
3686 }
3687
3688
3689 //=====================================================================================
3690 // Row-major dense vector cross product assignment
3691 //=====================================================================================
3692
3693 {
3694 test_ = "Row-major dense vector cross product assignment (mixed type)";
3695
3696 MT mat{ { 2, 1, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, -1, -2 } };
3697
3698 BT band0 = blaze::band( mat, 0L );
3699
3700 const blaze::DynamicVector<short,blaze::columnVector> vec{ 1, 0, -2 };
3701
3702 band0 %= vec;
3703
3704 checkSize ( band0, 3UL );
3705 checkCapacity( band0, 3UL );
3706 checkNonZeros( band0, 1UL );
3707 checkRows ( mat , 3UL );
3708 checkColumns ( mat , 4UL );
3709 checkNonZeros( mat , 3UL );
3710
3711 if( band0[0] != 0 || band0[1] != 3 || band0[2] != 0 ) {
3712 std::ostringstream oss;
3713 oss << " Test: " << test_ << "\n"
3714 << " Error: Cross product assignment failed\n"
3715 << " Details:\n"
3716 << " Result:\n" << band0 << "\n"
3717 << " Expected result:\n( 0 3 0 )\n";
3718 throw std::runtime_error( oss.str() );
3719 }
3720
3721 if( mat(0,0) != 0 || mat(0,1) != 1 || mat(0,2) != 0 || mat(0,3) != 0 ||
3722 mat(1,0) != 0 || mat(1,1) != 3 || mat(1,2) != 0 || mat(1,3) != 0 ||
3723 mat(2,0) != 0 || mat(2,1) != 0 || mat(2,2) != 0 || mat(2,3) != -2 ) {
3724 std::ostringstream oss;
3725 oss << " Test: " << test_ << "\n"
3726 << " Error: Cross product assignment failed\n"
3727 << " Details:\n"
3728 << " Result:\n" << mat << "\n"
3729 << " Expected result:\n( 0 1 0 0 )\n"
3730 "( 0 3 0 0 )\n"
3731 "( 0 0 0 -2 )\n";
3732 throw std::runtime_error( oss.str() );
3733 }
3734 }
3735
3736 {
3737 test_ = "Row-major dense vector cross product assignment (aligned/padded)";
3738
3739 using blaze::aligned;
3740 using blaze::padded;
3741 using blaze::columnVector;
3742
3743 MT mat{ { 2, 1, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, -1, -2 } };
3744
3745 BT band0 = blaze::band( mat, 0L );
3746
3747 using AlignedPadded = blaze::CustomVector<int,aligned,padded,columnVector>;
3748 std::unique_ptr<int[],blaze::Deallocate> memory( blaze::allocate<int>( 16UL ) );
3749 AlignedPadded vec( memory.get(), 3UL, 16UL );
3750 vec[0] = 1;
3751 vec[1] = 0;
3752 vec[2] = -2;
3753
3754 band0 %= vec;
3755
3756 checkSize ( band0, 3UL );
3757 checkCapacity( band0, 3UL );
3758 checkNonZeros( band0, 1UL );
3759 checkRows ( mat , 3UL );
3760 checkColumns ( mat , 4UL );
3761 checkNonZeros( mat , 3UL );
3762
3763 if( band0[0] != 0 || band0[1] != 3 || band0[2] != 0 ) {
3764 std::ostringstream oss;
3765 oss << " Test: " << test_ << "\n"
3766 << " Error: Cross product assignment failed\n"
3767 << " Details:\n"
3768 << " Result:\n" << band0 << "\n"
3769 << " Expected result:\n( 0 3 0 )\n";
3770 throw std::runtime_error( oss.str() );
3771 }
3772
3773 if( mat(0,0) != 0 || mat(0,1) != 1 || mat(0,2) != 0 || mat(0,3) != 0 ||
3774 mat(1,0) != 0 || mat(1,1) != 3 || mat(1,2) != 0 || mat(1,3) != 0 ||
3775 mat(2,0) != 0 || mat(2,1) != 0 || mat(2,2) != 0 || mat(2,3) != -2 ) {
3776 std::ostringstream oss;
3777 oss << " Test: " << test_ << "\n"
3778 << " Error: Cross product assignment failed\n"
3779 << " Details:\n"
3780 << " Result:\n" << mat << "\n"
3781 << " Expected result:\n( 0 1 0 0 )\n"
3782 "( 0 3 0 0 )\n"
3783 "( 0 0 0 -2 )\n";
3784 throw std::runtime_error( oss.str() );
3785 }
3786 }
3787
3788 {
3789 test_ = "Row-major dense vector cross product assignment (unaligned/unpadded)";
3790
3791 using blaze::unaligned;
3792 using blaze::unpadded;
3793 using blaze::columnVector;
3794
3795 MT mat{ { 2, 1, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, -1, -2 } };
3796
3797 BT band0 = blaze::band( mat, 0L );
3798
3799 using UnalignedUnpadded = blaze::CustomVector<int,unaligned,unpadded,columnVector>;
3800 std::unique_ptr<int[]> memory( new int[4] );
3801 UnalignedUnpadded vec( memory.get()+1UL, 3UL );
3802 vec[0] = 1;
3803 vec[1] = 0;
3804 vec[2] = -2;
3805
3806 band0 %= vec;
3807
3808 checkSize ( band0, 3UL );
3809 checkCapacity( band0, 3UL );
3810 checkNonZeros( band0, 1UL );
3811 checkRows ( mat , 3UL );
3812 checkColumns ( mat , 4UL );
3813 checkNonZeros( mat , 3UL );
3814
3815 if( band0[0] != 0 || band0[1] != 3 || band0[2] != 0 ) {
3816 std::ostringstream oss;
3817 oss << " Test: " << test_ << "\n"
3818 << " Error: Cross product assignment failed\n"
3819 << " Details:\n"
3820 << " Result:\n" << band0 << "\n"
3821 << " Expected result:\n( 0 3 0 )\n";
3822 throw std::runtime_error( oss.str() );
3823 }
3824
3825 if( mat(0,0) != 0 || mat(0,1) != 1 || mat(0,2) != 0 || mat(0,3) != 0 ||
3826 mat(1,0) != 0 || mat(1,1) != 3 || mat(1,2) != 0 || mat(1,3) != 0 ||
3827 mat(2,0) != 0 || mat(2,1) != 0 || mat(2,2) != 0 || mat(2,3) != -2 ) {
3828 std::ostringstream oss;
3829 oss << " Test: " << test_ << "\n"
3830 << " Error: Cross product assignment failed\n"
3831 << " Details:\n"
3832 << " Result:\n" << mat << "\n"
3833 << " Expected result:\n( 0 1 0 0 )\n"
3834 "( 0 3 0 0 )\n"
3835 "( 0 0 0 -2 )\n";
3836 throw std::runtime_error( oss.str() );
3837 }
3838 }
3839
3840
3841 //=====================================================================================
3842 // Row-major sparse vector cross product assignment
3843 //=====================================================================================
3844
3845 {
3846 test_ = "Row-major sparse vector cross product assignment";
3847
3848 MT mat{ { 2, 1, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, -1, -2 } };
3849
3850 BT band0 = blaze::band( mat, 0L );
3851
3852 blaze::CompressedVector<int,blaze::columnVector> vec( 3UL );
3853 vec[0] = 1;
3854 vec[2] = -2;
3855
3856 band0 %= vec;
3857
3858 checkSize ( band0, 3UL );
3859 checkCapacity( band0, 3UL );
3860 checkNonZeros( band0, 1UL );
3861 checkRows ( mat , 3UL );
3862 checkColumns ( mat , 4UL );
3863 checkNonZeros( mat , 3UL );
3864
3865 if( band0[0] != 0 || band0[1] != 3 || band0[2] != 0 ) {
3866 std::ostringstream oss;
3867 oss << " Test: " << test_ << "\n"
3868 << " Error: Cross product assignment failed\n"
3869 << " Details:\n"
3870 << " Result:\n" << band0 << "\n"
3871 << " Expected result:\n( 0 3 0 )\n";
3872 throw std::runtime_error( oss.str() );
3873 }
3874
3875 if( mat(0,0) != 0 || mat(0,1) != 1 || mat(0,2) != 0 || mat(0,3) != 0 ||
3876 mat(1,0) != 0 || mat(1,1) != 3 || mat(1,2) != 0 || mat(1,3) != 0 ||
3877 mat(2,0) != 0 || mat(2,1) != 0 || mat(2,2) != 0 || mat(2,3) != -2 ) {
3878 std::ostringstream oss;
3879 oss << " Test: " << test_ << "\n"
3880 << " Error: Cross product assignment failed\n"
3881 << " Details:\n"
3882 << " Result:\n" << mat << "\n"
3883 << " Expected result:\n( 0 1 0 0 )\n"
3884 "( 0 3 0 0 )\n"
3885 "( 0 0 0 -2 )\n";
3886 throw std::runtime_error( oss.str() );
3887 }
3888 }
3889
3890
3891 //=====================================================================================
3892 // Column-major Band cross product assignment
3893 //=====================================================================================
3894
3895 {
3896 test_ = "Column-major Band cross product assignment";
3897
3898 OMT mat{ { 2, 0, 0 }, { 1, 0, 0 }, { 0, 0, -1 }, { 0, 0, -2 } };
3899
3900 OBT band0 = blaze::band( mat, 0L );
3901 band0 %= blaze::band( mat, -1L );
3902
3903 checkSize ( band0, 3UL );
3904 checkCapacity( band0, 3UL );
3905 checkNonZeros( band0, 1UL );
3906 checkRows ( mat , 4UL );
3907 checkColumns ( mat , 3UL );
3908 checkNonZeros( mat , 3UL );
3909
3910 if( band0[0] != 0 || band0[1] != 3 || band0[2] != 0 ) {
3911 std::ostringstream oss;
3912 oss << " Test: " << test_ << "\n"
3913 << " Error: Cross product assignment failed\n"
3914 << " Details:\n"
3915 << " Result:\n" << band0 << "\n"
3916 << " Expected result:\n( 0 3 0 )\n";
3917 throw std::runtime_error( oss.str() );
3918 }
3919
3920 if( mat(0,0) != 0 || mat(0,1) != 0 || mat(0,2) != 0 ||
3921 mat(1,0) != 1 || mat(1,1) != 3 || mat(1,2) != 0 ||
3922 mat(2,0) != 0 || mat(2,1) != 0 || mat(2,2) != 0 ||
3923 mat(3,0) != 0 || mat(3,1) != 0 || mat(3,2) != -2 ) {
3924 std::ostringstream oss;
3925 oss << " Test: " << test_ << "\n"
3926 << " Error: Cross product assignment failed\n"
3927 << " Details:\n"
3928 << " Result:\n" << mat << "\n"
3929 << " Expected result:\n( 0 0 0 )\n"
3930 "( 1 3 0 )\n"
3931 "( 0 0 0 )\n"
3932 "( 0 0 -2 )\n";
3933 throw std::runtime_error( oss.str() );
3934 }
3935 }
3936
3937
3938 //=====================================================================================
3939 // Column-major dense vector cross product assignment
3940 //=====================================================================================
3941
3942 {
3943 test_ = "Column-major dense vector cross product assignment (mixed type)";
3944
3945 OMT mat{ { 2, 0, 0 }, { 1, 0, 0 }, { 0, 0, -1 }, { 0, 0, -2 } };
3946
3947 OBT band0 = blaze::band( mat, 0L );
3948
3949 const blaze::DynamicVector<short,blaze::columnVector> vec{ 1, 0, -2 };
3950
3951 band0 %= vec;
3952
3953 checkSize ( band0, 3UL );
3954 checkCapacity( band0, 3UL );
3955 checkNonZeros( band0, 1UL );
3956 checkRows ( mat , 4UL );
3957 checkColumns ( mat , 3UL );
3958 checkNonZeros( mat , 3UL );
3959
3960 if( band0[0] != 0 || band0[1] != 3 || band0[2] != 0 ) {
3961 std::ostringstream oss;
3962 oss << " Test: " << test_ << "\n"
3963 << " Error: Cross product assignment failed\n"
3964 << " Details:\n"
3965 << " Result:\n" << band0 << "\n"
3966 << " Expected result:\n( 0 3 0 )\n";
3967 throw std::runtime_error( oss.str() );
3968 }
3969
3970 if( mat(0,0) != 0 || mat(0,1) != 0 || mat(0,2) != 0 ||
3971 mat(1,0) != 1 || mat(1,1) != 3 || mat(1,2) != 0 ||
3972 mat(2,0) != 0 || mat(2,1) != 0 || mat(2,2) != 0 ||
3973 mat(3,0) != 0 || mat(3,1) != 0 || mat(3,2) != -2 ) {
3974 std::ostringstream oss;
3975 oss << " Test: " << test_ << "\n"
3976 << " Error: Cross product assignment failed\n"
3977 << " Details:\n"
3978 << " Result:\n" << mat << "\n"
3979 << " Expected result:\n( 0 0 0 )\n"
3980 "( 1 3 0 )\n"
3981 "( 0 0 0 )\n"
3982 "( 0 0 -2 )\n";
3983 throw std::runtime_error( oss.str() );
3984 }
3985 }
3986
3987 {
3988 test_ = "Column-major dense vector cross product assignment (aligned/padded)";
3989
3990 using blaze::aligned;
3991 using blaze::padded;
3992 using blaze::columnVector;
3993
3994 OMT mat{ { 2, 0, 0 }, { 1, 0, 0 }, { 0, 0, -1 }, { 0, 0, -2 } };
3995
3996 OBT band0 = blaze::band( mat, 0L );
3997
3998 using AlignedPadded = blaze::CustomVector<int,aligned,padded,columnVector>;
3999 std::unique_ptr<int[],blaze::Deallocate> memory( blaze::allocate<int>( 16UL ) );
4000 AlignedPadded vec( memory.get(), 3UL, 16UL );
4001 vec[0] = 1;
4002 vec[1] = 0;
4003 vec[2] = -2;
4004
4005 band0 %= vec;
4006
4007 checkSize ( band0, 3UL );
4008 checkCapacity( band0, 3UL );
4009 checkNonZeros( band0, 1UL );
4010 checkRows ( mat , 4UL );
4011 checkColumns ( mat , 3UL );
4012 checkNonZeros( mat , 3UL );
4013
4014 if( band0[0] != 0 || band0[1] != 3 || band0[2] != 0 ) {
4015 std::ostringstream oss;
4016 oss << " Test: " << test_ << "\n"
4017 << " Error: Cross product assignment failed\n"
4018 << " Details:\n"
4019 << " Result:\n" << band0 << "\n"
4020 << " Expected result:\n( 0 3 0 )\n";
4021 throw std::runtime_error( oss.str() );
4022 }
4023
4024 if( mat(0,0) != 0 || mat(0,1) != 0 || mat(0,2) != 0 ||
4025 mat(1,0) != 1 || mat(1,1) != 3 || mat(1,2) != 0 ||
4026 mat(2,0) != 0 || mat(2,1) != 0 || mat(2,2) != 0 ||
4027 mat(3,0) != 0 || mat(3,1) != 0 || mat(3,2) != -2 ) {
4028 std::ostringstream oss;
4029 oss << " Test: " << test_ << "\n"
4030 << " Error: Cross product assignment failed\n"
4031 << " Details:\n"
4032 << " Result:\n" << mat << "\n"
4033 << " Expected result:\n( 0 0 0 )\n"
4034 "( 1 3 0 )\n"
4035 "( 0 0 0 )\n"
4036 "( 0 0 -2 )\n";
4037 throw std::runtime_error( oss.str() );
4038 }
4039 }
4040
4041 {
4042 test_ = "Column-major dense vector cross product assignment (unaligned/unpadded)";
4043
4044 using blaze::unaligned;
4045 using blaze::unpadded;
4046 using blaze::columnVector;
4047
4048 OMT mat{ { 2, 0, 0 }, { 1, 0, 0 }, { 0, 0, -1 }, { 0, 0, -2 } };
4049
4050 OBT band0 = blaze::band( mat, 0L );
4051
4052 using UnalignedUnpadded = blaze::CustomVector<int,unaligned,unpadded,columnVector>;
4053 std::unique_ptr<int[]> memory( new int[4] );
4054 UnalignedUnpadded vec( memory.get()+1UL, 3UL );
4055 vec[0] = 1;
4056 vec[1] = 0;
4057 vec[2] = -2;
4058
4059 band0 %= vec;
4060
4061 checkSize ( band0, 3UL );
4062 checkCapacity( band0, 3UL );
4063 checkNonZeros( band0, 1UL );
4064 checkRows ( mat , 4UL );
4065 checkColumns ( mat , 3UL );
4066 checkNonZeros( mat , 3UL );
4067
4068 if( band0[0] != 0 || band0[1] != 3 || band0[2] != 0 ) {
4069 std::ostringstream oss;
4070 oss << " Test: " << test_ << "\n"
4071 << " Error: Cross product assignment failed\n"
4072 << " Details:\n"
4073 << " Result:\n" << band0 << "\n"
4074 << " Expected result:\n( 0 3 0 )\n";
4075 throw std::runtime_error( oss.str() );
4076 }
4077
4078 if( mat(0,0) != 0 || mat(0,1) != 0 || mat(0,2) != 0 ||
4079 mat(1,0) != 1 || mat(1,1) != 3 || mat(1,2) != 0 ||
4080 mat(2,0) != 0 || mat(2,1) != 0 || mat(2,2) != 0 ||
4081 mat(3,0) != 0 || mat(3,1) != 0 || mat(3,2) != -2 ) {
4082 std::ostringstream oss;
4083 oss << " Test: " << test_ << "\n"
4084 << " Error: Cross product assignment failed\n"
4085 << " Details:\n"
4086 << " Result:\n" << mat << "\n"
4087 << " Expected result:\n( 0 0 0 )\n"
4088 "( 1 3 0 )\n"
4089 "( 0 0 0 )\n"
4090 "( 0 0 -2 )\n";
4091 throw std::runtime_error( oss.str() );
4092 }
4093 }
4094
4095
4096 //=====================================================================================
4097 // Column-major sparse vector cross product assignment
4098 //=====================================================================================
4099
4100 {
4101 test_ = "Column-major sparse vector cross product assignment";
4102
4103 OMT mat{ { 2, 0, 0 }, { 1, 0, 0 }, { 0, 0, -1 }, { 0, 0, -2 } };
4104
4105 OBT band0 = blaze::band( mat, 0L );
4106
4107 blaze::CompressedVector<int,blaze::columnVector> vec( 3UL );
4108 vec[0] = 1;
4109 vec[2] = -2;
4110
4111 band0 %= vec;
4112
4113 checkSize ( band0, 3UL );
4114 checkCapacity( band0, 3UL );
4115 checkNonZeros( band0, 1UL );
4116 checkRows ( mat , 4UL );
4117 checkColumns ( mat , 3UL );
4118 checkNonZeros( mat , 3UL );
4119
4120 if( band0[0] != 0 || band0[1] != 3 || band0[2] != 0 ) {
4121 std::ostringstream oss;
4122 oss << " Test: " << test_ << "\n"
4123 << " Error: Cross product assignment failed\n"
4124 << " Details:\n"
4125 << " Result:\n" << band0 << "\n"
4126 << " Expected result:\n( 0 3 0 )\n";
4127 throw std::runtime_error( oss.str() );
4128 }
4129
4130 if( mat(0,0) != 0 || mat(0,1) != 0 || mat(0,2) != 0 ||
4131 mat(1,0) != 1 || mat(1,1) != 3 || mat(1,2) != 0 ||
4132 mat(2,0) != 0 || mat(2,1) != 0 || mat(2,2) != 0 ||
4133 mat(3,0) != 0 || mat(3,1) != 0 || mat(3,2) != -2 ) {
4134 std::ostringstream oss;
4135 oss << " Test: " << test_ << "\n"
4136 << " Error: Cross product assignment failed\n"
4137 << " Details:\n"
4138 << " Result:\n" << mat << "\n"
4139 << " Expected result:\n( 0 0 0 )\n"
4140 "( 1 3 0 )\n"
4141 "( 0 0 0 )\n"
4142 "( 0 0 -2 )\n";
4143 throw std::runtime_error( oss.str() );
4144 }
4145 }
4146 }
4147 //*************************************************************************************************
4148
4149
4150 //*************************************************************************************************
4151 /*!\brief Test of all Band (self-)scaling operations.
4152 //
4153 // \return void
4154 // \exception std::runtime_error Error detected.
4155 //
4156 // This function performs a test of all available ways to scale an instance of the Band
4157 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
4158 */
testScaling()4159 void DenseTest::testScaling()
4160 {
4161 //=====================================================================================
4162 // Row-major self-scaling (v*=s)
4163 //=====================================================================================
4164
4165 {
4166 test_ = "Row-major self-scaling (v*=s)";
4167
4168 initialize();
4169
4170 BT band0 = blaze::band( mat_, 0L );
4171
4172 band0 *= 3;
4173
4174 checkSize ( band0, 4UL );
4175 checkCapacity( band0, 4UL );
4176 checkNonZeros( band0, 2UL );
4177 checkRows ( mat_ , 4UL );
4178 checkColumns ( mat_ , 6UL );
4179 checkNonZeros( mat_ , 10UL );
4180
4181 if( band0[0] != -6 || band0[1] != 0 || band0[2] != -9 || band0[3] != 0 ) {
4182 std::ostringstream oss;
4183 oss << " Test: " << test_ << "\n"
4184 << " Error: Failed self-scaling operation\n"
4185 << " Details:\n"
4186 << " Result:\n" << band0 << "\n"
4187 << " Expected result:\n( -6 0 -9 0 )\n";
4188 throw std::runtime_error( oss.str() );
4189 }
4190
4191 if( mat_(0,0) != -6 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
4192 mat_(1,0) != 0 || mat_(1,1) != 0 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
4193 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != -9 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
4194 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
4195 std::ostringstream oss;
4196 oss << " Test: " << test_ << "\n"
4197 << " Error: Failed self-scaling operation\n"
4198 << " Details:\n"
4199 << " Result:\n" << mat_ << "\n"
4200 << " Expected result:\n( -6 0 7 0 0 0 )\n"
4201 "( 0 0 4 -8 0 0 )\n"
4202 "( 0 1 -9 5 9 0 )\n"
4203 "( 0 0 0 0 -6 10 )\n";
4204 throw std::runtime_error( oss.str() );
4205 }
4206 }
4207
4208
4209 //=====================================================================================
4210 // Row-major self-scaling (v=v*s)
4211 //=====================================================================================
4212
4213 {
4214 test_ = "Row-major self-scaling (v=v*s)";
4215
4216 initialize();
4217
4218 BT band0 = blaze::band( mat_, 0L );
4219
4220 band0 = band0 * 3;
4221
4222 checkSize ( band0, 4UL );
4223 checkCapacity( band0, 4UL );
4224 checkNonZeros( band0, 2UL );
4225 checkRows ( mat_ , 4UL );
4226 checkColumns ( mat_ , 6UL );
4227 checkNonZeros( mat_ , 10UL );
4228
4229 if( band0[0] != -6 || band0[1] != 0 || band0[2] != -9 || band0[3] != 0 ) {
4230 std::ostringstream oss;
4231 oss << " Test: " << test_ << "\n"
4232 << " Error: Failed self-scaling operation\n"
4233 << " Details:\n"
4234 << " Result:\n" << band0 << "\n"
4235 << " Expected result:\n( -6 0 -9 0 )\n";
4236 throw std::runtime_error( oss.str() );
4237 }
4238
4239 if( mat_(0,0) != -6 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
4240 mat_(1,0) != 0 || mat_(1,1) != 0 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
4241 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != -9 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
4242 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
4243 std::ostringstream oss;
4244 oss << " Test: " << test_ << "\n"
4245 << " Error: Failed self-scaling operation\n"
4246 << " Details:\n"
4247 << " Result:\n" << mat_ << "\n"
4248 << " Expected result:\n( -6 0 7 0 0 0 )\n"
4249 "( 0 0 4 -8 0 0 )\n"
4250 "( 0 1 -9 5 9 0 )\n"
4251 "( 0 0 0 0 -6 10 )\n";
4252 throw std::runtime_error( oss.str() );
4253 }
4254 }
4255
4256
4257 //=====================================================================================
4258 // Row-major self-scaling (v=s*v)
4259 //=====================================================================================
4260
4261 {
4262 test_ = "Row-major self-scaling (v=s*v)";
4263
4264 initialize();
4265
4266 BT band0 = blaze::band( mat_, 0L );
4267
4268 band0 = 3 * band0;
4269
4270 checkSize ( band0, 4UL );
4271 checkCapacity( band0, 4UL );
4272 checkNonZeros( band0, 2UL );
4273 checkRows ( mat_ , 4UL );
4274 checkColumns ( mat_ , 6UL );
4275 checkNonZeros( mat_ , 10UL );
4276
4277 if( band0[0] != -6 || band0[1] != 0 || band0[2] != -9 || band0[3] != 0 ) {
4278 std::ostringstream oss;
4279 oss << " Test: " << test_ << "\n"
4280 << " Error: Failed self-scaling operation\n"
4281 << " Details:\n"
4282 << " Result:\n" << band0 << "\n"
4283 << " Expected result:\n( -6 0 -9 0 )\n";
4284 throw std::runtime_error( oss.str() );
4285 }
4286
4287 if( mat_(0,0) != -6 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
4288 mat_(1,0) != 0 || mat_(1,1) != 0 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
4289 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != -9 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
4290 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
4291 std::ostringstream oss;
4292 oss << " Test: " << test_ << "\n"
4293 << " Error: Failed self-scaling operation\n"
4294 << " Details:\n"
4295 << " Result:\n" << mat_ << "\n"
4296 << " Expected result:\n( -6 0 7 0 0 0 )\n"
4297 "( 0 0 4 -8 0 0 )\n"
4298 "( 0 1 -9 5 9 0 )\n"
4299 "( 0 0 0 0 -6 10 )\n";
4300 throw std::runtime_error( oss.str() );
4301 }
4302 }
4303
4304
4305 //=====================================================================================
4306 // Row-major self-scaling (v/=s)
4307 //=====================================================================================
4308
4309 {
4310 test_ = "Row-major self-scaling (v/=s)";
4311
4312 initialize();
4313
4314 BT band0 = blaze::band( mat_, 0L );
4315
4316 band0 /= 0.5;
4317
4318 checkSize ( band0, 4UL );
4319 checkCapacity( band0, 4UL );
4320 checkNonZeros( band0, 2UL );
4321 checkRows ( mat_ , 4UL );
4322 checkColumns ( mat_ , 6UL );
4323 checkNonZeros( mat_ , 10UL );
4324
4325 if( band0[0] != -4 || band0[1] != 0 || band0[2] != -6 || band0[3] != 0 ) {
4326 std::ostringstream oss;
4327 oss << " Test: " << test_ << "\n"
4328 << " Error: Failed self-scaling operation\n"
4329 << " Details:\n"
4330 << " Result:\n" << band0 << "\n"
4331 << " Expected result:\n( -4 0 -6 0 )\n";
4332 throw std::runtime_error( oss.str() );
4333 }
4334
4335 if( mat_(0,0) != -4 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
4336 mat_(1,0) != 0 || mat_(1,1) != 0 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
4337 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != -6 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
4338 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
4339 std::ostringstream oss;
4340 oss << " Test: " << test_ << "\n"
4341 << " Error: Failed self-scaling operation\n"
4342 << " Details:\n"
4343 << " Result:\n" << mat_ << "\n"
4344 << " Expected result:\n( -4 0 7 0 0 0 )\n"
4345 "( 0 0 4 -8 0 0 )\n"
4346 "( 0 1 -6 5 9 0 )\n"
4347 "( 0 0 0 0 -6 10 )\n";
4348 throw std::runtime_error( oss.str() );
4349 }
4350 }
4351
4352
4353 //=====================================================================================
4354 // Row-major self-scaling (v=v/s)
4355 //=====================================================================================
4356
4357 {
4358 test_ = "Row-major self-scaling (v=v/s)";
4359
4360 initialize();
4361
4362 BT band0 = blaze::band( mat_, 0L );
4363
4364 band0 = band0 / 0.5;
4365
4366 checkSize ( band0, 4UL );
4367 checkCapacity( band0, 4UL );
4368 checkNonZeros( band0, 2UL );
4369 checkRows ( mat_ , 4UL );
4370 checkColumns ( mat_ , 6UL );
4371 checkNonZeros( mat_ , 10UL );
4372
4373 if( band0[0] != -4 || band0[1] != 0 || band0[2] != -6 || band0[3] != 0 ) {
4374 std::ostringstream oss;
4375 oss << " Test: " << test_ << "\n"
4376 << " Error: Failed self-scaling operation\n"
4377 << " Details:\n"
4378 << " Result:\n" << band0 << "\n"
4379 << " Expected result:\n( -4 0 -6 0 )\n";
4380 throw std::runtime_error( oss.str() );
4381 }
4382
4383 if( mat_(0,0) != -4 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
4384 mat_(1,0) != 0 || mat_(1,1) != 0 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
4385 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != -6 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
4386 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
4387 std::ostringstream oss;
4388 oss << " Test: " << test_ << "\n"
4389 << " Error: Failed self-scaling operation\n"
4390 << " Details:\n"
4391 << " Result:\n" << mat_ << "\n"
4392 << " Expected result:\n( -4 0 7 0 0 0 )\n"
4393 "( 0 0 4 -8 0 0 )\n"
4394 "( 0 1 -6 5 9 0 )\n"
4395 "( 0 0 0 0 -6 10 )\n";
4396 throw std::runtime_error( oss.str() );
4397 }
4398 }
4399
4400
4401 //=====================================================================================
4402 // Row-major Band::scale()
4403 //=====================================================================================
4404
4405 {
4406 test_ = "Row-major Band::scale()";
4407
4408 initialize();
4409
4410 // Integral scaling the 1st upper band
4411 {
4412 BT band1 = blaze::band( mat_, 1L );
4413 band1.scale( 3 );
4414
4415 checkSize ( band1, 4UL );
4416 checkCapacity( band1, 4UL );
4417 checkNonZeros( band1, 3UL );
4418 checkRows ( mat_ , 4UL );
4419 checkColumns ( mat_ , 6UL );
4420 checkNonZeros( mat_ , 10UL );
4421
4422 if( band1[0] != 0 || band1[1] != 12 || band1[2] != 15 || band1[3] != -18 ) {
4423 std::ostringstream oss;
4424 oss << " Test: " << test_ << "\n"
4425 << " Error: Integral scale operation of 1st upper band failed\n"
4426 << " Details:\n"
4427 << " Result:\n" << band1 << "\n"
4428 << " Expected result:\n( 0 12 15 -18 )\n";
4429 throw std::runtime_error( oss.str() );
4430 }
4431
4432 if( mat_(0,0) != -2 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
4433 mat_(1,0) != 0 || mat_(1,1) != 0 || mat_(1,2) != 12 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
4434 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != -3 || mat_(2,3) != 15 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
4435 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != -18 || mat_(3,5) != 10 ) {
4436 std::ostringstream oss;
4437 oss << " Test: " << test_ << "\n"
4438 << " Error: Integral scale operation of 3rd row failed\n"
4439 << " Details:\n"
4440 << " Result:\n" << mat_ << "\n"
4441 << " Expected result:\n( -2 0 7 0 0 0 )\n"
4442 "( 0 0 12 -8 0 0 )\n"
4443 "( 0 1 -3 15 9 0 )\n"
4444 "( 0 0 0 0 -18 10 )\n";
4445 throw std::runtime_error( oss.str() );
4446 }
4447 }
4448
4449 // Floating point scaling the 1st upper band
4450 {
4451 BT band1 = blaze::band( mat_, 1L );
4452 band1.scale( 0.5 );
4453
4454 checkSize ( band1, 4UL );
4455 checkCapacity( band1, 4UL );
4456 checkNonZeros( band1, 3UL );
4457 checkRows ( mat_ , 4UL );
4458 checkColumns ( mat_ , 6UL );
4459 checkNonZeros( mat_ , 10UL );
4460
4461 if( band1[0] != 0 || band1[1] != 6 || band1[2] != 7 || band1[3] != -9 ) {
4462 std::ostringstream oss;
4463 oss << " Test: " << test_ << "\n"
4464 << " Error: Floating point scale operation of 3rd row failed\n"
4465 << " Details:\n"
4466 << " Result:\n" << band1 << "\n"
4467 << " Expected result:\n( 0 6 7 -9 )\n";
4468 throw std::runtime_error( oss.str() );
4469 }
4470
4471 if( mat_(0,0) != -2 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
4472 mat_(1,0) != 0 || mat_(1,1) != 0 || mat_(1,2) != 6 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
4473 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != -3 || mat_(2,3) != 7 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
4474 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != -9 || mat_(3,5) != 10 ) {
4475 std::ostringstream oss;
4476 oss << " Test: " << test_ << "\n"
4477 << " Error: Floating point scale operation of 3rd row failed\n"
4478 << " Details:\n"
4479 << " Result:\n" << mat_ << "\n"
4480 << " Expected result:\n( -2 0 7 0 0 0 )\n"
4481 "( 0 0 6 -8 0 0 )\n"
4482 "( 0 1 -3 7 9 0 )\n"
4483 "( 0 0 0 0 -9 10 )\n";
4484 throw std::runtime_error( oss.str() );
4485 }
4486 }
4487 }
4488
4489
4490 //=====================================================================================
4491 // Column-major self-scaling (v*=s)
4492 //=====================================================================================
4493
4494 {
4495 test_ = "Column-major self-scaling (v*=s)";
4496
4497 initialize();
4498
4499 OBT band0 = blaze::band( tmat_, 0L );
4500
4501 band0 *= 3;
4502
4503 checkSize ( band0, 4UL );
4504 checkCapacity( band0, 4UL );
4505 checkNonZeros( band0, 2UL );
4506 checkRows ( tmat_, 6UL );
4507 checkColumns ( tmat_, 4UL );
4508 checkNonZeros( tmat_, 10UL );
4509
4510 if( band0[0] != -6 || band0[1] != 0 || band0[2] != -9 || band0[3] != 0 ) {
4511 std::ostringstream oss;
4512 oss << " Test: " << test_ << "\n"
4513 << " Error: Failed self-scaling operation\n"
4514 << " Details:\n"
4515 << " Result:\n" << band0 << "\n"
4516 << " Expected result:\n( -6 0 -9 0 )\n";
4517 throw std::runtime_error( oss.str() );
4518 }
4519
4520 if( tmat_(0,0) != -6 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
4521 tmat_(1,0) != 0 || tmat_(1,1) != 0 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
4522 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != -9 || tmat_(2,3) != 0 ||
4523 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
4524 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
4525 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
4526 std::ostringstream oss;
4527 oss << " Test: " << test_ << "\n"
4528 << " Error: Failed self-scaling operation\n"
4529 << " Details:\n"
4530 << " Result:\n" << tmat_ << "\n"
4531 << " Expected result:\n( -6 0 0 0 )\n"
4532 "( 0 0 1 0 )\n"
4533 "( 7 4 -9 0 )\n"
4534 "( 0 -8 5 0 )\n"
4535 "( 0 0 9 -6 )\n"
4536 "( 0 0 0 10 )\n";
4537 throw std::runtime_error( oss.str() );
4538 }
4539 }
4540
4541
4542 //=====================================================================================
4543 // Column-major self-scaling (v=v*s)
4544 //=====================================================================================
4545
4546 {
4547 test_ = "Column-major self-scaling (v=v*s)";
4548
4549 initialize();
4550
4551 OBT band0 = blaze::band( tmat_, 0L );
4552
4553 band0 = band0 * 3;
4554
4555 checkSize ( band0, 4UL );
4556 checkCapacity( band0, 4UL );
4557 checkNonZeros( band0, 2UL );
4558 checkRows ( tmat_, 6UL );
4559 checkColumns ( tmat_, 4UL );
4560 checkNonZeros( tmat_, 10UL );
4561
4562 if( band0[0] != -6 || band0[1] != 0 || band0[2] != -9 || band0[3] != 0 ) {
4563 std::ostringstream oss;
4564 oss << " Test: " << test_ << "\n"
4565 << " Error: Failed self-scaling operation\n"
4566 << " Details:\n"
4567 << " Result:\n" << band0 << "\n"
4568 << " Expected result:\n( -6 0 -9 0 )\n";
4569 throw std::runtime_error( oss.str() );
4570 }
4571
4572 if( tmat_(0,0) != -6 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
4573 tmat_(1,0) != 0 || tmat_(1,1) != 0 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
4574 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != -9 || tmat_(2,3) != 0 ||
4575 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
4576 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
4577 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
4578 std::ostringstream oss;
4579 oss << " Test: " << test_ << "\n"
4580 << " Error: Failed self-scaling operation\n"
4581 << " Details:\n"
4582 << " Result:\n" << tmat_ << "\n"
4583 << " Expected result:\n( -6 0 0 0 )\n"
4584 "( 0 0 1 0 )\n"
4585 "( 7 4 -9 0 )\n"
4586 "( 0 -8 5 0 )\n"
4587 "( 0 0 9 -6 )\n"
4588 "( 0 0 0 10 )\n";
4589 throw std::runtime_error( oss.str() );
4590 }
4591 }
4592
4593
4594 //=====================================================================================
4595 // Column-major self-scaling (v=s*v)
4596 //=====================================================================================
4597
4598 {
4599 test_ = "Column-major self-scaling (v=s*v)";
4600
4601 initialize();
4602
4603 OBT band0 = blaze::band( tmat_, 0L );
4604
4605 band0 = 3 * band0;
4606
4607 checkSize ( band0, 4UL );
4608 checkCapacity( band0, 4UL );
4609 checkNonZeros( band0, 2UL );
4610 checkRows ( tmat_, 6UL );
4611 checkColumns ( tmat_, 4UL );
4612 checkNonZeros( tmat_, 10UL );
4613
4614 if( band0[0] != -6 || band0[1] != 0 || band0[2] != -9 || band0[3] != 0 ) {
4615 std::ostringstream oss;
4616 oss << " Test: " << test_ << "\n"
4617 << " Error: Failed self-scaling operation\n"
4618 << " Details:\n"
4619 << " Result:\n" << band0 << "\n"
4620 << " Expected result:\n( -6 0 -9 0 )\n";
4621 throw std::runtime_error( oss.str() );
4622 }
4623
4624 if( tmat_(0,0) != -6 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
4625 tmat_(1,0) != 0 || tmat_(1,1) != 0 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
4626 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != -9 || tmat_(2,3) != 0 ||
4627 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
4628 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
4629 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
4630 std::ostringstream oss;
4631 oss << " Test: " << test_ << "\n"
4632 << " Error: Failed self-scaling operation\n"
4633 << " Details:\n"
4634 << " Result:\n" << tmat_ << "\n"
4635 << " Expected result:\n( -6 0 0 0 )\n"
4636 "( 0 0 1 0 )\n"
4637 "( 7 4 -9 0 )\n"
4638 "( 0 -8 5 0 )\n"
4639 "( 0 0 9 -6 )\n"
4640 "( 0 0 0 10 )\n";
4641 throw std::runtime_error( oss.str() );
4642 }
4643 }
4644
4645
4646 //=====================================================================================
4647 // Column-major self-scaling (v/=s)
4648 //=====================================================================================
4649
4650 {
4651 test_ = "Column-major self-scaling (v/=s)";
4652
4653 initialize();
4654
4655 OBT band0 = blaze::band( tmat_, 0L );
4656
4657 band0 /= 0.5;
4658
4659 checkSize ( band0, 4UL );
4660 checkCapacity( band0, 4UL );
4661 checkNonZeros( band0, 2UL );
4662 checkRows ( tmat_, 6UL );
4663 checkColumns ( tmat_, 4UL );
4664 checkNonZeros( tmat_, 10UL );
4665
4666 if( band0[0] != -4 || band0[1] != 0 || band0[2] != -6 || band0[3] != 0 ) {
4667 std::ostringstream oss;
4668 oss << " Test: " << test_ << "\n"
4669 << " Error: Failed self-scaling operation\n"
4670 << " Details:\n"
4671 << " Result:\n" << band0 << "\n"
4672 << " Expected result:\n( -4 0 -6 0 )\n";
4673 throw std::runtime_error( oss.str() );
4674 }
4675
4676 if( tmat_(0,0) != -4 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
4677 tmat_(1,0) != 0 || tmat_(1,1) != 0 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
4678 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != -6 || tmat_(2,3) != 0 ||
4679 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
4680 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
4681 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
4682 std::ostringstream oss;
4683 oss << " Test: " << test_ << "\n"
4684 << " Error: Failed self-scaling operation\n"
4685 << " Details:\n"
4686 << " Result:\n" << tmat_ << "\n"
4687 << " Expected result:\n( -4 0 0 0 )\n"
4688 "( 0 0 1 0 )\n"
4689 "( 7 4 -6 0 )\n"
4690 "( 0 -8 5 0 )\n"
4691 "( 0 0 9 -6 )\n"
4692 "( 0 0 0 10 )\n";
4693 throw std::runtime_error( oss.str() );
4694 }
4695 }
4696
4697
4698 //=====================================================================================
4699 // Column-major self-scaling (v=v/s)
4700 //=====================================================================================
4701
4702 {
4703 test_ = "Column-major self-scaling (v=v/s)";
4704
4705 initialize();
4706
4707 OBT band0 = blaze::band( tmat_, 0L );
4708
4709 band0 = band0 / 0.5;
4710
4711 checkSize ( band0, 4UL );
4712 checkCapacity( band0, 4UL );
4713 checkNonZeros( band0, 2UL );
4714 checkRows ( tmat_, 6UL );
4715 checkColumns ( tmat_, 4UL );
4716 checkNonZeros( tmat_, 10UL );
4717
4718 if( band0[0] != -4 || band0[1] != 0 || band0[2] != -6 || band0[3] != 0 ) {
4719 std::ostringstream oss;
4720 oss << " Test: " << test_ << "\n"
4721 << " Error: Failed self-scaling operation\n"
4722 << " Details:\n"
4723 << " Result:\n" << band0 << "\n"
4724 << " Expected result:\n( -4 0 -6 0 )\n";
4725 throw std::runtime_error( oss.str() );
4726 }
4727
4728 if( tmat_(0,0) != -4 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
4729 tmat_(1,0) != 0 || tmat_(1,1) != 0 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
4730 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != -6 || tmat_(2,3) != 0 ||
4731 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
4732 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
4733 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
4734 std::ostringstream oss;
4735 oss << " Test: " << test_ << "\n"
4736 << " Error: Failed self-scaling operation\n"
4737 << " Details:\n"
4738 << " Result:\n" << tmat_ << "\n"
4739 << " Expected result:\n( -4 0 0 0 )\n"
4740 "( 0 0 1 0 )\n"
4741 "( 7 4 -6 0 )\n"
4742 "( 0 -8 5 0 )\n"
4743 "( 0 0 9 -6 )\n"
4744 "( 0 0 0 10 )\n";
4745 throw std::runtime_error( oss.str() );
4746 }
4747 }
4748
4749
4750 //=====================================================================================
4751 // Column-major Band::scale()
4752 //=====================================================================================
4753
4754 {
4755 test_ = "Column-major Band::scale()";
4756
4757 initialize();
4758
4759 // Integral scaling the 1st lower band
4760 {
4761 OBT band1 = blaze::band( tmat_, -1L );
4762 band1.scale( 3 );
4763
4764 checkSize ( band1, 4UL );
4765 checkCapacity( band1, 4UL );
4766 checkNonZeros( band1, 3UL );
4767 checkRows ( tmat_, 6UL );
4768 checkColumns ( tmat_, 4UL );
4769 checkNonZeros( tmat_, 10UL );
4770
4771 if( band1[0] != 0 || band1[1] != 12 || band1[2] != 15 || band1[3] != -18 ) {
4772 std::ostringstream oss;
4773 oss << " Test: " << test_ << "\n"
4774 << " Error: Integral scale operation of 1st lower band failed\n"
4775 << " Details:\n"
4776 << " Result:\n" << band1 << "\n"
4777 << " Expected result:\n( 0 12 15 -18 )\n";
4778 throw std::runtime_error( oss.str() );
4779 }
4780
4781 if( tmat_(0,0) != -2 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
4782 tmat_(1,0) != 0 || tmat_(1,1) != 0 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
4783 tmat_(2,0) != 7 || tmat_(2,1) != 12 || tmat_(2,2) != -3 || tmat_(2,3) != 0 ||
4784 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 15 || tmat_(3,3) != 0 ||
4785 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -18 ||
4786 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
4787 std::ostringstream oss;
4788 oss << " Test: " << test_ << "\n"
4789 << " Error: Integral scale operation of 1st lower band failed\n"
4790 << " Details:\n"
4791 << " Result:\n" << tmat_ << "\n"
4792 << " Expected result:\n( -2 0 0 0 )\n"
4793 "( 0 0 1 0 )\n"
4794 "( 7 12 -3 0 )\n"
4795 "( 0 -8 15 0 )\n"
4796 "( 0 0 9 -18 )\n"
4797 "( 0 0 0 10 )\n";
4798 throw std::runtime_error( oss.str() );
4799 }
4800 }
4801
4802 // Floating point scaling the first lower band
4803 {
4804 OBT band1 = blaze::band( tmat_, -1L );
4805 band1.scale( 0.5 );
4806
4807 checkSize ( band1, 4UL );
4808 checkCapacity( band1, 4UL );
4809 checkNonZeros( band1, 3UL );
4810 checkRows ( tmat_, 6UL );
4811 checkColumns ( tmat_, 4UL );
4812 checkNonZeros( tmat_, 10UL );
4813
4814 if( band1[0] != 0 || band1[1] != 6 || band1[2] != 7 || band1[3] != -9 ) {
4815 std::ostringstream oss;
4816 oss << " Test: " << test_ << "\n"
4817 << " Error: Floating point scale operation of 1st lower band failed\n"
4818 << " Details:\n"
4819 << " Result:\n" << band1 << "\n"
4820 << " Expected result:\n( 0 6 7 -9 )\n";
4821 throw std::runtime_error( oss.str() );
4822 }
4823
4824 if( tmat_(0,0) != -2 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
4825 tmat_(1,0) != 0 || tmat_(1,1) != 0 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
4826 tmat_(2,0) != 7 || tmat_(2,1) != 6 || tmat_(2,2) != -3 || tmat_(2,3) != 0 ||
4827 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 7 || tmat_(3,3) != 0 ||
4828 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -9 ||
4829 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
4830 std::ostringstream oss;
4831 oss << " Test: " << test_ << "\n"
4832 << " Error: Integral scale operation of 1st lower band failed\n"
4833 << " Details:\n"
4834 << " Result:\n" << tmat_ << "\n"
4835 << " Expected result:\n( -2 0 0 0 )\n"
4836 "( 0 0 1 0 )\n"
4837 "( 7 6 -3 0 )\n"
4838 "( 0 -8 7 0 )\n"
4839 "( 0 0 9 -9 )\n"
4840 "( 0 0 0 10 )\n";
4841 throw std::runtime_error( oss.str() );
4842 }
4843 }
4844 }
4845 }
4846 //*************************************************************************************************
4847
4848
4849 //*************************************************************************************************
4850 /*!\brief Test of the Band subscript operator.
4851 //
4852 // \return void
4853 // \exception std::runtime_error Error detected.
4854 //
4855 // This function performs a test of adding and accessing elements via the subscript operator
4856 // of the Band specialization. In case an error is detected, a \a std::runtime_error exception
4857 // is thrown.
4858 */
testSubscript()4859 void DenseTest::testSubscript()
4860 {
4861 //=====================================================================================
4862 // Row-major matrix tests
4863 //=====================================================================================
4864
4865 {
4866 test_ = "Row-major Band::operator[]";
4867
4868 initialize();
4869
4870 BT band0 = blaze::band( mat_, 0L );
4871
4872 // Assignment to the element at index 1
4873 band0[1] = 9;
4874
4875 checkSize ( band0, 4UL );
4876 checkCapacity( band0, 4UL );
4877 checkNonZeros( band0, 3UL );
4878
4879 if( band0[0] != -2 || band0[1] != 9 || band0[2] != -3 || band0[3] != 0 ) {
4880 std::ostringstream oss;
4881 oss << " Test: " << test_ << "\n"
4882 << " Error: Subscript operator failed\n"
4883 << " Details:\n"
4884 << " Result:\n" << band0 << "\n"
4885 << " Expected result:\n( -2 9 -3 0 )\n";
4886 throw std::runtime_error( oss.str() );
4887 }
4888
4889 if( mat_(0,0) != -2 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
4890 mat_(1,0) != 0 || mat_(1,1) != 9 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
4891 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != -3 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
4892 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
4893 std::ostringstream oss;
4894 oss << " Test: " << test_ << "\n"
4895 << " Error: Subscript operator failed\n"
4896 << " Details:\n"
4897 << " Result:\n" << mat_ << "\n"
4898 << " Expected result:\n( -2 0 7 0 0 0 )\n"
4899 "( 0 9 4 -8 0 0 )\n"
4900 "( 0 1 -3 5 9 0 )\n"
4901 "( 0 0 0 0 -6 10 )\n";
4902 throw std::runtime_error( oss.str() );
4903 }
4904
4905 // Assignment to the element at index 2
4906 band0[2] = 0;
4907
4908 checkSize ( band0, 4UL );
4909 checkCapacity( band0, 4UL );
4910 checkNonZeros( band0, 2UL );
4911
4912 if( band0[0] != -2 || band0[1] != 9 || band0[2] != 0 || band0[3] != 0 ) {
4913 std::ostringstream oss;
4914 oss << " Test: " << test_ << "\n"
4915 << " Error: Subscript operator failed\n"
4916 << " Details:\n"
4917 << " Result:\n" << band0 << "\n"
4918 << " Expected result:\n( -2 9 0 0 )\n";
4919 throw std::runtime_error( oss.str() );
4920 }
4921
4922 if( mat_(0,0) != -2 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
4923 mat_(1,0) != 0 || mat_(1,1) != 9 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
4924 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != 0 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
4925 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 0 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
4926 std::ostringstream oss;
4927 oss << " Test: " << test_ << "\n"
4928 << " Error: Subscript operator failed\n"
4929 << " Details:\n"
4930 << " Result:\n" << mat_ << "\n"
4931 << " Expected result:\n( -2 0 7 0 0 0 )\n"
4932 "( 0 9 4 -8 0 0 )\n"
4933 "( 0 1 0 5 9 0 )\n"
4934 "( 0 0 0 0 -6 10 )\n";
4935 throw std::runtime_error( oss.str() );
4936 }
4937
4938 // Assignment to the element at index 3
4939 band0[3] = -8;
4940
4941 checkSize ( band0, 4UL );
4942 checkCapacity( band0, 4UL );
4943 checkNonZeros( band0, 3UL );
4944
4945 if( band0[0] != -2 || band0[1] != 9 || band0[2] != 0 || band0[3] != -8 ) {
4946 std::ostringstream oss;
4947 oss << " Test: " << test_ << "\n"
4948 << " Error: Subscript operator failed\n"
4949 << " Details:\n"
4950 << " Result:\n" << band0 << "\n"
4951 << " Expected result:\n( -2 9 0 -8 )\n";
4952 throw std::runtime_error( oss.str() );
4953 }
4954
4955 if( mat_(0,0) != -2 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
4956 mat_(1,0) != 0 || mat_(1,1) != 9 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
4957 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != 0 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
4958 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != -8 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
4959 std::ostringstream oss;
4960 oss << " Test: " << test_ << "\n"
4961 << " Error: Subscript operator failed\n"
4962 << " Details:\n"
4963 << " Result:\n" << mat_ << "\n"
4964 << " Expected result:\n( -2 0 7 0 0 0 )\n"
4965 "( 0 9 4 -8 0 0 )\n"
4966 "( 0 1 0 5 9 0 )\n"
4967 "( 0 0 0 -8 -6 10 )\n";
4968 throw std::runtime_error( oss.str() );
4969 }
4970
4971 // Addition assignment to the element at index 0
4972 band0[0] += -3;
4973
4974 checkSize ( band0, 4UL );
4975 checkCapacity( band0, 4UL );
4976 checkNonZeros( band0, 3UL );
4977
4978 if( band0[0] != -5 || band0[1] != 9 || band0[2] != 0 || band0[3] != -8 ) {
4979 std::ostringstream oss;
4980 oss << " Test: " << test_ << "\n"
4981 << " Error: Subscript operator failed\n"
4982 << " Details:\n"
4983 << " Result:\n" << band0 << "\n"
4984 << " Expected result:\n( -5 9 0 -8 )\n";
4985 throw std::runtime_error( oss.str() );
4986 }
4987
4988 if( mat_(0,0) != -5 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
4989 mat_(1,0) != 0 || mat_(1,1) != 9 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
4990 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != 0 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
4991 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != -8 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
4992 std::ostringstream oss;
4993 oss << " Test: " << test_ << "\n"
4994 << " Error: Subscript operator failed\n"
4995 << " Details:\n"
4996 << " Result:\n" << mat_ << "\n"
4997 << " Expected result:\n( -5 0 7 0 0 0 )\n"
4998 "( 0 9 4 -8 0 0 )\n"
4999 "( 0 1 0 5 9 0 )\n"
5000 "( 0 0 0 -8 -6 10 )\n";
5001 throw std::runtime_error( oss.str() );
5002 }
5003
5004 // Subtraction assignment to the element at index 1
5005 band0[1] -= 6;
5006
5007 checkSize ( band0, 4UL );
5008 checkCapacity( band0, 4UL );
5009 checkNonZeros( band0, 3UL );
5010
5011 if( band0[0] != -5 || band0[1] != 3 || band0[2] != 0 || band0[3] != -8 ) {
5012 std::ostringstream oss;
5013 oss << " Test: " << test_ << "\n"
5014 << " Error: Subscript operator failed\n"
5015 << " Details:\n"
5016 << " Result:\n" << band0 << "\n"
5017 << " Expected result:\n( -5 3 0 -8 )\n";
5018 throw std::runtime_error( oss.str() );
5019 }
5020
5021 if( mat_(0,0) != -5 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
5022 mat_(1,0) != 0 || mat_(1,1) != 3 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
5023 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != 0 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
5024 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != -8 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
5025 std::ostringstream oss;
5026 oss << " Test: " << test_ << "\n"
5027 << " Error: Subscript operator failed\n"
5028 << " Details:\n"
5029 << " Result:\n" << mat_ << "\n"
5030 << " Expected result:\n( -5 0 7 0 0 0 )\n"
5031 "( 0 3 4 -8 0 0 )\n"
5032 "( 0 1 0 5 9 0 )\n"
5033 "( 0 0 0 -8 -6 10 )\n";
5034 throw std::runtime_error( oss.str() );
5035 }
5036
5037 // Multiplication assignment to the element at index 1
5038 band0[1] *= -3;
5039
5040 checkSize ( band0, 4UL );
5041 checkCapacity( band0, 4UL );
5042 checkNonZeros( band0, 3UL );
5043
5044 if( band0[0] != -5 || band0[1] != -9 || band0[2] != 0 || band0[3] != -8 ) {
5045 std::ostringstream oss;
5046 oss << " Test: " << test_ << "\n"
5047 << " Error: Subscript operator failed\n"
5048 << " Details:\n"
5049 << " Result:\n" << band0 << "\n"
5050 << " Expected result:\n( -5 -9 0 -8 )\n";
5051 throw std::runtime_error( oss.str() );
5052 }
5053
5054 if( mat_(0,0) != -5 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
5055 mat_(1,0) != 0 || mat_(1,1) != -9 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
5056 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != 0 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
5057 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != -8 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
5058 std::ostringstream oss;
5059 oss << " Test: " << test_ << "\n"
5060 << " Error: Subscript operator failed\n"
5061 << " Details:\n"
5062 << " Result:\n" << mat_ << "\n"
5063 << " Expected result:\n( -5 0 7 0 0 0 )\n"
5064 "( 0 -9 4 -8 0 0 )\n"
5065 "( 0 1 0 5 9 0 )\n"
5066 "( 0 0 0 -8 -6 10 )\n";
5067 throw std::runtime_error( oss.str() );
5068 }
5069
5070 // Division assignment to the element at index 3
5071 band0[3] /= 2;
5072
5073 checkSize ( band0, 4UL );
5074 checkCapacity( band0, 4UL );
5075 checkNonZeros( band0, 3UL );
5076
5077 if( band0[0] != -5 || band0[1] != -9 || band0[2] != 0 || band0[3] != -4 ) {
5078 std::ostringstream oss;
5079 oss << " Test: " << test_ << "\n"
5080 << " Error: Subscript operator failed\n"
5081 << " Details:\n"
5082 << " Result:\n" << band0 << "\n"
5083 << " Expected result:\n( -5 -9 0 -4 )\n";
5084 throw std::runtime_error( oss.str() );
5085 }
5086
5087 if( mat_(0,0) != -5 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
5088 mat_(1,0) != 0 || mat_(1,1) != -9 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
5089 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != 0 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
5090 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != -4 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
5091 std::ostringstream oss;
5092 oss << " Test: " << test_ << "\n"
5093 << " Error: Subscript operator failed\n"
5094 << " Details:\n"
5095 << " Result:\n" << mat_ << "\n"
5096 << " Expected result:\n( -5 0 7 0 0 0 )\n"
5097 "( 0 -9 4 -8 0 0 )\n"
5098 "( 0 1 0 5 9 0 )\n"
5099 "( 0 0 0 -4 -6 10 )\n";
5100 throw std::runtime_error( oss.str() );
5101 }
5102 }
5103
5104
5105 //=====================================================================================
5106 // Column-major matrix tests
5107 //=====================================================================================
5108
5109 {
5110 test_ = "Column-major Band::operator[]";
5111
5112 initialize();
5113
5114 OBT band0 = blaze::band( tmat_, 0L );
5115
5116 // Assignment to the element at index 1
5117 band0[1] = 9;
5118
5119 checkSize ( band0, 4UL );
5120 checkCapacity( band0, 4UL );
5121 checkNonZeros( band0, 3UL );
5122
5123 if( band0[0] != -2 || band0[1] != 9 || band0[2] != -3 || band0[3] != 0 ) {
5124 std::ostringstream oss;
5125 oss << " Test: " << test_ << "\n"
5126 << " Error: Subscript operator failed\n"
5127 << " Details:\n"
5128 << " Result:\n" << band0 << "\n"
5129 << " Expected result:\n( -2 9 -3 0 )\n";
5130 throw std::runtime_error( oss.str() );
5131 }
5132
5133 if( tmat_(0,0) != -2 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
5134 tmat_(1,0) != 0 || tmat_(1,1) != 9 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
5135 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != -3 || tmat_(2,3) != 0 ||
5136 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
5137 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
5138 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
5139 std::ostringstream oss;
5140 oss << " Test: " << test_ << "\n"
5141 << " Error: Subscript operator failed\n"
5142 << " Details:\n"
5143 << " Result:\n" << tmat_ << "\n"
5144 << " Expected result:\n( -2 0 0 0 )\n"
5145 "( 0 9 1 0 )\n"
5146 "( 7 4 -3 0 )\n"
5147 "( 0 -8 5 0 )\n"
5148 "( 0 0 9 -6 )\n"
5149 "( 0 0 0 10 )\n";
5150 throw std::runtime_error( oss.str() );
5151 }
5152
5153 // Assignment to the element at index 2
5154 band0[2] = 0;
5155
5156 checkSize ( band0, 4UL );
5157 checkCapacity( band0, 4UL );
5158 checkNonZeros( band0, 2UL );
5159
5160 if( band0[0] != -2 || band0[1] != 9 || band0[2] != 0 || band0[3] != 0 ) {
5161 std::ostringstream oss;
5162 oss << " Test: " << test_ << "\n"
5163 << " Error: Subscript operator failed\n"
5164 << " Details:\n"
5165 << " Result:\n" << band0 << "\n"
5166 << " Expected result:\n( -2 9 0 0 )\n";
5167 throw std::runtime_error( oss.str() );
5168 }
5169
5170 if( tmat_(0,0) != -2 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
5171 tmat_(1,0) != 0 || tmat_(1,1) != 9 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
5172 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != 0 || tmat_(2,3) != 0 ||
5173 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 0 ||
5174 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
5175 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
5176 std::ostringstream oss;
5177 oss << " Test: " << test_ << "\n"
5178 << " Error: Subscript operator failed\n"
5179 << " Details:\n"
5180 << " Result:\n" << tmat_ << "\n"
5181 << " Expected result:\n( -2 0 0 0 )\n"
5182 "( 0 9 1 0 )\n"
5183 "( 7 4 0 0 )\n"
5184 "( 0 -8 5 0 )\n"
5185 "( 0 0 9 -6 )\n"
5186 "( 0 0 0 10 )\n";
5187 throw std::runtime_error( oss.str() );
5188 }
5189
5190 // Assignment to the element at index 3
5191 band0[3] = -8;
5192
5193 checkSize ( band0, 4UL );
5194 checkCapacity( band0, 4UL );
5195 checkNonZeros( band0, 3UL );
5196
5197 if( band0[0] != -2 || band0[1] != 9 || band0[2] != 0 || band0[3] != -8 ) {
5198 std::ostringstream oss;
5199 oss << " Test: " << test_ << "\n"
5200 << " Error: Subscript operator failed\n"
5201 << " Details:\n"
5202 << " Result:\n" << band0 << "\n"
5203 << " Expected result:\n( -2 9 0 -8 )\n";
5204 throw std::runtime_error( oss.str() );
5205 }
5206
5207 if( tmat_(0,0) != -2 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
5208 tmat_(1,0) != 0 || tmat_(1,1) != 9 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
5209 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != 0 || tmat_(2,3) != 0 ||
5210 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != -8 ||
5211 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
5212 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
5213 std::ostringstream oss;
5214 oss << " Test: " << test_ << "\n"
5215 << " Error: Subscript operator failed\n"
5216 << " Details:\n"
5217 << " Result:\n" << tmat_ << "\n"
5218 << " Expected result:\n( -2 0 0 0 )\n"
5219 "( 0 9 1 0 )\n"
5220 "( 7 4 0 0 )\n"
5221 "( 0 -8 5 -8 )\n"
5222 "( 0 0 9 -6 )\n"
5223 "( 0 0 0 10 )\n";
5224 throw std::runtime_error( oss.str() );
5225 }
5226
5227 // Addition assignment to the element at index 0
5228 band0[0] += -3;
5229
5230 checkSize ( band0, 4UL );
5231 checkCapacity( band0, 4UL );
5232 checkNonZeros( band0, 3UL );
5233
5234 if( band0[0] != -5 || band0[1] != 9 || band0[2] != 0 || band0[3] != -8 ) {
5235 std::ostringstream oss;
5236 oss << " Test: " << test_ << "\n"
5237 << " Error: Subscript operator failed\n"
5238 << " Details:\n"
5239 << " Result:\n" << band0 << "\n"
5240 << " Expected result:\n( -5 9 0 -8 )\n";
5241 throw std::runtime_error( oss.str() );
5242 }
5243
5244 if( tmat_(0,0) != -5 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
5245 tmat_(1,0) != 0 || tmat_(1,1) != 9 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
5246 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != 0 || tmat_(2,3) != 0 ||
5247 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != -8 ||
5248 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
5249 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
5250 std::ostringstream oss;
5251 oss << " Test: " << test_ << "\n"
5252 << " Error: Subscript operator failed\n"
5253 << " Details:\n"
5254 << " Result:\n" << tmat_ << "\n"
5255 << " Expected result:\n( -5 0 0 0 )\n"
5256 "( 0 9 1 0 )\n"
5257 "( 7 4 0 0 )\n"
5258 "( 0 -8 5 -8 )\n"
5259 "( 0 0 9 -6 )\n"
5260 "( 0 0 0 10 )\n";
5261 throw std::runtime_error( oss.str() );
5262 }
5263
5264 // Subtraction assignment to the element at index 1
5265 band0[1] -= 6;
5266
5267 checkSize ( band0, 4UL );
5268 checkCapacity( band0, 4UL );
5269 checkNonZeros( band0, 3UL );
5270
5271 if( band0[0] != -5 || band0[1] != 3 || band0[2] != 0 || band0[3] != -8 ) {
5272 std::ostringstream oss;
5273 oss << " Test: " << test_ << "\n"
5274 << " Error: Subscript operator failed\n"
5275 << " Details:\n"
5276 << " Result:\n" << band0 << "\n"
5277 << " Expected result:\n( -5 3 0 -8 )\n";
5278 throw std::runtime_error( oss.str() );
5279 }
5280
5281 if( tmat_(0,0) != -5 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
5282 tmat_(1,0) != 0 || tmat_(1,1) != 3 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
5283 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != 0 || tmat_(2,3) != 0 ||
5284 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != -8 ||
5285 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
5286 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
5287 std::ostringstream oss;
5288 oss << " Test: " << test_ << "\n"
5289 << " Error: Subscript operator failed\n"
5290 << " Details:\n"
5291 << " Result:\n" << tmat_ << "\n"
5292 << " Expected result:\n( -5 0 0 0 )\n"
5293 "( 0 3 1 0 )\n"
5294 "( 7 4 0 0 )\n"
5295 "( 0 -8 5 -8 )\n"
5296 "( 0 0 9 -6 )\n"
5297 "( 0 0 0 10 )\n";
5298 throw std::runtime_error( oss.str() );
5299 }
5300
5301 // Multiplication assignment to the element at index 1
5302 band0[1] *= -3;
5303
5304 checkSize ( band0, 4UL );
5305 checkCapacity( band0, 4UL );
5306 checkNonZeros( band0, 3UL );
5307
5308 if( band0[0] != -5 || band0[1] != -9 || band0[2] != 0 || band0[3] != -8 ) {
5309 std::ostringstream oss;
5310 oss << " Test: " << test_ << "\n"
5311 << " Error: Subscript operator failed\n"
5312 << " Details:\n"
5313 << " Result:\n" << band0 << "\n"
5314 << " Expected result:\n( -5 -9 0 -8 )\n";
5315 throw std::runtime_error( oss.str() );
5316 }
5317
5318 if( tmat_(0,0) != -5 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
5319 tmat_(1,0) != 0 || tmat_(1,1) != -9 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
5320 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != 0 || tmat_(2,3) != 0 ||
5321 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != -8 ||
5322 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
5323 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
5324 std::ostringstream oss;
5325 oss << " Test: " << test_ << "\n"
5326 << " Error: Subscript operator failed\n"
5327 << " Details:\n"
5328 << " Result:\n" << tmat_ << "\n"
5329 << " Expected result:\n( -5 0 0 0 )\n"
5330 "( 0 -9 1 0 )\n"
5331 "( 7 4 0 0 )\n"
5332 "( 0 -8 5 -8 )\n"
5333 "( 0 0 9 -6 )\n"
5334 "( 0 0 0 10 )\n";
5335 throw std::runtime_error( oss.str() );
5336 }
5337
5338 // Division assignment to the element at index 3
5339 band0[3] /= 2;
5340
5341 checkSize ( band0, 4UL );
5342 checkCapacity( band0, 4UL );
5343 checkNonZeros( band0, 3UL );
5344
5345 if( band0[0] != -5 || band0[1] != -9 || band0[2] != 0 || band0[3] != -4 ) {
5346 std::ostringstream oss;
5347 oss << " Test: " << test_ << "\n"
5348 << " Error: Subscript operator failed\n"
5349 << " Details:\n"
5350 << " Result:\n" << band0 << "\n"
5351 << " Expected result:\n( -5 -9 0 -4 )\n";
5352 throw std::runtime_error( oss.str() );
5353 }
5354
5355 if( tmat_(0,0) != -5 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
5356 tmat_(1,0) != 0 || tmat_(1,1) != -9 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
5357 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != 0 || tmat_(2,3) != 0 ||
5358 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != -4 ||
5359 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
5360 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
5361 std::ostringstream oss;
5362 oss << " Test: " << test_ << "\n"
5363 << " Error: Subscript operator failed\n"
5364 << " Details:\n"
5365 << " Result:\n" << tmat_ << "\n"
5366 << " Expected result:\n( -5 0 0 0 )\n"
5367 "( 0 -9 1 0 )\n"
5368 "( 7 4 0 0 )\n"
5369 "( 0 -8 5 -4 )\n"
5370 "( 0 0 9 -6 )\n"
5371 "( 0 0 0 10 )\n";
5372 throw std::runtime_error( oss.str() );
5373 }
5374 }
5375 }
5376 //*************************************************************************************************
5377
5378
5379 //*************************************************************************************************
5380 /*!\brief Test of the Band iterator implementation.
5381 //
5382 // \return void
5383 // \exception std::runtime_error Error detected.
5384 //
5385 // This function performs a test of the iterator implementation of the Band specialization.
5386 // In case an error is detected, a \a std::runtime_error exception is thrown.
5387 */
testIterator()5388 void DenseTest::testIterator()
5389 {
5390 //=====================================================================================
5391 // Row-major matrix tests
5392 //=====================================================================================
5393
5394 {
5395 initialize();
5396
5397 // Testing the Iterator default constructor
5398 {
5399 test_ = "Row-major Iterator default constructor";
5400
5401 BT::Iterator it{};
5402
5403 if( it != BT::Iterator() ) {
5404 std::ostringstream oss;
5405 oss << " Test: " << test_ << "\n"
5406 << " Error: Failed iterator default constructor\n";
5407 throw std::runtime_error( oss.str() );
5408 }
5409 }
5410
5411 // Testing the ConstIterator default constructor
5412 {
5413 test_ = "Row-major ConstIterator default constructor";
5414
5415 BT::ConstIterator it{};
5416
5417 if( it != BT::ConstIterator() ) {
5418 std::ostringstream oss;
5419 oss << " Test: " << test_ << "\n"
5420 << " Error: Failed iterator default constructor\n";
5421 throw std::runtime_error( oss.str() );
5422 }
5423 }
5424
5425 // Testing conversion from Iterator to ConstIterator
5426 {
5427 test_ = "Row-major Iterator/ConstIterator conversion";
5428
5429 BT band0 = blaze::band( mat_, 0L );
5430 BT::ConstIterator it( begin( band0 ) );
5431
5432 if( it == end( band0 ) || *it != -2 ) {
5433 std::ostringstream oss;
5434 oss << " Test: " << test_ << "\n"
5435 << " Error: Failed iterator conversion detected\n";
5436 throw std::runtime_error( oss.str() );
5437 }
5438 }
5439
5440 // Counting the number of elements in 1st lower band via Iterator (end-begin)
5441 {
5442 test_ = "Row-major Iterator subtraction (end-begin)";
5443
5444 BT band1 = blaze::band( mat_, -1L );
5445 const ptrdiff_t number( end( band1 ) - begin( band1 ) );
5446
5447 if( number != 3L ) {
5448 std::ostringstream oss;
5449 oss << " Test: " << test_ << "\n"
5450 << " Error: Invalid number of elements detected\n"
5451 << " Details:\n"
5452 << " Number of elements : " << number << "\n"
5453 << " Expected number of elements: 3\n";
5454 throw std::runtime_error( oss.str() );
5455 }
5456 }
5457
5458 // Counting the number of elements in 1st lower band via Iterator (begin-end)
5459 {
5460 test_ = "Row-major Iterator subtraction (begin-end)";
5461
5462 BT band1 = blaze::band( mat_, -1L );
5463 const ptrdiff_t number( begin( band1 ) - end( band1 ) );
5464
5465 if( number != -3L ) {
5466 std::ostringstream oss;
5467 oss << " Test: " << test_ << "\n"
5468 << " Error: Invalid number of elements detected\n"
5469 << " Details:\n"
5470 << " Number of elements : " << number << "\n"
5471 << " Expected number of elements: -3\n";
5472 throw std::runtime_error( oss.str() );
5473 }
5474 }
5475
5476 // Counting the number of elements on the digaonal via ConstIterator (end-begin)
5477 {
5478 test_ = "Row-major ConstIterator subtraction (end-begin)";
5479
5480 BT band0 = blaze::band( mat_, 0L );
5481 const ptrdiff_t number( cend( band0 ) - cbegin( band0 ) );
5482
5483 if( number != 4L ) {
5484 std::ostringstream oss;
5485 oss << " Test: " << test_ << "\n"
5486 << " Error: Invalid number of elements detected\n"
5487 << " Details:\n"
5488 << " Number of elements : " << number << "\n"
5489 << " Expected number of elements: 4\n";
5490 throw std::runtime_error( oss.str() );
5491 }
5492 }
5493
5494 // Counting the number of elements on the digaonal via ConstIterator (begin-end)
5495 {
5496 test_ = "Row-major ConstIterator subtraction (begin-end)";
5497
5498 BT band0 = blaze::band( mat_, 0L );
5499 const ptrdiff_t number( cbegin( band0 ) - cend( band0 ) );
5500
5501 if( number != -4L ) {
5502 std::ostringstream oss;
5503 oss << " Test: " << test_ << "\n"
5504 << " Error: Invalid number of elements detected\n"
5505 << " Details:\n"
5506 << " Number of elements : " << number << "\n"
5507 << " Expected number of elements: -4\n";
5508 throw std::runtime_error( oss.str() );
5509 }
5510 }
5511
5512 // Testing read-only access via ConstIterator
5513 {
5514 test_ = "Row-major read-only access via ConstIterator";
5515
5516 BT band1 = blaze::band( mat_, 1L );
5517 BT::ConstIterator it ( cbegin( band1 ) );
5518 BT::ConstIterator end( cend( band1 ) );
5519
5520 if( it == end || *it != 0 ) {
5521 std::ostringstream oss;
5522 oss << " Test: " << test_ << "\n"
5523 << " Error: Invalid initial iterator detected\n";
5524 throw std::runtime_error( oss.str() );
5525 }
5526
5527 ++it;
5528
5529 if( it == end || *it != 4 ) {
5530 std::ostringstream oss;
5531 oss << " Test: " << test_ << "\n"
5532 << " Error: Iterator pre-increment failed\n";
5533 throw std::runtime_error( oss.str() );
5534 }
5535
5536 --it;
5537
5538 if( it == end || *it != 0 ) {
5539 std::ostringstream oss;
5540 oss << " Test: " << test_ << "\n"
5541 << " Error: Iterator pre-decrement failed\n";
5542 throw std::runtime_error( oss.str() );
5543 }
5544
5545 it++;
5546
5547 if( it == end || *it != 4 ) {
5548 std::ostringstream oss;
5549 oss << " Test: " << test_ << "\n"
5550 << " Error: Iterator post-increment failed\n";
5551 throw std::runtime_error( oss.str() );
5552 }
5553
5554 it--;
5555
5556 if( it == end || *it != 0 ) {
5557 std::ostringstream oss;
5558 oss << " Test: " << test_ << "\n"
5559 << " Error: Iterator post-decrement failed\n";
5560 throw std::runtime_error( oss.str() );
5561 }
5562
5563 it += 2UL;
5564
5565 if( it == end || *it != 5 ) {
5566 std::ostringstream oss;
5567 oss << " Test: " << test_ << "\n"
5568 << " Error: Iterator addition assignment failed\n";
5569 throw std::runtime_error( oss.str() );
5570 }
5571
5572 it -= 2UL;
5573
5574 if( it == end || *it != 0 ) {
5575 std::ostringstream oss;
5576 oss << " Test: " << test_ << "\n"
5577 << " Error: Iterator subtraction assignment failed\n";
5578 throw std::runtime_error( oss.str() );
5579 }
5580
5581 it = it + 3UL;
5582
5583 if( it == end || *it != -6 ) {
5584 std::ostringstream oss;
5585 oss << " Test: " << test_ << "\n"
5586 << " Error: Iterator/scalar addition failed\n";
5587 throw std::runtime_error( oss.str() );
5588 }
5589
5590 it = it - 3UL;
5591
5592 if( it == end || *it != 0 ) {
5593 std::ostringstream oss;
5594 oss << " Test: " << test_ << "\n"
5595 << " Error: Iterator/scalar subtraction failed\n";
5596 throw std::runtime_error( oss.str() );
5597 }
5598
5599 it = 4UL + it;
5600
5601 if( it != end ) {
5602 std::ostringstream oss;
5603 oss << " Test: " << test_ << "\n"
5604 << " Error: Scalar/iterator addition failed\n";
5605 throw std::runtime_error( oss.str() );
5606 }
5607 }
5608
5609 // Testing assignment via Iterator
5610 {
5611 test_ = "Row-major assignment via Iterator";
5612
5613 BT band0 = blaze::band( mat_, 0L );
5614 int value = 6;
5615
5616 for( BT::Iterator it=begin( band0 ); it!=end( band0 ); ++it ) {
5617 *it = value++;
5618 }
5619
5620 if( band0[0] != 6 || band0[1] != 7 || band0[2] != 8 || band0[3] != 9 ) {
5621 std::ostringstream oss;
5622 oss << " Test: " << test_ << "\n"
5623 << " Error: Assignment via iterator failed\n"
5624 << " Details:\n"
5625 << " Result:\n" << band0 << "\n"
5626 << " Expected result:\n( 6 7 8 9 )\n";
5627 throw std::runtime_error( oss.str() );
5628 }
5629
5630 if( mat_(0,0) != 6 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
5631 mat_(1,0) != 0 || mat_(1,1) != 7 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
5632 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != 8 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
5633 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 9 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
5634 std::ostringstream oss;
5635 oss << " Test: " << test_ << "\n"
5636 << " Error: Assignment via iterator failed\n"
5637 << " Details:\n"
5638 << " Result:\n" << mat_ << "\n"
5639 << " Expected result:\n( 6 0 7 0 0 0 )\n"
5640 "( 0 7 4 -8 0 0 )\n"
5641 "( 0 1 8 5 9 0 )\n"
5642 "( 0 0 0 9 -6 10 )\n";
5643 throw std::runtime_error( oss.str() );
5644 }
5645 }
5646
5647 // Testing addition assignment via Iterator
5648 {
5649 test_ = "Row-major addition assignment via Iterator";
5650
5651 BT band0 = blaze::band( mat_, 0L );
5652 int value = 2;
5653
5654 for( BT::Iterator it=begin( band0 ); it!=end( band0 ); ++it ) {
5655 *it += value++;
5656 }
5657
5658 if( band0[0] != 8 || band0[1] != 10 || band0[2] != 12 || band0[3] != 14 ) {
5659 std::ostringstream oss;
5660 oss << " Test: " << test_ << "\n"
5661 << " Error: Addition assignment via iterator failed\n"
5662 << " Details:\n"
5663 << " Result:\n" << band0 << "\n"
5664 << " Expected result:\n( 8 10 12 14 )\n";
5665 throw std::runtime_error( oss.str() );
5666 }
5667
5668 if( mat_(0,0) != 8 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
5669 mat_(1,0) != 0 || mat_(1,1) != 10 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
5670 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != 12 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
5671 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 14 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
5672 std::ostringstream oss;
5673 oss << " Test: " << test_ << "\n"
5674 << " Error: Assignment via iterator failed\n"
5675 << " Details:\n"
5676 << " Result:\n" << mat_ << "\n"
5677 << " Expected result:\n( 8 0 7 0 0 0 )\n"
5678 "( 0 10 4 -8 0 0 )\n"
5679 "( 0 1 12 5 9 0 )\n"
5680 "( 0 0 0 14 -6 10 )\n";
5681 throw std::runtime_error( oss.str() );
5682 }
5683 }
5684
5685 // Testing subtraction assignment via Iterator
5686 {
5687 test_ = "Row-major subtraction assignment via Iterator";
5688
5689 BT band0 = blaze::band( mat_, 0L );
5690 int value = 2;
5691
5692 for( BT::Iterator it=begin( band0 ); it!=end( band0 ); ++it ) {
5693 *it -= value++;
5694 }
5695
5696 if( band0[0] != 6 || band0[1] != 7 || band0[2] != 8 || band0[3] != 9 ) {
5697 std::ostringstream oss;
5698 oss << " Test: " << test_ << "\n"
5699 << " Error: Subtraction assignment via iterator failed\n"
5700 << " Details:\n"
5701 << " Result:\n" << band0 << "\n"
5702 << " Expected result:\n( 6 7 8 9 )\n";
5703 throw std::runtime_error( oss.str() );
5704 }
5705
5706 if( mat_(0,0) != 6 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
5707 mat_(1,0) != 0 || mat_(1,1) != 7 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
5708 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != 8 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
5709 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 9 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
5710 std::ostringstream oss;
5711 oss << " Test: " << test_ << "\n"
5712 << " Error: Assignment via iterator failed\n"
5713 << " Details:\n"
5714 << " Result:\n" << mat_ << "\n"
5715 << " Expected result:\n( 6 0 7 0 0 0 )\n"
5716 "( 0 7 4 -8 0 0 )\n"
5717 "( 0 1 8 5 9 0 )\n"
5718 "( 0 0 0 9 -6 10 )\n";
5719 throw std::runtime_error( oss.str() );
5720 }
5721 }
5722
5723 // Testing multiplication assignment via Iterator
5724 {
5725 test_ = "Row-major multiplication assignment via Iterator";
5726
5727 BT band0 = blaze::band( mat_, 0L );
5728 int value = 1;
5729
5730 for( BT::Iterator it=begin( band0 ); it!=end( band0 ); ++it ) {
5731 *it *= value++;
5732 }
5733
5734 if( band0[0] != 6 || band0[1] != 14 || band0[2] != 24 || band0[3] != 36 ) {
5735 std::ostringstream oss;
5736 oss << " Test: " << test_ << "\n"
5737 << " Error: Multiplication assignment via iterator failed\n"
5738 << " Details:\n"
5739 << " Result:\n" << band0 << "\n"
5740 << " Expected result:\n( 6 14 24 36 )\n";
5741 throw std::runtime_error( oss.str() );
5742 }
5743
5744 if( mat_(0,0) != 6 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
5745 mat_(1,0) != 0 || mat_(1,1) != 14 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
5746 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != 24 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
5747 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 36 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
5748 std::ostringstream oss;
5749 oss << " Test: " << test_ << "\n"
5750 << " Error: Assignment via iterator failed\n"
5751 << " Details:\n"
5752 << " Result:\n" << mat_ << "\n"
5753 << " Expected result:\n( 6 0 7 0 0 0 )\n"
5754 "( 0 14 4 -8 0 0 )\n"
5755 "( 0 1 24 5 9 0 )\n"
5756 "( 0 0 0 36 -6 10 )\n";
5757 throw std::runtime_error( oss.str() );
5758 }
5759 }
5760
5761 // Testing division assignment via Iterator
5762 {
5763 test_ = "Row-major division assignment via Iterator";
5764
5765 BT band0 = blaze::band( mat_, 0L );
5766
5767 for( BT::Iterator it=begin( band0 ); it!=end( band0 ); ++it ) {
5768 *it /= 2;
5769 }
5770
5771 if( band0[0] != 3 || band0[1] != 7 || band0[2] != 12 || band0[3] != 18 ) {
5772 std::ostringstream oss;
5773 oss << " Test: " << test_ << "\n"
5774 << " Error: Division assignment via iterator failed\n"
5775 << " Details:\n"
5776 << " Result:\n" << band0 << "\n"
5777 << " Expected result:\n( 3 7 12 18 )\n";
5778 throw std::runtime_error( oss.str() );
5779 }
5780
5781 if( mat_(0,0) != 3 || mat_(0,1) != 0 || mat_(0,2) != 7 || mat_(0,3) != 0 || mat_(0,4) != 0 || mat_(0,5) != 0 ||
5782 mat_(1,0) != 0 || mat_(1,1) != 7 || mat_(1,2) != 4 || mat_(1,3) != -8 || mat_(1,4) != 0 || mat_(1,5) != 0 ||
5783 mat_(2,0) != 0 || mat_(2,1) != 1 || mat_(2,2) != 12 || mat_(2,3) != 5 || mat_(2,4) != 9 || mat_(2,5) != 0 ||
5784 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 0 || mat_(3,3) != 18 || mat_(3,4) != -6 || mat_(3,5) != 10 ) {
5785 std::ostringstream oss;
5786 oss << " Test: " << test_ << "\n"
5787 << " Error: Assignment via iterator failed\n"
5788 << " Details:\n"
5789 << " Result:\n" << mat_ << "\n"
5790 << " Expected result:\n( 3 0 7 0 0 0 )\n"
5791 "( 0 7 4 -8 0 0 )\n"
5792 "( 0 1 12 5 9 0 )\n"
5793 "( 0 0 0 18 -6 10 )\n";
5794 throw std::runtime_error( oss.str() );
5795 }
5796 }
5797 }
5798
5799
5800 //=====================================================================================
5801 // Column-major matrix tests
5802 //=====================================================================================
5803
5804 {
5805 initialize();
5806
5807 // Testing the Iterator default constructor
5808 {
5809 test_ = "Column-major Iterator default constructor";
5810
5811 OBT::Iterator it{};
5812
5813 if( it != OBT::Iterator() ) {
5814 std::ostringstream oss;
5815 oss << " Test: " << test_ << "\n"
5816 << " Error: Failed iterator default constructor\n";
5817 throw std::runtime_error( oss.str() );
5818 }
5819 }
5820
5821 // Testing the ConstIterator default constructor
5822 {
5823 test_ = "Column-major ConstIterator default constructor";
5824
5825 OBT::ConstIterator it{};
5826
5827 if( it != OBT::ConstIterator() ) {
5828 std::ostringstream oss;
5829 oss << " Test: " << test_ << "\n"
5830 << " Error: Failed iterator default constructor\n";
5831 throw std::runtime_error( oss.str() );
5832 }
5833 }
5834
5835 // Testing conversion from Iterator to ConstIterator
5836 {
5837 test_ = "Column-major Iterator/ConstIterator conversion";
5838
5839 OBT band0 = blaze::band( tmat_, 0L );
5840 OBT::ConstIterator it( begin( band0 ) );
5841
5842 if( it == end( band0 ) || *it != -2 ) {
5843 std::ostringstream oss;
5844 oss << " Test: " << test_ << "\n"
5845 << " Error: Failed iterator conversion detected\n";
5846 throw std::runtime_error( oss.str() );
5847 }
5848 }
5849
5850 // Counting the number of elements in 1st upper band via Iterator (end-begin)
5851 {
5852 test_ = "Column-major Iterator subtraction (end-begin)";
5853
5854 OBT band1 = blaze::band( tmat_, 1L );
5855 const ptrdiff_t number( end( band1 ) - begin( band1 ) );
5856
5857 if( number != 3L ) {
5858 std::ostringstream oss;
5859 oss << " Test: " << test_ << "\n"
5860 << " Error: Invalid number of elements detected\n"
5861 << " Details:\n"
5862 << " Number of elements : " << number << "\n"
5863 << " Expected number of elements: 3\n";
5864 throw std::runtime_error( oss.str() );
5865 }
5866 }
5867
5868 // Counting the number of elements in 1st upper band via Iterator (begin-end)
5869 {
5870 test_ = "Column-major Iterator subtraction (begin-end)";
5871
5872 OBT band1 = blaze::band( tmat_, 1L );
5873 const ptrdiff_t number( begin( band1 ) - end( band1 ) );
5874
5875 if( number != -3L ) {
5876 std::ostringstream oss;
5877 oss << " Test: " << test_ << "\n"
5878 << " Error: Invalid number of elements detected\n"
5879 << " Details:\n"
5880 << " Number of elements : " << number << "\n"
5881 << " Expected number of elements: -3\n";
5882 throw std::runtime_error( oss.str() );
5883 }
5884 }
5885
5886 // Counting the number of elements on the diagonal via ConstIterator (end-begin)
5887 {
5888 test_ = "Column-major ConstIterator subtraction (end-begin)";
5889
5890 OBT band0 = blaze::band( tmat_, 0L );
5891 const ptrdiff_t number( cend( band0 ) - cbegin( band0 ) );
5892
5893 if( number != 4L ) {
5894 std::ostringstream oss;
5895 oss << " Test: " << test_ << "\n"
5896 << " Error: Invalid number of elements detected\n"
5897 << " Details:\n"
5898 << " Number of elements : " << number << "\n"
5899 << " Expected number of elements: 4\n";
5900 throw std::runtime_error( oss.str() );
5901 }
5902 }
5903
5904 // Counting the number of elements on the diagonal via ConstIterator (begin-end)
5905 {
5906 test_ = "Column-major ConstIterator subtraction (begin-end)";
5907
5908 OBT band0 = blaze::band( tmat_, 0L );
5909 const ptrdiff_t number( cbegin( band0 ) - cend( band0 ) );
5910
5911 if( number != -4L ) {
5912 std::ostringstream oss;
5913 oss << " Test: " << test_ << "\n"
5914 << " Error: Invalid number of elements detected\n"
5915 << " Details:\n"
5916 << " Number of elements : " << number << "\n"
5917 << " Expected number of elements: -4\n";
5918 throw std::runtime_error( oss.str() );
5919 }
5920 }
5921
5922 // Testing read-only access via ConstIterator
5923 {
5924 test_ = "Column-major read-only access via ConstIterator";
5925
5926 OBT band1 = blaze::band( tmat_, -1L );
5927 OBT::ConstIterator it ( cbegin( band1 ) );
5928 OBT::ConstIterator end( cend( band1 ) );
5929
5930 if( it == end || *it != 0 ) {
5931 std::ostringstream oss;
5932 oss << " Test: " << test_ << "\n"
5933 << " Error: Invalid initial iterator detected\n";
5934 throw std::runtime_error( oss.str() );
5935 }
5936
5937 ++it;
5938
5939 if( it == end || *it != 4 ) {
5940 std::ostringstream oss;
5941 oss << " Test: " << test_ << "\n"
5942 << " Error: Iterator pre-increment failed\n";
5943 throw std::runtime_error( oss.str() );
5944 }
5945
5946 --it;
5947
5948 if( it == end || *it != 0 ) {
5949 std::ostringstream oss;
5950 oss << " Test: " << test_ << "\n"
5951 << " Error: Iterator pre-decrement failed\n";
5952 throw std::runtime_error( oss.str() );
5953 }
5954
5955 it++;
5956
5957 if( it == end || *it != 4 ) {
5958 std::ostringstream oss;
5959 oss << " Test: " << test_ << "\n"
5960 << " Error: Iterator post-increment failed\n";
5961 throw std::runtime_error( oss.str() );
5962 }
5963
5964 it--;
5965
5966 if( it == end || *it != 0 ) {
5967 std::ostringstream oss;
5968 oss << " Test: " << test_ << "\n"
5969 << " Error: Iterator post-decrement failed\n";
5970 throw std::runtime_error( oss.str() );
5971 }
5972
5973 it += 2UL;
5974
5975 if( it == end || *it != 5 ) {
5976 std::ostringstream oss;
5977 oss << " Test: " << test_ << "\n"
5978 << " Error: Iterator addition assignment failed\n";
5979 throw std::runtime_error( oss.str() );
5980 }
5981
5982 it -= 2UL;
5983
5984 if( it == end || *it != 0 ) {
5985 std::ostringstream oss;
5986 oss << " Test: " << test_ << "\n"
5987 << " Error: Iterator subtraction assignment failed\n";
5988 throw std::runtime_error( oss.str() );
5989 }
5990
5991 it = it + 3UL;
5992
5993 if( it == end || *it != -6 ) {
5994 std::ostringstream oss;
5995 oss << " Test: " << test_ << "\n"
5996 << " Error: Iterator/scalar addition failed\n";
5997 throw std::runtime_error( oss.str() );
5998 }
5999
6000 it = it - 3UL;
6001
6002 if( it == end || *it != 0 ) {
6003 std::ostringstream oss;
6004 oss << " Test: " << test_ << "\n"
6005 << " Error: Iterator/scalar subtraction failed\n";
6006 throw std::runtime_error( oss.str() );
6007 }
6008
6009 it = 4UL + it;
6010
6011 if( it != end ) {
6012 std::ostringstream oss;
6013 oss << " Test: " << test_ << "\n"
6014 << " Error: Scalar/iterator addition failed\n";
6015 throw std::runtime_error( oss.str() );
6016 }
6017 }
6018
6019 // Testing assignment via Iterator
6020 {
6021 test_ = "Column-major assignment via Iterator";
6022
6023 OBT band0 = blaze::band( tmat_, 0L );
6024 int value = 6;
6025
6026 for( OBT::Iterator it=begin( band0 ); it!=end( band0 ); ++it ) {
6027 *it = value++;
6028 }
6029
6030 if( band0[0] != 6 || band0[1] != 7 || band0[2] != 8 || band0[3] != 9 ) {
6031 std::ostringstream oss;
6032 oss << " Test: " << test_ << "\n"
6033 << " Error: Assignment via iterator failed\n"
6034 << " Details:\n"
6035 << " Result:\n" << band0 << "\n"
6036 << " Expected result:\n( 6 7 8 9 )\n";
6037 throw std::runtime_error( oss.str() );
6038 }
6039
6040 if( tmat_(0,0) != 6 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
6041 tmat_(1,0) != 0 || tmat_(1,1) != 7 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
6042 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != 8 || tmat_(2,3) != 0 ||
6043 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 9 ||
6044 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
6045 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
6046 std::ostringstream oss;
6047 oss << " Test: " << test_ << "\n"
6048 << " Error: Assignment via iterator failed\n"
6049 << " Details:\n"
6050 << " Result:\n" << tmat_ << "\n"
6051 << " Expected result:\n( 6 0 0 0 )\n"
6052 "( 0 7 1 0 )\n"
6053 "( 7 4 8 0 )\n"
6054 "( 0 -8 5 9 )\n"
6055 "( 0 0 9 -6 )\n"
6056 "( 0 0 0 10 )\n";
6057 throw std::runtime_error( oss.str() );
6058 }
6059 }
6060
6061 // Testing addition assignment via Iterator
6062 {
6063 test_ = "Column-major addition assignment via Iterator";
6064
6065 OBT band0 = blaze::band( tmat_, 0L );
6066 int value = 2;
6067
6068 for( OBT::Iterator it=begin( band0 ); it!=end( band0 ); ++it ) {
6069 *it += value++;
6070 }
6071
6072 if( band0[0] != 8 || band0[1] != 10 || band0[2] != 12 || band0[3] != 14 ) {
6073 std::ostringstream oss;
6074 oss << " Test: " << test_ << "\n"
6075 << " Error: Addition assignment via iterator failed\n"
6076 << " Details:\n"
6077 << " Result:\n" << band0 << "\n"
6078 << " Expected result:\n( 8 10 12 14 )\n";
6079 throw std::runtime_error( oss.str() );
6080 }
6081
6082 if( tmat_(0,0) != 8 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
6083 tmat_(1,0) != 0 || tmat_(1,1) != 10 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
6084 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != 12 || tmat_(2,3) != 0 ||
6085 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 14 ||
6086 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
6087 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
6088 std::ostringstream oss;
6089 oss << " Test: " << test_ << "\n"
6090 << " Error: Assignment via iterator failed\n"
6091 << " Details:\n"
6092 << " Result:\n" << tmat_ << "\n"
6093 << " Expected result:\n( 8 0 0 0 )\n"
6094 "( 0 10 1 0 )\n"
6095 "( 7 4 12 0 )\n"
6096 "( 0 -8 5 14 )\n"
6097 "( 0 0 9 -6 )\n"
6098 "( 0 0 0 10 )\n";
6099 throw std::runtime_error( oss.str() );
6100 }
6101 }
6102
6103 // Testing subtraction assignment via Iterator
6104 {
6105 test_ = "Column-major subtraction assignment via Iterator";
6106
6107 OBT band0 = blaze::band( tmat_, 0L );
6108 int value = 2;
6109
6110 for( OBT::Iterator it=begin( band0 ); it!=end( band0 ); ++it ) {
6111 *it -= value++;
6112 }
6113
6114 if( band0[0] != 6 || band0[1] != 7 || band0[2] != 8 || band0[3] != 9 ) {
6115 std::ostringstream oss;
6116 oss << " Test: " << test_ << "\n"
6117 << " Error: Subtraction assignment via iterator failed\n"
6118 << " Details:\n"
6119 << " Result:\n" << band0 << "\n"
6120 << " Expected result:\n( 6 7 8 9 )\n";
6121 throw std::runtime_error( oss.str() );
6122 }
6123
6124 if( tmat_(0,0) != 6 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
6125 tmat_(1,0) != 0 || tmat_(1,1) != 7 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
6126 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != 8 || tmat_(2,3) != 0 ||
6127 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 9 ||
6128 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
6129 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
6130 std::ostringstream oss;
6131 oss << " Test: " << test_ << "\n"
6132 << " Error: Assignment via iterator failed\n"
6133 << " Details:\n"
6134 << " Result:\n" << tmat_ << "\n"
6135 << " Expected result:\n( 6 0 0 0 )\n"
6136 "( 0 7 1 0 )\n"
6137 "( 7 4 8 0 )\n"
6138 "( 0 -8 5 9 )\n"
6139 "( 0 0 9 -6 )\n"
6140 "( 0 0 0 10 )\n";
6141 throw std::runtime_error( oss.str() );
6142 }
6143 }
6144
6145 // Testing multiplication assignment via Iterator
6146 {
6147 test_ = "Column-major multiplication assignment via Iterator";
6148
6149 OBT band0 = blaze::band( tmat_, 0L );
6150 int value = 1;
6151
6152 for( OBT::Iterator it=begin( band0 ); it!=end( band0 ); ++it ) {
6153 *it *= value++;
6154 }
6155
6156 if( band0[0] != 6 || band0[1] != 14 || band0[2] != 24 || band0[3] != 36 ) {
6157 std::ostringstream oss;
6158 oss << " Test: " << test_ << "\n"
6159 << " Error: Multiplication assignment via iterator failed\n"
6160 << " Details:\n"
6161 << " Result:\n" << band0 << "\n"
6162 << " Expected result:\n( 6 14 24 36 )\n";
6163 throw std::runtime_error( oss.str() );
6164 }
6165
6166 if( tmat_(0,0) != 6 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
6167 tmat_(1,0) != 0 || tmat_(1,1) != 14 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
6168 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != 24 || tmat_(2,3) != 0 ||
6169 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 36 ||
6170 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
6171 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
6172 std::ostringstream oss;
6173 oss << " Test: " << test_ << "\n"
6174 << " Error: Assignment via iterator failed\n"
6175 << " Details:\n"
6176 << " Result:\n" << tmat_ << "\n"
6177 << " Expected result:\n( 6 0 0 0 )\n"
6178 "( 0 14 1 0 )\n"
6179 "( 7 4 24 0 )\n"
6180 "( 0 -8 5 36 )\n"
6181 "( 0 0 9 -6 )\n"
6182 "( 0 0 0 10 )\n";
6183 throw std::runtime_error( oss.str() );
6184 }
6185 }
6186
6187 // Testing division assignment via Iterator
6188 {
6189 test_ = "Column-major division assignment via Iterator";
6190
6191 OBT band0 = blaze::band( tmat_, 0L );
6192
6193 for( OBT::Iterator it=begin( band0 ); it!=end( band0 ); ++it ) {
6194 *it /= 2;
6195 }
6196
6197 if( band0[0] != 3 || band0[1] != 7 || band0[2] != 12 || band0[3] != 18 ) {
6198 std::ostringstream oss;
6199 oss << " Test: " << test_ << "\n"
6200 << " Error: Division assignment via iterator failed\n"
6201 << " Details:\n"
6202 << " Result:\n" << band0 << "\n"
6203 << " Expected result:\n( 3 7 12 18 )\n";
6204 throw std::runtime_error( oss.str() );
6205 }
6206
6207 if( tmat_(0,0) != 3 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 ||
6208 tmat_(1,0) != 0 || tmat_(1,1) != 7 || tmat_(1,2) != 1 || tmat_(1,3) != 0 ||
6209 tmat_(2,0) != 7 || tmat_(2,1) != 4 || tmat_(2,2) != 12 || tmat_(2,3) != 0 ||
6210 tmat_(3,0) != 0 || tmat_(3,1) != -8 || tmat_(3,2) != 5 || tmat_(3,3) != 18 ||
6211 tmat_(4,0) != 0 || tmat_(4,1) != 0 || tmat_(4,2) != 9 || tmat_(4,3) != -6 ||
6212 tmat_(5,0) != 0 || tmat_(5,1) != 0 || tmat_(5,2) != 0 || tmat_(5,3) != 10 ) {
6213 std::ostringstream oss;
6214 oss << " Test: " << test_ << "\n"
6215 << " Error: Assignment via iterator failed\n"
6216 << " Details:\n"
6217 << " Result:\n" << tmat_ << "\n"
6218 << " Expected result:\n( 3 0 0 0 )\n"
6219 "( 0 7 1 0 )\n"
6220 "( 7 4 12 0 )\n"
6221 "( 0 -8 5 18 )\n"
6222 "( 0 0 9 -6 )\n"
6223 "( 0 0 0 10 )\n";
6224 throw std::runtime_error( oss.str() );
6225 }
6226 }
6227 }
6228 }
6229 //*************************************************************************************************
6230
6231
6232 //*************************************************************************************************
6233 /*!\brief Test of the \c nonZeros() member function of the Band specialization.
6234 //
6235 // \return void
6236 // \exception std::runtime_error Error detected.
6237 //
6238 // This function performs a test of the \c nonZeros() member function of the Band specialization.
6239 // In case an error is detected, a \a std::runtime_error exception is thrown.
6240 */
testNonZeros()6241 void DenseTest::testNonZeros()
6242 {
6243 //=====================================================================================
6244 // Row-major matrix tests
6245 //=====================================================================================
6246
6247 {
6248 test_ = "Row-major Band::nonZeros()";
6249
6250 initialize();
6251
6252 // Initialization check
6253 BT band1 = blaze::band( mat_, 1L );
6254
6255 checkSize ( band1, 4UL );
6256 checkCapacity( band1, 4UL );
6257 checkNonZeros( band1, 3UL );
6258
6259 if( band1[0] != 0 || band1[1] != 4 || band1[2] != 5 || band1[3] != -6 ) {
6260 std::ostringstream oss;
6261 oss << " Test: " << test_ << "\n"
6262 << " Error: Initialization failed\n"
6263 << " Details:\n"
6264 << " Result:\n" << band1 << "\n"
6265 << " Expected result:\n( 0 4 5 -6 )\n";
6266 throw std::runtime_error( oss.str() );
6267 }
6268
6269 // Changing the number of non-zeros via the dense band
6270 band1[2] = 0;
6271
6272 checkSize ( band1, 4UL );
6273 checkCapacity( band1, 4UL );
6274 checkNonZeros( band1, 2UL );
6275
6276 if( band1[0] != 0 || band1[1] != 4 || band1[2] != 0 || band1[3] != -6 ) {
6277 std::ostringstream oss;
6278 oss << " Test: " << test_ << "\n"
6279 << " Error: Subscript operator failed\n"
6280 << " Details:\n"
6281 << " Result:\n" << band1 << "\n"
6282 << " Expected result:\n( 0 4 0 -6 )\n";
6283 throw std::runtime_error( oss.str() );
6284 }
6285
6286 // Changing the number of non-zeros via the dense matrix
6287 mat_(0,1) = 5;
6288
6289 checkSize ( band1, 4UL );
6290 checkCapacity( band1, 4UL );
6291 checkNonZeros( band1, 3UL );
6292
6293 if( band1[0] != 5 || band1[1] != 4 || band1[2] != 0 || band1[3] != -6 ) {
6294 std::ostringstream oss;
6295 oss << " Test: " << test_ << "\n"
6296 << " Error: Function call operator failed\n"
6297 << " Details:\n"
6298 << " Result:\n" << band1 << "\n"
6299 << " Expected result:\n( 5 4 0 -6 )\n";
6300 throw std::runtime_error( oss.str() );
6301 }
6302 }
6303
6304
6305 //=====================================================================================
6306 // Column-major matrix tests
6307 //=====================================================================================
6308
6309 {
6310 test_ = "Column-major Band::nonZeros()";
6311
6312 initialize();
6313
6314 // Initialization check
6315 OBT band1 = blaze::band( tmat_, -1L );
6316
6317 checkSize ( band1, 4UL );
6318 checkCapacity( band1, 4UL );
6319 checkNonZeros( band1, 3UL );
6320
6321 if( band1[0] != 0 || band1[1] != 4 || band1[2] != 5 || band1[3] != -6 ) {
6322 std::ostringstream oss;
6323 oss << " Test: " << test_ << "\n"
6324 << " Error: Initialization failed\n"
6325 << " Details:\n"
6326 << " Result:\n" << band1 << "\n"
6327 << " Expected result:\n( 0 4 5 -6 )\n";
6328 throw std::runtime_error( oss.str() );
6329 }
6330
6331 // Changing the number of non-zeros via the dense band
6332 band1[2] = 0;
6333
6334 checkSize ( band1, 4UL );
6335 checkCapacity( band1, 4UL );
6336 checkNonZeros( band1, 2UL );
6337
6338 if( band1[0] != 0 || band1[1] != 4 || band1[2] != 0 || band1[3] != -6 ) {
6339 std::ostringstream oss;
6340 oss << " Test: " << test_ << "\n"
6341 << " Error: Subscript operator failed\n"
6342 << " Details:\n"
6343 << " Result:\n" << band1 << "\n"
6344 << " Expected result:\n( 0 4 0 -6 )\n";
6345 throw std::runtime_error( oss.str() );
6346 }
6347
6348 // Changing the number of non-zeros via the dense matrix
6349 tmat_(1,0) = 5;
6350
6351 checkSize ( band1, 4UL );
6352 checkCapacity( band1, 4UL );
6353 checkNonZeros( band1, 3UL );
6354
6355 if( band1[0] != 5 || band1[1] != 4 || band1[2] != 0 || band1[3] != -6 ) {
6356 std::ostringstream oss;
6357 oss << " Test: " << test_ << "\n"
6358 << " Error: Function call operator failed\n"
6359 << " Details:\n"
6360 << " Result:\n" << band1 << "\n"
6361 << " Expected result:\n( 5 4 0 -6 )\n";
6362 throw std::runtime_error( oss.str() );
6363 }
6364 }
6365 }
6366 //*************************************************************************************************
6367
6368
6369 //*************************************************************************************************
6370 /*!\brief Test of the \c reset() member function of the Band specialization.
6371 //
6372 // \return void
6373 // \exception std::runtime_error Error detected.
6374 //
6375 // This function performs a test of the \c reset() member function of the Band specialization.
6376 // In case an error is detected, a \a std::runtime_error exception is thrown.
6377 */
testReset()6378 void DenseTest::testReset()
6379 {
6380 using blaze::reset;
6381
6382
6383 //=====================================================================================
6384 // Row-major matrix tests
6385 //=====================================================================================
6386
6387 {
6388 test_ = "Row-major Band::reset()";
6389
6390 // Resetting a single element in the 1st upper band
6391 {
6392 initialize();
6393
6394 BT band1 = blaze::band( mat_, 1L );
6395 reset( band1[1] );
6396
6397 checkSize ( band1, 4UL );
6398 checkCapacity( band1, 4UL );
6399 checkNonZeros( band1, 2UL );
6400 checkRows ( mat_ , 4UL );
6401 checkColumns ( mat_ , 6UL );
6402 checkNonZeros( mat_ , 9UL );
6403
6404 if( band1[0] != 0 || band1[1] != 0 || band1[2] != 5 || band1[3] != -6 ) {
6405 std::ostringstream oss;
6406 oss << " Test: " << test_ << "\n"
6407 << " Error: Reset operation failed\n"
6408 << " Details:\n"
6409 << " Result:\n" << band1 << "\n"
6410 << " Expected result:\n( 0 0 5 -6 )\n";
6411 throw std::runtime_error( oss.str() );
6412 }
6413 }
6414
6415 // Resetting the 1st upper band (lvalue)
6416 {
6417 initialize();
6418
6419 BT band1 = blaze::band( mat_, 1L );
6420 reset( band1 );
6421
6422 checkSize ( band1, 4UL );
6423 checkCapacity( band1, 4UL );
6424 checkNonZeros( band1, 0UL );
6425 checkRows ( mat_ , 4UL );
6426 checkColumns ( mat_ , 6UL );
6427 checkNonZeros( mat_ , 7UL );
6428
6429 if( band1[0] != 0 || band1[1] != 0 || band1[2] != 0 || band1[3] != 0 ) {
6430 std::ostringstream oss;
6431 oss << " Test: " << test_ << "\n"
6432 << " Error: Reset operation of 1st upper band failed\n"
6433 << " Details:\n"
6434 << " Result:\n" << band1 << "\n"
6435 << " Expected result:\n( 0 0 0 0 )\n";
6436 throw std::runtime_error( oss.str() );
6437 }
6438 }
6439
6440 // Resetting the 2nd upper band (rvalue)
6441 {
6442 initialize();
6443
6444 reset( blaze::band( mat_, 2L ) );
6445
6446 checkRows ( mat_, 4UL );
6447 checkColumns ( mat_, 6UL );
6448 checkNonZeros( mat_, 6UL );
6449
6450 if( mat_(0,2) != 0 || mat_(1,3) != 0 || mat_(2,4) != 0 || mat_(3,5) != 0 ) {
6451 std::ostringstream oss;
6452 oss << " Test: " << test_ << "\n"
6453 << " Error: Reset operation of 2nd upper band failed\n"
6454 << " Details:\n"
6455 << " Result:\n" << mat_ << "\n"
6456 << " Expected result:\n( -2 0 0 0 0 0 )\n"
6457 "( 0 0 4 0 0 0 )\n"
6458 "( 0 1 -3 5 0 0 )\n"
6459 "( 0 0 0 0 -6 0 )\n";
6460 throw std::runtime_error( oss.str() );
6461 }
6462 }
6463 }
6464
6465
6466 //=====================================================================================
6467 // Column-major matrix tests
6468 //=====================================================================================
6469
6470 {
6471 test_ = "Column-major Band::reset()";
6472
6473 // Resetting a single element in the 1st lower band
6474 {
6475 initialize();
6476
6477 OBT band1 = blaze::band( tmat_, -1L );
6478 reset( band1[1] );
6479
6480 checkSize ( band1, 4UL );
6481 checkCapacity( band1, 4UL );
6482 checkNonZeros( band1, 2UL );
6483 checkRows ( tmat_, 6UL );
6484 checkColumns ( tmat_, 4UL );
6485 checkNonZeros( tmat_, 9UL );
6486
6487 if( band1[0] != 0 || band1[1] != 0 || band1[2] != 5 || band1[3] != -6 ) {
6488 std::ostringstream oss;
6489 oss << " Test: " << test_ << "\n"
6490 << " Error: Reset operation failed\n"
6491 << " Details:\n"
6492 << " Result:\n" << band1 << "\n"
6493 << " Expected result:\n( 0 0 5 -6 )\n";
6494 throw std::runtime_error( oss.str() );
6495 }
6496 }
6497
6498 // Resetting the 1st lower band (lvalue)
6499 {
6500 initialize();
6501
6502 OBT band1 = blaze::band( tmat_, -1L );
6503 reset( band1 );
6504
6505 checkSize ( band1, 4UL );
6506 checkCapacity( band1, 4UL );
6507 checkNonZeros( band1, 0UL );
6508 checkRows ( tmat_, 6UL );
6509 checkColumns ( tmat_, 4UL );
6510 checkNonZeros( tmat_, 7UL );
6511
6512 if( band1[0] != 0 || band1[1] != 0 || band1[2] != 0 || band1[3] != 0 ) {
6513 std::ostringstream oss;
6514 oss << " Test: " << test_ << "\n"
6515 << " Error: Reset operation of 1st lower band failed\n"
6516 << " Details:\n"
6517 << " Result:\n" << band1 << "\n"
6518 << " Expected result:\n( 0 0 0 0 )\n";
6519 throw std::runtime_error( oss.str() );
6520 }
6521 }
6522
6523 // Resetting the 2nd lower band (rvalue)
6524 {
6525 initialize();
6526
6527 reset( blaze::band( tmat_, -2L ) );
6528
6529 checkRows ( tmat_, 6UL );
6530 checkColumns ( tmat_, 4UL );
6531 checkNonZeros( tmat_, 6UL );
6532
6533 if( tmat_(2,0) != 0 || tmat_(3,1) != 0 || tmat_(4,2) != 0 || tmat_(5,3) != 0 ) {
6534 std::ostringstream oss;
6535 oss << " Test: " << test_ << "\n"
6536 << " Error: Reset operation of 2nd lower band failed\n"
6537 << " Details:\n"
6538 << " Result:\n" << tmat_ << "\n"
6539 << " Expected result:\n( -2 0 0 0 )\n"
6540 "( 0 0 1 0 )\n"
6541 "( 0 4 -3 0 )\n"
6542 "( 0 0 5 0 )\n"
6543 "( 0 0 0 -6 )\n"
6544 "( 0 0 0 0 )\n";
6545 throw std::runtime_error( oss.str() );
6546 }
6547 }
6548 }
6549 }
6550 //*************************************************************************************************
6551
6552
6553 //*************************************************************************************************
6554 /*!\brief Test of the \c clear() function with the Band specialization.
6555 //
6556 // \return void
6557 // \exception std::runtime_error Error detected.
6558 //
6559 // This function performs a test of the \c clear() function with the Band specialization.
6560 // In case an error is detected, a \a std::runtime_error exception is thrown.
6561 */
testClear()6562 void DenseTest::testClear()
6563 {
6564 using blaze::clear;
6565
6566
6567 //=====================================================================================
6568 // Row-major matrix tests
6569 //=====================================================================================
6570
6571 {
6572 test_ = "Row-major clear() function";
6573
6574 // Clearing a single element in the 1st upper band
6575 {
6576 initialize();
6577
6578 BT band1 = blaze::band( mat_, 1L );
6579 clear( band1[1] );
6580
6581 checkSize ( band1, 4UL );
6582 checkCapacity( band1, 4UL );
6583 checkNonZeros( band1, 2UL );
6584 checkRows ( mat_ , 4UL );
6585 checkColumns ( mat_ , 6UL );
6586 checkNonZeros( mat_ , 9UL );
6587
6588 if( band1[0] != 0 || band1[1] != 0 || band1[2] != 5 || band1[3] != -6 ) {
6589 std::ostringstream oss;
6590 oss << " Test: " << test_ << "\n"
6591 << " Error: Clear operation failed\n"
6592 << " Details:\n"
6593 << " Result:\n" << band1 << "\n"
6594 << " Expected result:\n( 0 0 5 -6 )\n";
6595 throw std::runtime_error( oss.str() );
6596 }
6597 }
6598
6599 // Clearing the 1st upper band (lvalue)
6600 {
6601 initialize();
6602
6603 BT band1 = blaze::band( mat_, 1L );
6604 clear( band1 );
6605
6606 checkSize ( band1, 4UL );
6607 checkCapacity( band1, 4UL );
6608 checkNonZeros( band1, 0UL );
6609 checkRows ( mat_ , 4UL );
6610 checkColumns ( mat_ , 6UL );
6611 checkNonZeros( mat_ , 7UL );
6612
6613 if( band1[0] != 0 || band1[1] != 0 || band1[2] != 0 || band1[3] != 0 ) {
6614 std::ostringstream oss;
6615 oss << " Test: " << test_ << "\n"
6616 << " Error: Clear operation of 1st upper band failed\n"
6617 << " Details:\n"
6618 << " Result:\n" << band1 << "\n"
6619 << " Expected result:\n( 0 0 0 0 )\n";
6620 throw std::runtime_error( oss.str() );
6621 }
6622 }
6623
6624 // Clearing the 2nd upper band (rvalue)
6625 {
6626 initialize();
6627
6628 clear( blaze::band( mat_, 2L ) );
6629
6630 checkRows ( mat_, 4UL );
6631 checkColumns ( mat_, 6UL );
6632 checkNonZeros( mat_, 6UL );
6633
6634 if( mat_(0,2) != 0 || mat_(1,3) != 0 || mat_(2,4) != 0 || mat_(3,5) != 0 ) {
6635 std::ostringstream oss;
6636 oss << " Test: " << test_ << "\n"
6637 << " Error: Clear operation of 2nd upper band failed\n"
6638 << " Details:\n"
6639 << " Result:\n" << mat_ << "\n"
6640 << " Expected result:\n( -2 0 0 0 0 0 )\n"
6641 "( 0 0 4 0 0 0 )\n"
6642 "( 0 1 -3 5 0 0 )\n"
6643 "( 0 0 0 0 -6 0 )\n";
6644 throw std::runtime_error( oss.str() );
6645 }
6646 }
6647 }
6648
6649
6650 //=====================================================================================
6651 // Column-major matrix tests
6652 //=====================================================================================
6653
6654 {
6655 test_ = "Column-major clear() function";
6656
6657 // Clearing a single element in the 1st lower band
6658 {
6659 initialize();
6660
6661 OBT band1 = blaze::band( tmat_, -1L );
6662 clear( band1[1] );
6663
6664 checkSize ( band1, 4UL );
6665 checkCapacity( band1, 4UL );
6666 checkNonZeros( band1, 2UL );
6667 checkRows ( tmat_, 6UL );
6668 checkColumns ( tmat_, 4UL );
6669 checkNonZeros( tmat_, 9UL );
6670
6671 if( band1[0] != 0 || band1[1] != 0 || band1[2] != 5 || band1[3] != -6 ) {
6672 std::ostringstream oss;
6673 oss << " Test: " << test_ << "\n"
6674 << " Error: Clear operation failed\n"
6675 << " Details:\n"
6676 << " Result:\n" << band1 << "\n"
6677 << " Expected result:\n( 0 0 5 -6 )\n";
6678 throw std::runtime_error( oss.str() );
6679 }
6680 }
6681
6682 // Clearing the 1st lower band (lvalue)
6683 {
6684 initialize();
6685
6686 OBT band1 = blaze::band( tmat_, -1L );
6687 clear( band1 );
6688
6689 checkSize ( band1, 4UL );
6690 checkCapacity( band1, 4UL );
6691 checkNonZeros( band1, 0UL );
6692 checkRows ( tmat_, 6UL );
6693 checkColumns ( tmat_, 4UL );
6694 checkNonZeros( tmat_, 7UL );
6695
6696 if( band1[0] != 0 || band1[1] != 0 || band1[2] != 0 || band1[3] != 0 ) {
6697 std::ostringstream oss;
6698 oss << " Test: " << test_ << "\n"
6699 << " Error: Clear operation of 1st lower band failed\n"
6700 << " Details:\n"
6701 << " Result:\n" << band1 << "\n"
6702 << " Expected result:\n( 0 0 0 0 )\n";
6703 throw std::runtime_error( oss.str() );
6704 }
6705 }
6706
6707 // Clearing the 2nd lower band (rvalue)
6708 {
6709 initialize();
6710
6711 clear( blaze::band( tmat_, -2L ) );
6712
6713 checkRows ( tmat_, 6UL );
6714 checkColumns ( tmat_, 4UL );
6715 checkNonZeros( tmat_, 6UL );
6716
6717 if( tmat_(2,0) != 0 || tmat_(3,1) != 0 || tmat_(4,2) != 0 || tmat_(5,3) != 0 ) {
6718 std::ostringstream oss;
6719 oss << " Test: " << test_ << "\n"
6720 << " Error: Clear operation of 2nd lower band failed\n"
6721 << " Details:\n"
6722 << " Result:\n" << tmat_ << "\n"
6723 << " Expected result:\n( -2 0 0 0 )\n"
6724 "( 0 0 1 0 )\n"
6725 "( 0 4 -3 0 )\n"
6726 "( 0 0 5 0 )\n"
6727 "( 0 0 0 -6 )\n"
6728 "( 0 0 0 0 )\n";
6729 throw std::runtime_error( oss.str() );
6730 }
6731 }
6732 }
6733 }
6734 //*************************************************************************************************
6735
6736
6737 //*************************************************************************************************
6738 /*!\brief Test of the \c isDefault() function with the Band specialization.
6739 //
6740 // \return void
6741 // \exception std::runtime_error Error detected.
6742 //
6743 // This function performs a test of the \c isDefault() function with the Band specialization.
6744 // In case an error is detected, a \a std::runtime_error exception is thrown.
6745 */
testIsDefault()6746 void DenseTest::testIsDefault()
6747 {
6748 using blaze::isDefault;
6749
6750
6751 //=====================================================================================
6752 // Row-major matrix tests
6753 //=====================================================================================
6754
6755 {
6756 test_ = "Row-major isDefault() function";
6757
6758 initialize();
6759
6760 // isDefault with default band
6761 {
6762 BT band3 = blaze::band( mat_, 3L );
6763
6764 if( isDefault( band3[1] ) != true ) {
6765 std::ostringstream oss;
6766 oss << " Test: " << test_ << "\n"
6767 << " Error: Invalid isDefault evaluation\n"
6768 << " Details:\n"
6769 << " Band element: " << band3[1] << "\n";
6770 throw std::runtime_error( oss.str() );
6771 }
6772
6773 if( isDefault( band3 ) != true ) {
6774 std::ostringstream oss;
6775 oss << " Test: " << test_ << "\n"
6776 << " Error: Invalid isDefault evaluation\n"
6777 << " Details:\n"
6778 << " Band:\n" << band3 << "\n";
6779 throw std::runtime_error( oss.str() );
6780 }
6781 }
6782
6783 // isDefault with non-default band
6784 {
6785 BT band2 = blaze::band( mat_, 2L );
6786
6787 if( isDefault( band2[1] ) != false ) {
6788 std::ostringstream oss;
6789 oss << " Test: " << test_ << "\n"
6790 << " Error: Invalid isDefault evaluation\n"
6791 << " Details:\n"
6792 << " Band element: " << band2[1] << "\n";
6793 throw std::runtime_error( oss.str() );
6794 }
6795
6796 if( isDefault( band2 ) != false ) {
6797 std::ostringstream oss;
6798 oss << " Test: " << test_ << "\n"
6799 << " Error: Invalid isDefault evaluation\n"
6800 << " Details:\n"
6801 << " Band:\n" << band2 << "\n";
6802 throw std::runtime_error( oss.str() );
6803 }
6804 }
6805 }
6806
6807
6808 //=====================================================================================
6809 // Column-major matrix tests
6810 //=====================================================================================
6811
6812 {
6813 test_ = "Column-major isDefault() function";
6814
6815 initialize();
6816
6817 // isDefault with default band
6818 {
6819 OBT band3 = blaze::band( tmat_, -3L );
6820
6821 if( isDefault( band3[1] ) != true ) {
6822 std::ostringstream oss;
6823 oss << " Test: " << test_ << "\n"
6824 << " Error: Invalid isDefault evaluation\n"
6825 << " Details:\n"
6826 << " Band element: " << band3[1] << "\n";
6827 throw std::runtime_error( oss.str() );
6828 }
6829
6830 if( isDefault( band3 ) != true ) {
6831 std::ostringstream oss;
6832 oss << " Test: " << test_ << "\n"
6833 << " Error: Invalid isDefault evaluation\n"
6834 << " Details:\n"
6835 << " Band:\n" << band3 << "\n";
6836 throw std::runtime_error( oss.str() );
6837 }
6838 }
6839
6840 // isDefault with non-default band
6841 {
6842 OBT band2 = blaze::band( tmat_, -2L );
6843
6844 if( isDefault( band2[1] ) != false ) {
6845 std::ostringstream oss;
6846 oss << " Test: " << test_ << "\n"
6847 << " Error: Invalid isDefault evaluation\n"
6848 << " Details:\n"
6849 << " Band element: " << band2[1] << "\n";
6850 throw std::runtime_error( oss.str() );
6851 }
6852
6853 if( isDefault( band2 ) != false ) {
6854 std::ostringstream oss;
6855 oss << " Test: " << test_ << "\n"
6856 << " Error: Invalid isDefault evaluation\n"
6857 << " Details:\n"
6858 << " Band:\n" << band2 << "\n";
6859 throw std::runtime_error( oss.str() );
6860 }
6861 }
6862 }
6863 }
6864 //*************************************************************************************************
6865
6866
6867 //*************************************************************************************************
6868 /*!\brief Test of the \c isSame() function with the Band specialization.
6869 //
6870 // \return void
6871 // \exception std::runtime_error Error detected.
6872 //
6873 // This function performs a test of the \c isSame() function with the Band specialization.
6874 // In case an error is detected, a \a std::runtime_error exception is thrown.
6875 */
testIsSame()6876 void DenseTest::testIsSame()
6877 {
6878 //=====================================================================================
6879 // Row-major matrix tests
6880 //=====================================================================================
6881
6882 {
6883 test_ = "Row-major isSame() function";
6884
6885 // isSame with matching bands
6886 {
6887 BT band1 = blaze::band( mat_, 1L );
6888 BT band2 = blaze::band( mat_, 1L );
6889
6890 if( blaze::isSame( band1, band2 ) == false ) {
6891 std::ostringstream oss;
6892 oss << " Test: " << test_ << "\n"
6893 << " Error: Invalid isSame evaluation\n"
6894 << " Details:\n"
6895 << " First band:\n" << band1 << "\n"
6896 << " Second band:\n" << band2 << "\n";
6897 throw std::runtime_error( oss.str() );
6898 }
6899 }
6900
6901 // isSame with non-matching bands
6902 {
6903 BT band1 = blaze::band( mat_, 0L );
6904 BT band2 = blaze::band( mat_, 1L );
6905
6906 if( blaze::isSame( band1, band2 ) == true ) {
6907 std::ostringstream oss;
6908 oss << " Test: " << test_ << "\n"
6909 << " Error: Invalid isSame evaluation\n"
6910 << " Details:\n"
6911 << " First band:\n" << band1 << "\n"
6912 << " Second band:\n" << band2 << "\n";
6913 throw std::runtime_error( oss.str() );
6914 }
6915 }
6916
6917 // isSame with band and matching subvector
6918 {
6919 BT band1 = blaze::band( mat_, 1L );
6920 auto sv = blaze::subvector( band1, 0UL, 4UL );
6921
6922 if( blaze::isSame( band1, sv ) == false ) {
6923 std::ostringstream oss;
6924 oss << " Test: " << test_ << "\n"
6925 << " Error: Invalid isSame evaluation\n"
6926 << " Details:\n"
6927 << " Dense band:\n" << band1 << "\n"
6928 << " Dense subvector:\n" << sv << "\n";
6929 throw std::runtime_error( oss.str() );
6930 }
6931
6932 if( blaze::isSame( sv, band1 ) == false ) {
6933 std::ostringstream oss;
6934 oss << " Test: " << test_ << "\n"
6935 << " Error: Invalid isSame evaluation\n"
6936 << " Details:\n"
6937 << " Dense band:\n" << band1 << "\n"
6938 << " Dense subvector:\n" << sv << "\n";
6939 throw std::runtime_error( oss.str() );
6940 }
6941 }
6942
6943 // isSame with band and non-matching subvector (different size)
6944 {
6945 BT band1 = blaze::band( mat_, 1L );
6946 auto sv = blaze::subvector( band1, 0UL, 3UL );
6947
6948 if( blaze::isSame( band1, sv ) == true ) {
6949 std::ostringstream oss;
6950 oss << " Test: " << test_ << "\n"
6951 << " Error: Invalid isSame evaluation\n"
6952 << " Details:\n"
6953 << " Dense band:\n" << band1 << "\n"
6954 << " Dense subvector:\n" << sv << "\n";
6955 throw std::runtime_error( oss.str() );
6956 }
6957
6958 if( blaze::isSame( sv, band1 ) == true ) {
6959 std::ostringstream oss;
6960 oss << " Test: " << test_ << "\n"
6961 << " Error: Invalid isSame evaluation\n"
6962 << " Details:\n"
6963 << " Dense band:\n" << band1 << "\n"
6964 << " Dense subvector:\n" << sv << "\n";
6965 throw std::runtime_error( oss.str() );
6966 }
6967 }
6968
6969 // isSame with band and non-matching subvector (different offset)
6970 {
6971 BT band1 = blaze::band( mat_, 1L );
6972 auto sv = blaze::subvector( band1, 1UL, 3UL );
6973
6974 if( blaze::isSame( band1, sv ) == true ) {
6975 std::ostringstream oss;
6976 oss << " Test: " << test_ << "\n"
6977 << " Error: Invalid isSame evaluation\n"
6978 << " Details:\n"
6979 << " Dense band:\n" << band1 << "\n"
6980 << " Dense subvector:\n" << sv << "\n";
6981 throw std::runtime_error( oss.str() );
6982 }
6983
6984 if( blaze::isSame( sv, band1 ) == true ) {
6985 std::ostringstream oss;
6986 oss << " Test: " << test_ << "\n"
6987 << " Error: Invalid isSame evaluation\n"
6988 << " Details:\n"
6989 << " Dense band:\n" << band1 << "\n"
6990 << " Dense subvector:\n" << sv << "\n";
6991 throw std::runtime_error( oss.str() );
6992 }
6993 }
6994
6995 // isSame with matching bands on a common submatrix
6996 {
6997 auto sm = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 4UL );
6998 auto band1 = blaze::band( sm, 1L );
6999 auto band2 = blaze::band( sm, 1L );
7000
7001 if( blaze::isSame( band1, band2 ) == false ) {
7002 std::ostringstream oss;
7003 oss << " Test: " << test_ << "\n"
7004 << " Error: Invalid isSame evaluation\n"
7005 << " Details:\n"
7006 << " First band:\n" << band1 << "\n"
7007 << " Second band:\n" << band2 << "\n";
7008 throw std::runtime_error( oss.str() );
7009 }
7010 }
7011
7012 // isSame with non-matching bands on a common submatrix
7013 {
7014 auto sm = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 4UL );
7015 auto band1 = blaze::band( sm, 0L );
7016 auto band2 = blaze::band( sm, 1L );
7017
7018 if( blaze::isSame( band1, band2 ) == true ) {
7019 std::ostringstream oss;
7020 oss << " Test: " << test_ << "\n"
7021 << " Error: Invalid isSame evaluation\n"
7022 << " Details:\n"
7023 << " First band:\n" << band1 << "\n"
7024 << " Second band:\n" << band2 << "\n";
7025 throw std::runtime_error( oss.str() );
7026 }
7027 }
7028
7029 // isSame with matching rows on matrix and submatrix
7030 {
7031 auto sm = blaze::submatrix( mat_, 0UL, 1UL, 4UL, 4UL );
7032 auto band1 = blaze::band( mat_, 1L );
7033 auto band2 = blaze::band( sm , 0L );
7034
7035 if( blaze::isSame( band1, band2 ) == false ) {
7036 std::ostringstream oss;
7037 oss << " Test: " << test_ << "\n"
7038 << " Error: Invalid isSame evaluation\n"
7039 << " Details:\n"
7040 << " First band:\n" << band1 << "\n"
7041 << " Second band:\n" << band2 << "\n";
7042 throw std::runtime_error( oss.str() );
7043 }
7044
7045 if( blaze::isSame( band2, band1 ) == false ) {
7046 std::ostringstream oss;
7047 oss << " Test: " << test_ << "\n"
7048 << " Error: Invalid isSame evaluation\n"
7049 << " Details:\n"
7050 << " First band:\n" << band1 << "\n"
7051 << " Second band:\n" << band2 << "\n";
7052 throw std::runtime_error( oss.str() );
7053 }
7054 }
7055
7056 // isSame with non-matching rows on matrix and submatrix (different band)
7057 {
7058 auto sm = blaze::submatrix( mat_, 0UL, 1UL, 4UL, 4UL );
7059 auto band1 = blaze::band( mat_, 2L );
7060 auto band2 = blaze::band( sm , 0L );
7061
7062 if( blaze::isSame( band1, band2 ) == true ) {
7063 std::ostringstream oss;
7064 oss << " Test: " << test_ << "\n"
7065 << " Error: Invalid isSame evaluation\n"
7066 << " Details:\n"
7067 << " First band:\n" << band1 << "\n"
7068 << " Second band:\n" << band2 << "\n";
7069 throw std::runtime_error( oss.str() );
7070 }
7071
7072 if( blaze::isSame( band2, band1 ) == true ) {
7073 std::ostringstream oss;
7074 oss << " Test: " << test_ << "\n"
7075 << " Error: Invalid isSame evaluation\n"
7076 << " Details:\n"
7077 << " First band:\n" << band1 << "\n"
7078 << " Second band:\n" << band2 << "\n";
7079 throw std::runtime_error( oss.str() );
7080 }
7081 }
7082
7083 // isSame with non-matching rows on matrix and submatrix (different size)
7084 {
7085 auto sm = blaze::submatrix( mat_, 0UL, 1UL, 3UL, 4UL );
7086 auto band1 = blaze::band( mat_, 1L );
7087 auto band2 = blaze::band( sm , 0L );
7088
7089 if( blaze::isSame( band1, band2 ) == true ) {
7090 std::ostringstream oss;
7091 oss << " Test: " << test_ << "\n"
7092 << " Error: Invalid isSame evaluation\n"
7093 << " Details:\n"
7094 << " First band:\n" << band1 << "\n"
7095 << " Second band:\n" << band2 << "\n";
7096 throw std::runtime_error( oss.str() );
7097 }
7098
7099 if( blaze::isSame( band2, band1 ) == true ) {
7100 std::ostringstream oss;
7101 oss << " Test: " << test_ << "\n"
7102 << " Error: Invalid isSame evaluation\n"
7103 << " Details:\n"
7104 << " First band:\n" << band1 << "\n"
7105 << " Second band:\n" << band2 << "\n";
7106 throw std::runtime_error( oss.str() );
7107 }
7108 }
7109
7110 // isSame with matching rows on two submatrices
7111 {
7112 auto sm1 = blaze::submatrix( mat_, 1UL, 0UL, 3UL, 4UL );
7113 auto sm2 = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 5UL );
7114 auto band1 = blaze::band( sm1, 1L );
7115 auto band2 = blaze::band( sm2, 0L );
7116
7117 if( blaze::isSame( band1, band2 ) == false ) {
7118 std::ostringstream oss;
7119 oss << " Test: " << test_ << "\n"
7120 << " Error: Invalid isSame evaluation\n"
7121 << " Details:\n"
7122 << " First band:\n" << band1 << "\n"
7123 << " Second band:\n" << band2 << "\n";
7124 throw std::runtime_error( oss.str() );
7125 }
7126 }
7127
7128 // isSame with non-matching rows on two submatrices (different band)
7129 {
7130 auto sm1 = blaze::submatrix( mat_, 1UL, 0UL, 3UL, 4UL );
7131 auto sm2 = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 5UL );
7132 auto band1 = blaze::band( sm1, 1L );
7133 auto band2 = blaze::band( sm2, 1L );
7134
7135 if( blaze::isSame( band1, band2 ) == true ) {
7136 std::ostringstream oss;
7137 oss << " Test: " << test_ << "\n"
7138 << " Error: Invalid isSame evaluation\n"
7139 << " Details:\n"
7140 << " First band:\n" << band1 << "\n"
7141 << " Second band:\n" << band2 << "\n";
7142 throw std::runtime_error( oss.str() );
7143 }
7144 }
7145
7146 // isSame with non-matching rows on two submatrices (different size)
7147 {
7148 auto sm1 = blaze::submatrix( mat_, 1UL, 0UL, 3UL, 4UL );
7149 auto sm2 = blaze::submatrix( mat_, 1UL, 1UL, 2UL, 5UL );
7150 auto band1 = blaze::band( sm1, 1L );
7151 auto band2 = blaze::band( sm2, 0L );
7152
7153 if( blaze::isSame( band1, band2 ) == true ) {
7154 std::ostringstream oss;
7155 oss << " Test: " << test_ << "\n"
7156 << " Error: Invalid isSame evaluation\n"
7157 << " Details:\n"
7158 << " First band:\n" << band1 << "\n"
7159 << " Second band:\n" << band2 << "\n";
7160 throw std::runtime_error( oss.str() );
7161 }
7162 }
7163
7164 // isSame with non-matching rows on two submatrices (different offset)
7165 {
7166 auto sm1 = blaze::submatrix( mat_, 0UL, 0UL, 3UL, 4UL );
7167 auto sm2 = blaze::submatrix( mat_, 1UL, 1UL, 2UL, 5UL );
7168 auto band1 = blaze::band( sm1, 0L );
7169 auto band2 = blaze::band( sm2, 0L );
7170
7171 if( blaze::isSame( band1, band2 ) == true ) {
7172 std::ostringstream oss;
7173 oss << " Test: " << test_ << "\n"
7174 << " Error: Invalid isSame evaluation\n"
7175 << " Details:\n"
7176 << " First band:\n" << band1 << "\n"
7177 << " Second band:\n" << band2 << "\n";
7178 throw std::runtime_error( oss.str() );
7179 }
7180 }
7181
7182 // isSame with matching band subvectors on submatrices
7183 {
7184 auto sm = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 4UL );
7185 auto band1 = blaze::band( sm, 1L );
7186 auto sv1 = blaze::subvector( band1, 0UL, 2UL );
7187 auto sv2 = blaze::subvector( band1, 0UL, 2UL );
7188
7189 if( blaze::isSame( sv1, sv2 ) == false ) {
7190 std::ostringstream oss;
7191 oss << " Test: " << test_ << "\n"
7192 << " Error: Invalid isSame evaluation\n"
7193 << " Details:\n"
7194 << " First subvector:\n" << sv1 << "\n"
7195 << " Second subvector:\n" << sv2 << "\n";
7196 throw std::runtime_error( oss.str() );
7197 }
7198 }
7199
7200 // isSame with non-matching band subvectors on submatrices (different size)
7201 {
7202 auto sm = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 4UL );
7203 auto band1 = blaze::band( sm, 1L );
7204 auto sv1 = blaze::subvector( band1, 0UL, 3UL );
7205 auto sv2 = blaze::subvector( band1, 0UL, 2UL );
7206
7207 if( blaze::isSame( sv1, sv2 ) == true ) {
7208 std::ostringstream oss;
7209 oss << " Test: " << test_ << "\n"
7210 << " Error: Invalid isSame evaluation\n"
7211 << " Details:\n"
7212 << " First subvector:\n" << sv1 << "\n"
7213 << " Second subvector:\n" << sv2 << "\n";
7214 throw std::runtime_error( oss.str() );
7215 }
7216 }
7217
7218 // isSame with non-matching band subvectors on submatrices (different offset)
7219 {
7220 auto sm = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 4UL );
7221 auto band1 = blaze::band( sm, 1L );
7222 auto sv1 = blaze::subvector( band1, 0UL, 2UL );
7223 auto sv2 = blaze::subvector( band1, 1UL, 2UL );
7224
7225 if( blaze::isSame( sv1, sv2 ) == true ) {
7226 std::ostringstream oss;
7227 oss << " Test: " << test_ << "\n"
7228 << " Error: Invalid isSame evaluation\n"
7229 << " Details:\n"
7230 << " First subvector:\n" << sv1 << "\n"
7231 << " Second subvector:\n" << sv2 << "\n";
7232 throw std::runtime_error( oss.str() );
7233 }
7234 }
7235
7236 // isSame with matching row subvectors on two submatrices
7237 {
7238 auto sm1 = blaze::submatrix( mat_, 1UL, 0UL, 3UL, 4UL );
7239 auto sm2 = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 5UL );
7240 auto band1 = blaze::band( sm1, 1L );
7241 auto band2 = blaze::band( sm2, 0L );
7242 auto sv1 = blaze::subvector( band1, 0UL, 2UL );
7243 auto sv2 = blaze::subvector( band2, 0UL, 2UL );
7244
7245 if( blaze::isSame( sv1, sv2 ) == false ) {
7246 std::ostringstream oss;
7247 oss << " Test: " << test_ << "\n"
7248 << " Error: Invalid isSame evaluation\n"
7249 << " Details:\n"
7250 << " First subvector:\n" << sv1 << "\n"
7251 << " Second subvector:\n" << sv2 << "\n";
7252 throw std::runtime_error( oss.str() );
7253 }
7254 }
7255
7256 // isSame with non-matching row subvectors on two submatrices (different size)
7257 {
7258 auto sm1 = blaze::submatrix( mat_, 1UL, 0UL, 3UL, 4UL );
7259 auto sm2 = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 5UL );
7260 auto band1 = blaze::band( sm1, 1L );
7261 auto band2 = blaze::band( sm2, 0L );
7262 auto sv1 = blaze::subvector( band1, 0UL, 3UL );
7263 auto sv2 = blaze::subvector( band2, 0UL, 2UL );
7264
7265 if( blaze::isSame( sv1, sv2 ) == true ) {
7266 std::ostringstream oss;
7267 oss << " Test: " << test_ << "\n"
7268 << " Error: Invalid isSame evaluation\n"
7269 << " Details:\n"
7270 << " First subvector:\n" << sv1 << "\n"
7271 << " Second subvector:\n" << sv2 << "\n";
7272 throw std::runtime_error( oss.str() );
7273 }
7274 }
7275
7276 // isSame with non-matching row subvectors on two submatrices (different offset)
7277 {
7278 auto sm1 = blaze::submatrix( mat_, 1UL, 0UL, 3UL, 4UL );
7279 auto sm2 = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 5UL );
7280 auto band1 = blaze::band( sm1, 1L );
7281 auto band2 = blaze::band( sm2, 0L );
7282 auto sv1 = blaze::subvector( band1, 0UL, 2UL );
7283 auto sv2 = blaze::subvector( band2, 1UL, 2UL );
7284
7285 if( blaze::isSame( sv1, sv2 ) == true ) {
7286 std::ostringstream oss;
7287 oss << " Test: " << test_ << "\n"
7288 << " Error: Invalid isSame evaluation\n"
7289 << " Details:\n"
7290 << " First subvector:\n" << sv1 << "\n"
7291 << " Second subvector:\n" << sv2 << "\n";
7292 throw std::runtime_error( oss.str() );
7293 }
7294 }
7295 }
7296
7297
7298 //=====================================================================================
7299 // Column-major matrix tests
7300 //=====================================================================================
7301
7302 {
7303 test_ = "Column-major isSame() function";
7304
7305 // isSame with matching bands
7306 {
7307 OBT band1 = blaze::band( tmat_, -1L );
7308 OBT band2 = blaze::band( tmat_, -1L );
7309
7310 if( blaze::isSame( band1, band2 ) == false ) {
7311 std::ostringstream oss;
7312 oss << " Test: " << test_ << "\n"
7313 << " Error: Invalid isSame evaluation\n"
7314 << " Details:\n"
7315 << " First band:\n" << band1 << "\n"
7316 << " Second band:\n" << band2 << "\n";
7317 throw std::runtime_error( oss.str() );
7318 }
7319 }
7320
7321 // isSame with non-matching bands
7322 {
7323 OBT band1 = blaze::band( tmat_, -1L );
7324 OBT band2 = blaze::band( tmat_, 0L );
7325
7326 if( blaze::isSame( band1, band2 ) == true ) {
7327 std::ostringstream oss;
7328 oss << " Test: " << test_ << "\n"
7329 << " Error: Invalid isSame evaluation\n"
7330 << " Details:\n"
7331 << " First band:\n" << band1 << "\n"
7332 << " Second band:\n" << band2 << "\n";
7333 throw std::runtime_error( oss.str() );
7334 }
7335 }
7336
7337 // isSame with band and matching subvector
7338 {
7339 OBT band1 = blaze::band( tmat_, -1L );
7340 auto sv = blaze::subvector( band1, 0UL, 4UL );
7341
7342 if( blaze::isSame( band1, sv ) == false ) {
7343 std::ostringstream oss;
7344 oss << " Test: " << test_ << "\n"
7345 << " Error: Invalid isSame evaluation\n"
7346 << " Details:\n"
7347 << " Dense band:\n" << band1 << "\n"
7348 << " Dense subvector:\n" << sv << "\n";
7349 throw std::runtime_error( oss.str() );
7350 }
7351
7352 if( blaze::isSame( sv, band1 ) == false ) {
7353 std::ostringstream oss;
7354 oss << " Test: " << test_ << "\n"
7355 << " Error: Invalid isSame evaluation\n"
7356 << " Details:\n"
7357 << " Dense band:\n" << band1 << "\n"
7358 << " Dense subvector:\n" << sv << "\n";
7359 throw std::runtime_error( oss.str() );
7360 }
7361 }
7362
7363 // isSame with band and non-matching subvector (different size)
7364 {
7365 OBT band1 = blaze::band( tmat_, -1L );
7366 auto sv = blaze::subvector( band1, 0UL, 3UL );
7367
7368 if( blaze::isSame( band1, sv ) == true ) {
7369 std::ostringstream oss;
7370 oss << " Test: " << test_ << "\n"
7371 << " Error: Invalid isSame evaluation\n"
7372 << " Details:\n"
7373 << " Dense band:\n" << band1 << "\n"
7374 << " Dense subvector:\n" << sv << "\n";
7375 throw std::runtime_error( oss.str() );
7376 }
7377
7378 if( blaze::isSame( sv, band1 ) == true ) {
7379 std::ostringstream oss;
7380 oss << " Test: " << test_ << "\n"
7381 << " Error: Invalid isSame evaluation\n"
7382 << " Details:\n"
7383 << " Dense band:\n" << band1 << "\n"
7384 << " Dense subvector:\n" << sv << "\n";
7385 throw std::runtime_error( oss.str() );
7386 }
7387 }
7388
7389 // isSame with band and non-matching subvector (different offset)
7390 {
7391 OBT band1 = blaze::band( tmat_, -1L );
7392 auto sv = blaze::subvector( band1, 1UL, 3UL );
7393
7394 if( blaze::isSame( band1, sv ) == true ) {
7395 std::ostringstream oss;
7396 oss << " Test: " << test_ << "\n"
7397 << " Error: Invalid isSame evaluation\n"
7398 << " Details:\n"
7399 << " Dense band:\n" << band1 << "\n"
7400 << " Dense subvector:\n" << sv << "\n";
7401 throw std::runtime_error( oss.str() );
7402 }
7403
7404 if( blaze::isSame( sv, band1 ) == true ) {
7405 std::ostringstream oss;
7406 oss << " Test: " << test_ << "\n"
7407 << " Error: Invalid isSame evaluation\n"
7408 << " Details:\n"
7409 << " Dense band:\n" << band1 << "\n"
7410 << " Dense subvector:\n" << sv << "\n";
7411 throw std::runtime_error( oss.str() );
7412 }
7413 }
7414
7415 // isSame with matching bands on a common submatrix
7416 {
7417 auto sm = blaze::submatrix( tmat_, 1UL, 1UL, 4UL, 3UL );
7418 auto band1 = blaze::band( sm, -1L );
7419 auto band2 = blaze::band( sm, -1L );
7420
7421 if( blaze::isSame( band1, band2 ) == false ) {
7422 std::ostringstream oss;
7423 oss << " Test: " << test_ << "\n"
7424 << " Error: Invalid isSame evaluation\n"
7425 << " Details:\n"
7426 << " First band:\n" << band1 << "\n"
7427 << " Second band:\n" << band2 << "\n";
7428 throw std::runtime_error( oss.str() );
7429 }
7430 }
7431
7432 // isSame with non-matching bands on a common submatrix
7433 {
7434 auto sm = blaze::submatrix( tmat_, 1UL, 1UL, 4UL, 3UL );
7435 auto band1 = blaze::band( sm, -1L );
7436 auto band2 = blaze::band( sm, 0L );
7437
7438 if( blaze::isSame( band1, band2 ) == true ) {
7439 std::ostringstream oss;
7440 oss << " Test: " << test_ << "\n"
7441 << " Error: Invalid isSame evaluation\n"
7442 << " Details:\n"
7443 << " First band:\n" << band1 << "\n"
7444 << " Second band:\n" << band2 << "\n";
7445 throw std::runtime_error( oss.str() );
7446 }
7447 }
7448
7449 // isSame with matching rows on matrix and submatrix
7450 {
7451 auto sm = blaze::submatrix( tmat_, 1UL, 0UL, 4UL, 4UL );
7452 auto band1 = blaze::band( tmat_, -1L );
7453 auto band2 = blaze::band( sm , 0L );
7454
7455 if( blaze::isSame( band1, band2 ) == false ) {
7456 std::ostringstream oss;
7457 oss << " Test: " << test_ << "\n"
7458 << " Error: Invalid isSame evaluation\n"
7459 << " Details:\n"
7460 << " First band:\n" << band1 << "\n"
7461 << " Second band:\n" << band2 << "\n";
7462 throw std::runtime_error( oss.str() );
7463 }
7464
7465 if( blaze::isSame( band2, band1 ) == false ) {
7466 std::ostringstream oss;
7467 oss << " Test: " << test_ << "\n"
7468 << " Error: Invalid isSame evaluation\n"
7469 << " Details:\n"
7470 << " First band:\n" << band1 << "\n"
7471 << " Second band:\n" << band2 << "\n";
7472 throw std::runtime_error( oss.str() );
7473 }
7474 }
7475
7476 // isSame with non-matching rows on matrix and submatrix (different band)
7477 {
7478 auto sm = blaze::submatrix( tmat_, 1UL, 0UL, 4UL, 4UL );
7479 auto band1 = blaze::band( tmat_, -2L );
7480 auto band2 = blaze::band( sm , 0L );
7481
7482 if( blaze::isSame( band1, band2 ) == true ) {
7483 std::ostringstream oss;
7484 oss << " Test: " << test_ << "\n"
7485 << " Error: Invalid isSame evaluation\n"
7486 << " Details:\n"
7487 << " First band:\n" << band1 << "\n"
7488 << " Second band:\n" << band2 << "\n";
7489 throw std::runtime_error( oss.str() );
7490 }
7491
7492 if( blaze::isSame( band2, band1 ) == true ) {
7493 std::ostringstream oss;
7494 oss << " Test: " << test_ << "\n"
7495 << " Error: Invalid isSame evaluation\n"
7496 << " Details:\n"
7497 << " First band:\n" << band1 << "\n"
7498 << " Second band:\n" << band2 << "\n";
7499 throw std::runtime_error( oss.str() );
7500 }
7501 }
7502
7503 // isSame with non-matching rows on matrix and submatrix (different size)
7504 {
7505 auto sm = blaze::submatrix( tmat_, 1UL, 0UL, 4UL, 3UL );
7506 auto band1 = blaze::band( tmat_, -1L );
7507 auto band2 = blaze::band( sm , 0L );
7508
7509 if( blaze::isSame( band1, band2 ) == true ) {
7510 std::ostringstream oss;
7511 oss << " Test: " << test_ << "\n"
7512 << " Error: Invalid isSame evaluation\n"
7513 << " Details:\n"
7514 << " First band:\n" << band1 << "\n"
7515 << " Second band:\n" << band2 << "\n";
7516 throw std::runtime_error( oss.str() );
7517 }
7518
7519 if( blaze::isSame( band2, band1 ) == true ) {
7520 std::ostringstream oss;
7521 oss << " Test: " << test_ << "\n"
7522 << " Error: Invalid isSame evaluation\n"
7523 << " Details:\n"
7524 << " First band:\n" << band1 << "\n"
7525 << " Second band:\n" << band2 << "\n";
7526 throw std::runtime_error( oss.str() );
7527 }
7528 }
7529
7530 // isSame with matching rows on two submatrices
7531 {
7532 auto sm1 = blaze::submatrix( tmat_, 0UL, 1UL, 4UL, 3UL );
7533 auto sm2 = blaze::submatrix( tmat_, 1UL, 1UL, 5UL, 3UL );
7534 auto band1 = blaze::band( sm1, -1L );
7535 auto band2 = blaze::band( sm2, 0L );
7536
7537 if( blaze::isSame( band1, band2 ) == false ) {
7538 std::ostringstream oss;
7539 oss << " Test: " << test_ << "\n"
7540 << " Error: Invalid isSame evaluation\n"
7541 << " Details:\n"
7542 << " First band:\n" << band1 << "\n"
7543 << " Second band:\n" << band2 << "\n";
7544 throw std::runtime_error( oss.str() );
7545 }
7546 }
7547
7548 // isSame with non-matching rows on two submatrices (different band)
7549 {
7550 auto sm1 = blaze::submatrix( tmat_, 0UL, 1UL, 4UL, 3UL );
7551 auto sm2 = blaze::submatrix( tmat_, 1UL, 1UL, 5UL, 3UL );
7552 auto band1 = blaze::band( sm1, -1L );
7553 auto band2 = blaze::band( sm2, -1L );
7554
7555 if( blaze::isSame( band1, band2 ) == true ) {
7556 std::ostringstream oss;
7557 oss << " Test: " << test_ << "\n"
7558 << " Error: Invalid isSame evaluation\n"
7559 << " Details:\n"
7560 << " First band:\n" << band1 << "\n"
7561 << " Second band:\n" << band2 << "\n";
7562 throw std::runtime_error( oss.str() );
7563 }
7564 }
7565
7566 // isSame with non-matching rows on two submatrices (different size)
7567 {
7568 auto sm1 = blaze::submatrix( tmat_, 0UL, 1UL, 4UL, 3UL );
7569 auto sm2 = blaze::submatrix( tmat_, 1UL, 1UL, 5UL, 2UL );
7570 auto band1 = blaze::band( sm1, -1L );
7571 auto band2 = blaze::band( sm2, 0L );
7572
7573 if( blaze::isSame( band1, band2 ) == true ) {
7574 std::ostringstream oss;
7575 oss << " Test: " << test_ << "\n"
7576 << " Error: Invalid isSame evaluation\n"
7577 << " Details:\n"
7578 << " First band:\n" << band1 << "\n"
7579 << " Second band:\n" << band2 << "\n";
7580 throw std::runtime_error( oss.str() );
7581 }
7582 }
7583
7584 // isSame with non-matching rows on two submatrices (different offset)
7585 {
7586 auto sm1 = blaze::submatrix( tmat_, 0UL, 0UL, 4UL, 3UL );
7587 auto sm2 = blaze::submatrix( tmat_, 1UL, 1UL, 5UL, 2UL );
7588 auto band1 = blaze::band( sm1, 0L );
7589 auto band2 = blaze::band( sm2, 0L );
7590
7591 if( blaze::isSame( band1, band2 ) == true ) {
7592 std::ostringstream oss;
7593 oss << " Test: " << test_ << "\n"
7594 << " Error: Invalid isSame evaluation\n"
7595 << " Details:\n"
7596 << " First band:\n" << band1 << "\n"
7597 << " Second band:\n" << band2 << "\n";
7598 throw std::runtime_error( oss.str() );
7599 }
7600 }
7601
7602 // isSame with matching band subvectors on submatrices
7603 {
7604 auto sm = blaze::submatrix( tmat_, 1UL, 1UL, 4UL, 3UL );
7605 auto band1 = blaze::band( sm, -1L );
7606 auto sv1 = blaze::subvector( band1, 0UL, 2UL );
7607 auto sv2 = blaze::subvector( band1, 0UL, 2UL );
7608
7609 if( blaze::isSame( sv1, sv2 ) == false ) {
7610 std::ostringstream oss;
7611 oss << " Test: " << test_ << "\n"
7612 << " Error: Invalid isSame evaluation\n"
7613 << " Details:\n"
7614 << " First subvector:\n" << sv1 << "\n"
7615 << " Second subvector:\n" << sv2 << "\n";
7616 throw std::runtime_error( oss.str() );
7617 }
7618 }
7619
7620 // isSame with non-matching band subvectors on submatrices (different size)
7621 {
7622 auto sm = blaze::submatrix( tmat_, 1UL, 1UL, 4UL, 3UL );
7623 auto band1 = blaze::band( sm, -1L );
7624 auto sv1 = blaze::subvector( band1, 0UL, 3UL );
7625 auto sv2 = blaze::subvector( band1, 0UL, 2UL );
7626
7627 if( blaze::isSame( sv1, sv2 ) == true ) {
7628 std::ostringstream oss;
7629 oss << " Test: " << test_ << "\n"
7630 << " Error: Invalid isSame evaluation\n"
7631 << " Details:\n"
7632 << " First subvector:\n" << sv1 << "\n"
7633 << " Second subvector:\n" << sv2 << "\n";
7634 throw std::runtime_error( oss.str() );
7635 }
7636 }
7637
7638 // isSame with non-matching band subvectors on submatrices (different offset)
7639 {
7640 auto sm = blaze::submatrix( tmat_, 1UL, 1UL, 4UL, 3UL );
7641 auto band1 = blaze::band( sm, -1L );
7642 auto sv1 = blaze::subvector( band1, 0UL, 2UL );
7643 auto sv2 = blaze::subvector( band1, 1UL, 2UL );
7644
7645 if( blaze::isSame( sv1, sv2 ) == true ) {
7646 std::ostringstream oss;
7647 oss << " Test: " << test_ << "\n"
7648 << " Error: Invalid isSame evaluation\n"
7649 << " Details:\n"
7650 << " First subvector:\n" << sv1 << "\n"
7651 << " Second subvector:\n" << sv2 << "\n";
7652 throw std::runtime_error( oss.str() );
7653 }
7654 }
7655
7656 // isSame with matching row subvectors on two submatrices
7657 {
7658 auto sm1 = blaze::submatrix( tmat_, 0UL, 1UL, 4UL, 3UL );
7659 auto sm2 = blaze::submatrix( tmat_, 1UL, 1UL, 5UL, 3UL );
7660 auto band1 = blaze::band( sm1, -1L );
7661 auto band2 = blaze::band( sm2, 0L );
7662 auto sv1 = blaze::subvector( band1, 0UL, 2UL );
7663 auto sv2 = blaze::subvector( band2, 0UL, 2UL );
7664
7665 if( blaze::isSame( sv1, sv2 ) == false ) {
7666 std::ostringstream oss;
7667 oss << " Test: " << test_ << "\n"
7668 << " Error: Invalid isSame evaluation\n"
7669 << " Details:\n"
7670 << " First subvector:\n" << sv1 << "\n"
7671 << " Second subvector:\n" << sv2 << "\n";
7672 throw std::runtime_error( oss.str() );
7673 }
7674 }
7675
7676 // isSame with non-matching row subvectors on two submatrices (different size)
7677 {
7678 auto sm1 = blaze::submatrix( tmat_, 0UL, 1UL, 4UL, 3UL );
7679 auto sm2 = blaze::submatrix( tmat_, 1UL, 1UL, 5UL, 3UL );
7680 auto band1 = blaze::band( sm1, -1L );
7681 auto band2 = blaze::band( sm2, 0L );
7682 auto sv1 = blaze::subvector( band1, 0UL, 3UL );
7683 auto sv2 = blaze::subvector( band2, 0UL, 2UL );
7684
7685 if( blaze::isSame( sv1, sv2 ) == true ) {
7686 std::ostringstream oss;
7687 oss << " Test: " << test_ << "\n"
7688 << " Error: Invalid isSame evaluation\n"
7689 << " Details:\n"
7690 << " First subvector:\n" << sv1 << "\n"
7691 << " Second subvector:\n" << sv2 << "\n";
7692 throw std::runtime_error( oss.str() );
7693 }
7694 }
7695
7696 // isSame with non-matching row subvectors on two submatrices (different offset)
7697 {
7698 auto sm1 = blaze::submatrix( tmat_, 0UL, 1UL, 4UL, 3UL );
7699 auto sm2 = blaze::submatrix( tmat_, 1UL, 1UL, 5UL, 3UL );
7700 auto band1 = blaze::band( sm1, -1L );
7701 auto band2 = blaze::band( sm2, 0L );
7702 auto sv1 = blaze::subvector( band1, 0UL, 2UL );
7703 auto sv2 = blaze::subvector( band2, 1UL, 2UL );
7704
7705 if( blaze::isSame( sv1, sv2 ) == true ) {
7706 std::ostringstream oss;
7707 oss << " Test: " << test_ << "\n"
7708 << " Error: Invalid isSame evaluation\n"
7709 << " Details:\n"
7710 << " First subvector:\n" << sv1 << "\n"
7711 << " Second subvector:\n" << sv2 << "\n";
7712 throw std::runtime_error( oss.str() );
7713 }
7714 }
7715 }
7716 }
7717 //*************************************************************************************************
7718
7719
7720 //*************************************************************************************************
7721 /*!\brief Test of the \c subvector() function with the Band specialization.
7722 //
7723 // \return void
7724 // \exception std::runtime_error Error detected.
7725 //
7726 // This function performs a test of the \c subvector() function used with the Band specialization.
7727 // In case an error is detected, a \a std::runtime_error exception is thrown.
7728 */
testSubvector()7729 void DenseTest::testSubvector()
7730 {
7731 //=====================================================================================
7732 // Row-major matrix tests
7733 //=====================================================================================
7734
7735 {
7736 test_ = "Row-major subvector() function";
7737
7738 initialize();
7739
7740 {
7741 BT band1 = blaze::band( mat_, 1L );
7742 auto sv = blaze::subvector( band1, 0UL, 4UL );
7743
7744 if( sv[0] != 0 || sv[1] != 4 || sv[2] != 5 || sv[3] != -6 ) {
7745 std::ostringstream oss;
7746 oss << " Test: " << test_ << "\n"
7747 << " Error: Subscript operator access failed\n"
7748 << " Details:\n"
7749 << " Result:\n" << sv << "\n"
7750 << " Expected result:\n( 0 4 5 -6 )\n";
7751 throw std::runtime_error( oss.str() );
7752 }
7753
7754 if( *sv.begin() != 0 ) {
7755 std::ostringstream oss;
7756 oss << " Test: " << test_ << "\n"
7757 << " Error: Iterator access failed\n"
7758 << " Details:\n"
7759 << " Result: " << *sv.begin() << "\n"
7760 << " Expected result: 0\n";
7761 throw std::runtime_error( oss.str() );
7762 }
7763 }
7764
7765 try {
7766 BT band1 = blaze::band( mat_, 1L );
7767 auto sv = blaze::subvector( band1, 4UL, 4UL );
7768
7769 std::ostringstream oss;
7770 oss << " Test: " << test_ << "\n"
7771 << " Error: Setup of out-of-bounds subvector succeeded\n"
7772 << " Details:\n"
7773 << " Result:\n" << sv << "\n";
7774 throw std::runtime_error( oss.str() );
7775 }
7776 catch( std::invalid_argument& ) {}
7777
7778 try {
7779 BT band1 = blaze::band( mat_, 1L );
7780 auto sv = blaze::subvector( band1, 0UL, 5UL );
7781
7782 std::ostringstream oss;
7783 oss << " Test: " << test_ << "\n"
7784 << " Error: Setup of out-of-bounds subvector succeeded\n"
7785 << " Details:\n"
7786 << " Result:\n" << sv << "\n";
7787 throw std::runtime_error( oss.str() );
7788 }
7789 catch( std::invalid_argument& ) {}
7790 }
7791
7792
7793 //=====================================================================================
7794 // Column-major matrix tests
7795 //=====================================================================================
7796
7797 {
7798 test_ = "Column-major subvector() function";
7799
7800 initialize();
7801
7802 {
7803 OBT band1 = blaze::band( tmat_, -1L );
7804 auto sv = blaze::subvector( band1, 0UL, 4UL );
7805
7806 if( sv[0] != 0 || sv[1] != 4 || sv[2] != 5 || sv[3] != -6 ) {
7807 std::ostringstream oss;
7808 oss << " Test: " << test_ << "\n"
7809 << " Error: Subscript operator access failed\n"
7810 << " Details:\n"
7811 << " Result:\n" << sv << "\n"
7812 << " Expected result:\n( 0 4 5 -6 )\n";
7813 throw std::runtime_error( oss.str() );
7814 }
7815
7816 if( *sv.begin() != 0 ) {
7817 std::ostringstream oss;
7818 oss << " Test: " << test_ << "\n"
7819 << " Error: Iterator access failed\n"
7820 << " Details:\n"
7821 << " Result: " << *sv.begin() << "\n"
7822 << " Expected result: 0\n";
7823 throw std::runtime_error( oss.str() );
7824 }
7825 }
7826
7827 try {
7828 OBT band1 = blaze::band( tmat_, -1L );
7829 auto sv = blaze::subvector( band1, 4UL, 4UL );
7830
7831 std::ostringstream oss;
7832 oss << " Test: " << test_ << "\n"
7833 << " Error: Setup of out-of-bounds subvector succeeded\n"
7834 << " Details:\n"
7835 << " Result:\n" << sv << "\n";
7836 throw std::runtime_error( oss.str() );
7837 }
7838 catch( std::invalid_argument& ) {}
7839
7840 try {
7841 OBT band1 = blaze::band( tmat_, -1L );
7842 auto sv = blaze::subvector( band1, 0UL, 5UL );
7843
7844 std::ostringstream oss;
7845 oss << " Test: " << test_ << "\n"
7846 << " Error: Setup of out-of-bounds subvector succeeded\n"
7847 << " Details:\n"
7848 << " Result:\n" << sv << "\n";
7849 throw std::runtime_error( oss.str() );
7850 }
7851 catch( std::invalid_argument& ) {}
7852 }
7853 }
7854 //*************************************************************************************************
7855
7856
7857 //*************************************************************************************************
7858 /*!\brief Test of the \c elements() function with the Band specialization.
7859 //
7860 // \return void
7861 // \exception std::runtime_error Error detected.
7862 //
7863 // This function performs a test of the \c elements() function used with the Band specialization.
7864 // In case an error is detected, a \a std::runtime_error exception is thrown.
7865 */
testElements()7866 void DenseTest::testElements()
7867 {
7868 //=====================================================================================
7869 // Row-major matrix tests (initializer_list)
7870 //=====================================================================================
7871
7872 {
7873 test_ = "Row-major elements() function (initializer_list)";
7874
7875 initialize();
7876
7877 {
7878 BT band1 = blaze::band( mat_, 1L );
7879 auto e = blaze::elements( band1, { 3UL, 2UL } );
7880
7881 if( e[0] != -6 || e[1] != 5 ) {
7882 std::ostringstream oss;
7883 oss << " Test: " << test_ << "\n"
7884 << " Error: Subscript operator access failed\n"
7885 << " Details:\n"
7886 << " Result:\n" << e << "\n"
7887 << " Expected result:\n( -6 5 )\n";
7888 throw std::runtime_error( oss.str() );
7889 }
7890
7891 if( *e.begin() != -6 ) {
7892 std::ostringstream oss;
7893 oss << " Test: " << test_ << "\n"
7894 << " Error: Iterator access failed\n"
7895 << " Details:\n"
7896 << " Result: " << *e.begin() << "\n"
7897 << " Expected result: -6\n";
7898 throw std::runtime_error( oss.str() );
7899 }
7900 }
7901
7902 try {
7903 BT band1 = blaze::band( mat_, 1L );
7904 auto e = blaze::elements( band1, { 4UL } );
7905
7906 std::ostringstream oss;
7907 oss << " Test: " << test_ << "\n"
7908 << " Error: Setup of out-of-bounds element selection succeeded\n"
7909 << " Details:\n"
7910 << " Result:\n" << e << "\n";
7911 throw std::runtime_error( oss.str() );
7912 }
7913 catch( std::invalid_argument& ) {}
7914 }
7915
7916
7917 //=====================================================================================
7918 // Row-major matrix tests (std::array)
7919 //=====================================================================================
7920
7921 {
7922 test_ = "Row-major elements() function (std::array)";
7923
7924 initialize();
7925
7926 {
7927 std::array<int,2UL> indices{ 3UL, 2UL };
7928
7929 BT band1 = blaze::band( mat_, 1L );
7930 auto e = blaze::elements( band1, indices );
7931
7932 if( e[0] != -6 || e[1] != 5 ) {
7933 std::ostringstream oss;
7934 oss << " Test: " << test_ << "\n"
7935 << " Error: Subscript operator access failed\n"
7936 << " Details:\n"
7937 << " Result:\n" << e << "\n"
7938 << " Expected result:\n( -6 5 )\n";
7939 throw std::runtime_error( oss.str() );
7940 }
7941
7942 if( *e.begin() != -6 ) {
7943 std::ostringstream oss;
7944 oss << " Test: " << test_ << "\n"
7945 << " Error: Iterator access failed\n"
7946 << " Details:\n"
7947 << " Result: " << *e.begin() << "\n"
7948 << " Expected result: -6\n";
7949 throw std::runtime_error( oss.str() );
7950 }
7951 }
7952
7953 try {
7954 std::array<int,2UL> indices{ 4UL };
7955
7956 BT band1 = blaze::band( mat_, 1L );
7957 auto e = blaze::elements( band1, indices );
7958
7959 std::ostringstream oss;
7960 oss << " Test: " << test_ << "\n"
7961 << " Error: Setup of out-of-bounds element selection succeeded\n"
7962 << " Details:\n"
7963 << " Result:\n" << e << "\n";
7964 throw std::runtime_error( oss.str() );
7965 }
7966 catch( std::invalid_argument& ) {}
7967 }
7968
7969
7970 //=====================================================================================
7971 // Row-major matrix tests (lambda expression)
7972 //=====================================================================================
7973
7974 {
7975 test_ = "Row-major elements() function (lambda expression)";
7976
7977 initialize();
7978
7979 {
7980 BT band1 = blaze::band( mat_, 1L );
7981 auto e = blaze::elements( band1, []( size_t i ){ return 3UL-i; }, 2UL );
7982
7983 if( e[0] != -6 || e[1] != 5 ) {
7984 std::ostringstream oss;
7985 oss << " Test: " << test_ << "\n"
7986 << " Error: Subscript operator access failed\n"
7987 << " Details:\n"
7988 << " Result:\n" << e << "\n"
7989 << " Expected result:\n( -6 5 )\n";
7990 throw std::runtime_error( oss.str() );
7991 }
7992
7993 if( *e.begin() != -6 ) {
7994 std::ostringstream oss;
7995 oss << " Test: " << test_ << "\n"
7996 << " Error: Iterator access failed\n"
7997 << " Details:\n"
7998 << " Result: " << *e.begin() << "\n"
7999 << " Expected result: -6\n";
8000 throw std::runtime_error( oss.str() );
8001 }
8002 }
8003
8004 try {
8005 BT band1 = blaze::band( mat_, 1L );
8006 auto e = blaze::elements( band1, []( size_t ){ return 4UL; }, 1UL );
8007
8008 std::ostringstream oss;
8009 oss << " Test: " << test_ << "\n"
8010 << " Error: Setup of out-of-bounds element selection succeeded\n"
8011 << " Details:\n"
8012 << " Result:\n" << e << "\n";
8013 throw std::runtime_error( oss.str() );
8014 }
8015 catch( std::invalid_argument& ) {}
8016 }
8017
8018
8019 //=====================================================================================
8020 // Column-major matrix tests (initializer_list)
8021 //=====================================================================================
8022
8023 {
8024 test_ = "Column-major elements() function (initializer_list)";
8025
8026 initialize();
8027
8028 {
8029 OBT band1 = blaze::band( tmat_, -1L );
8030 auto e = blaze::elements( band1, { 3UL, 2UL } );
8031
8032 if( e[0] != -6 || e[1] != 5 ) {
8033 std::ostringstream oss;
8034 oss << " Test: " << test_ << "\n"
8035 << " Error: Subscript operator access failed\n"
8036 << " Details:\n"
8037 << " Result:\n" << e << "\n"
8038 << " Expected result:\n( -6 5 )\n";
8039 throw std::runtime_error( oss.str() );
8040 }
8041
8042 if( *e.begin() != -6 ) {
8043 std::ostringstream oss;
8044 oss << " Test: " << test_ << "\n"
8045 << " Error: Iterator access failed\n"
8046 << " Details:\n"
8047 << " Result: " << *e.begin() << "\n"
8048 << " Expected result: -6\n";
8049 throw std::runtime_error( oss.str() );
8050 }
8051 }
8052
8053 try {
8054 OBT band1 = blaze::band( tmat_, -1L );
8055 auto e = blaze::elements( band1, { 4UL } );
8056
8057 std::ostringstream oss;
8058 oss << " Test: " << test_ << "\n"
8059 << " Error: Setup of out-of-bounds element selection succeeded\n"
8060 << " Details:\n"
8061 << " Result:\n" << e << "\n";
8062 throw std::runtime_error( oss.str() );
8063 }
8064 catch( std::invalid_argument& ) {}
8065 }
8066
8067
8068 //=====================================================================================
8069 // Column-major matrix tests (std::array)
8070 //=====================================================================================
8071
8072 {
8073 test_ = "Column-major elements() function (std::array)";
8074
8075 initialize();
8076
8077 {
8078 std::array<int,2UL> indices{ 3UL, 2UL };
8079
8080 OBT band1 = blaze::band( tmat_, -1L );
8081 auto e = blaze::elements( band1, indices );
8082
8083 if( e[0] != -6 || e[1] != 5 ) {
8084 std::ostringstream oss;
8085 oss << " Test: " << test_ << "\n"
8086 << " Error: Subscript operator access failed\n"
8087 << " Details:\n"
8088 << " Result:\n" << e << "\n"
8089 << " Expected result:\n( -6 5 )\n";
8090 throw std::runtime_error( oss.str() );
8091 }
8092
8093 if( *e.begin() != -6 ) {
8094 std::ostringstream oss;
8095 oss << " Test: " << test_ << "\n"
8096 << " Error: Iterator access failed\n"
8097 << " Details:\n"
8098 << " Result: " << *e.begin() << "\n"
8099 << " Expected result: -6\n";
8100 throw std::runtime_error( oss.str() );
8101 }
8102 }
8103
8104 try {
8105 std::array<int,1UL> indices{ 4UL };
8106
8107 OBT band1 = blaze::band( tmat_, -1L );
8108 auto e = blaze::elements( band1, indices );
8109
8110 std::ostringstream oss;
8111 oss << " Test: " << test_ << "\n"
8112 << " Error: Setup of out-of-bounds element selection succeeded\n"
8113 << " Details:\n"
8114 << " Result:\n" << e << "\n";
8115 throw std::runtime_error( oss.str() );
8116 }
8117 catch( std::invalid_argument& ) {}
8118 }
8119
8120
8121 //=====================================================================================
8122 // Column-major matrix tests (lambda expression)
8123 //=====================================================================================
8124
8125 {
8126 test_ = "Column-major elements() function (lambda expression)";
8127
8128 initialize();
8129
8130 {
8131 OBT band1 = blaze::band( tmat_, -1L );
8132 auto e = blaze::elements( band1, []( size_t i ){ return 3UL-i; }, 2UL );
8133
8134 if( e[0] != -6 || e[1] != 5 ) {
8135 std::ostringstream oss;
8136 oss << " Test: " << test_ << "\n"
8137 << " Error: Subscript operator access failed\n"
8138 << " Details:\n"
8139 << " Result:\n" << e << "\n"
8140 << " Expected result:\n( -6 5 )\n";
8141 throw std::runtime_error( oss.str() );
8142 }
8143
8144 if( *e.begin() != -6 ) {
8145 std::ostringstream oss;
8146 oss << " Test: " << test_ << "\n"
8147 << " Error: Iterator access failed\n"
8148 << " Details:\n"
8149 << " Result: " << *e.begin() << "\n"
8150 << " Expected result: -6\n";
8151 throw std::runtime_error( oss.str() );
8152 }
8153 }
8154
8155 try {
8156 OBT band1 = blaze::band( tmat_, -1L );
8157 auto e = blaze::elements( band1, []( size_t ){ return 4UL; }, 1UL );
8158
8159 std::ostringstream oss;
8160 oss << " Test: " << test_ << "\n"
8161 << " Error: Setup of out-of-bounds element selection succeeded\n"
8162 << " Details:\n"
8163 << " Result:\n" << e << "\n";
8164 throw std::runtime_error( oss.str() );
8165 }
8166 catch( std::invalid_argument& ) {}
8167 }
8168 }
8169 //*************************************************************************************************
8170
8171
8172
8173
8174 //=================================================================================================
8175 //
8176 // UTILITY FUNCTIONS
8177 //
8178 //=================================================================================================
8179
8180 //*************************************************************************************************
8181 /*!\brief Initialization of all member matrices.
8182 //
8183 // \return void
8184 // \exception std::runtime_error Error detected.
8185 //
8186 // This function initializes all member matrices to specific predetermined values.
8187 */
initialize()8188 void DenseTest::initialize()
8189 {
8190 // Initializing the row-major dynamic matrix
8191 mat_.reset();
8192 mat_(0,0) = -2;
8193 mat_(0,2) = 7;
8194 mat_(1,2) = 4;
8195 mat_(1,3) = -8;
8196 mat_(2,1) = 1;
8197 mat_(2,2) = -3;
8198 mat_(2,3) = 5;
8199 mat_(2,4) = 9;
8200 mat_(3,4) = -6;
8201 mat_(3,5) = 10;
8202
8203 // Initializing the column-major dynamic matrix
8204 tmat_ = trans( mat_ );
8205 }
8206 //*************************************************************************************************
8207
8208 } // namespace band
8209
8210 } // namespace views
8211
8212 } // namespace mathtest
8213
8214 } // namespace blazetest
8215
8216
8217
8218
8219 //=================================================================================================
8220 //
8221 // MAIN FUNCTION
8222 //
8223 //=================================================================================================
8224
8225 //*************************************************************************************************
main()8226 int main()
8227 {
8228 std::cout << " Running Band dense test..." << std::endl;
8229
8230 try
8231 {
8232 RUN_BAND_DENSE_TEST;
8233 }
8234 catch( std::exception& ex ) {
8235 std::cerr << "\n\n ERROR DETECTED during Band dense test:\n"
8236 << ex.what() << "\n";
8237 return EXIT_FAILURE;
8238 }
8239
8240 return EXIT_SUCCESS;
8241 }
8242 //*************************************************************************************************
8243