1 //=================================================================================================
2 /*!
3 // \file src/mathtest/adaptors/symmetricmatrix/SparseScalarTest1.cpp
4 // \brief Source file for the SymmetricMatrix sparse scalar test (part 1)
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 <blaze/math/DynamicMatrix.h>
43 #include <blaze/math/StaticMatrix.h>
44 #include <blazetest/mathtest/adaptors/symmetricmatrix/SparseScalarTest.h>
45
46 #ifdef BLAZE_USE_HPX_THREADS
47 # include <hpx/hpx_main.hpp>
48 #endif
49
50
51 namespace blazetest {
52
53 namespace mathtest {
54
55 namespace adaptors {
56
57 namespace symmetricmatrix {
58
59 //=================================================================================================
60 //
61 // CONSTRUCTORS
62 //
63 //=================================================================================================
64
65 //*************************************************************************************************
66 /*!\brief Constructor for the SymmetricMatrix sparse scalar test.
67 //
68 // \exception std::runtime_error Operation error detected.
69 */
SparseScalarTest()70 SparseScalarTest::SparseScalarTest()
71 {
72 testConstructors();
73 testAssignment();
74 testAddAssign();
75 testSubAssign();
76 testSchurAssign();
77 testMultAssign();
78 }
79 //*************************************************************************************************
80
81
82
83
84 //=================================================================================================
85 //
86 // TEST FUNCTIONS
87 //
88 //=================================================================================================
89
90 //*************************************************************************************************
91 /*!\brief Test of the SymmetricMatrix constructors.
92 //
93 // \return void
94 // \exception std::runtime_error Error detected.
95 //
96 // This function performs a test of all constructors of the SymmetricMatrix specialization.
97 // In case an error is detected, a \a std::runtime_error exception is thrown.
98 */
testConstructors()99 void SparseScalarTest::testConstructors()
100 {
101 //=====================================================================================
102 // Row-major default constructor
103 //=====================================================================================
104
105 // Default constructor (CompressedMatrix)
106 {
107 test_ = "Row-major SymmetricMatrix default constructor (CompressedMatrix)";
108
109 const ST sym;
110
111 checkRows ( sym, 0UL );
112 checkColumns ( sym, 0UL );
113 checkNonZeros( sym, 0UL );
114 }
115
116
117 //=====================================================================================
118 // Row-major size constructor
119 //=====================================================================================
120
121 // Size constructor (CompressedMatrix)
122 {
123 test_ = "Row-major SymmetricMatrix size constructor (CompressedMatrix)";
124
125 const ST sym( 2UL );
126
127 checkRows ( sym, 2UL );
128 checkColumns ( sym, 2UL );
129 checkNonZeros( sym, 0UL );
130 }
131
132
133 //=====================================================================================
134 // Row-major list initialization
135 //=====================================================================================
136
137 // Complete initializer list
138 {
139 test_ = "Row-major SymmetricMatrix initializer list constructor (complete list)";
140
141 const ST sym{ { 1, 2, 3 }, { 2, 4, 0 }, { 3, 0, 6 } };
142
143 checkRows ( sym, 3UL );
144 checkColumns ( sym, 3UL );
145 checkCapacity( sym, 7UL );
146 checkNonZeros( sym, 7UL );
147
148 if( sym(0,0) != 1 || sym(0,1) != 2 || sym(0,2) != 3 ||
149 sym(1,0) != 2 || sym(1,1) != 4 || sym(1,2) != 0 ||
150 sym(2,0) != 3 || sym(2,1) != 0 || sym(2,2) != 6 ) {
151 std::ostringstream oss;
152 oss << " Test: " << test_ << "\n"
153 << " Error: Construction failed\n"
154 << " Details:\n"
155 << " Result:\n" << sym << "\n"
156 << " Expected result:\n( 1 2 3 )\n( 2 4 0 )\n( 3 0 6 )\n";
157 throw std::runtime_error( oss.str() );
158 }
159 }
160
161 // Incomplete initializer list
162 {
163 test_ = "Row-major SymmetricMatrix initializer list constructor (incomplete list)";
164
165 const ST sym{ { 1, 2, 3 }, { 2, 4 }, { 3, 0, 6 } };
166
167 checkRows ( sym, 3UL );
168 checkColumns ( sym, 3UL );
169 checkCapacity( sym, 7UL );
170 checkNonZeros( sym, 7UL );
171
172 if( sym(0,0) != 1 || sym(0,1) != 2 || sym(0,2) != 3 ||
173 sym(1,0) != 2 || sym(1,1) != 4 || sym(1,2) != 0 ||
174 sym(2,0) != 3 || sym(2,1) != 0 || sym(2,2) != 6 ) {
175 std::ostringstream oss;
176 oss << " Test: " << test_ << "\n"
177 << " Error: Construction failed\n"
178 << " Details:\n"
179 << " Result:\n" << sym << "\n"
180 << " Expected result:\n( 1 2 3 )\n( 2 4 0 )\n( 3 0 6 )\n";
181 throw std::runtime_error( oss.str() );
182 }
183 }
184
185
186 //=====================================================================================
187 // Row-major copy constructor
188 //=====================================================================================
189
190 // Copy constructor (0x0)
191 {
192 test_ = "Row-major SymmetricMatrix copy constructor (0x0)";
193
194 const ST sym1;
195 const ST sym2( sym1 );
196
197 checkRows ( sym2, 0UL );
198 checkColumns ( sym2, 0UL );
199 checkNonZeros( sym2, 0UL );
200 }
201
202 // Copy constructor (3x3)
203 {
204 test_ = "Row-major SymmetricMatrix copy constructor (3x3)";
205
206 ST sym1( 3UL );
207 sym1(0,0) = 1;
208 sym1(0,1) = -4;
209 sym1(0,2) = 7;
210 sym1(1,1) = 2;
211 sym1(2,2) = 3;
212
213 const ST sym2( sym1 );
214
215 checkRows ( sym2, 3UL );
216 checkColumns ( sym2, 3UL );
217 checkCapacity( sym2, 7UL );
218 checkNonZeros( sym2, 7UL );
219
220 if( sym2(0,0) != 1 || sym2(0,1) != -4 || sym2(0,2) != 7 ||
221 sym2(1,0) != -4 || sym2(1,1) != 2 || sym2(1,2) != 0 ||
222 sym2(2,0) != 7 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
223 std::ostringstream oss;
224 oss << " Test: " << test_ << "\n"
225 << " Error: Construction failed\n"
226 << " Details:\n"
227 << " Result:\n" << sym2 << "\n"
228 << " Expected result:\n( 1 -4 7 )\n( -4 2 0 )\n( 7 0 3 )\n";
229 throw std::runtime_error( oss.str() );
230 }
231 }
232
233
234 //=====================================================================================
235 // Row-major move constructor
236 //=====================================================================================
237
238 // Move constructor (0x0)
239 {
240 test_ = "Row-major SymmetricMatrix move constructor (0x0)";
241
242 ST sym1;
243 ST sym2( std::move( sym1 ) );
244
245 checkRows ( sym2, 0UL );
246 checkColumns ( sym2, 0UL );
247 checkNonZeros( sym2, 0UL );
248 }
249
250 // Move constructor (3x3)
251 {
252 test_ = "Row-major SymmetricMatrix move constructor (3x3)";
253
254 ST sym1( 3UL );
255 sym1(0,0) = 1;
256 sym1(0,1) = -4;
257 sym1(0,2) = 7;
258 sym1(1,1) = 2;
259 sym1(2,2) = 3;
260
261 ST sym2( std::move( sym1 ) );
262
263 checkRows ( sym2, 3UL );
264 checkColumns ( sym2, 3UL );
265 checkCapacity( sym2, 7UL );
266 checkNonZeros( sym2, 7UL );
267
268 if( sym2(0,0) != 1 || sym2(0,1) != -4 || sym2(0,2) != 7 ||
269 sym2(1,0) != -4 || sym2(1,1) != 2 || sym2(1,2) != 0 ||
270 sym2(2,0) != 7 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
271 std::ostringstream oss;
272 oss << " Test: " << test_ << "\n"
273 << " Error: Construction failed\n"
274 << " Details:\n"
275 << " Result:\n" << sym2 << "\n"
276 << " Expected result:\n( 1 -4 7 )\n( -4 2 0 )\n( 7 0 3 )\n";
277 throw std::runtime_error( oss.str() );
278 }
279 }
280
281
282 //=====================================================================================
283 // Row-major conversion constructor
284 //=====================================================================================
285
286 // Conversion constructor (0x0)
287 {
288 test_ = "Row-major SymmetricMatrix conversion constructor (0x0)";
289
290 const blaze::DynamicMatrix<int,blaze::rowMajor> mat;
291 const ST sym( mat );
292
293 checkRows ( sym, 0UL );
294 checkColumns ( sym, 0UL );
295 checkNonZeros( sym, 0UL );
296 }
297
298 // Conversion constructor (symmetric)
299 {
300 test_ = "Row-major SymmetricMatrix conversion constructor (symmetric)";
301
302 const blaze::StaticMatrix<int,3UL,3UL,blaze::rowMajor> mat( { { 1, -4, 7 },
303 { -4, 2, 0 },
304 { 7, 0, 3 } } );
305
306 const ST sym( mat );
307
308 checkRows ( sym, 3UL );
309 checkColumns ( sym, 3UL );
310 checkCapacity( sym, 7UL );
311 checkNonZeros( sym, 7UL );
312
313 if( sym(0,0) != 1 || sym(0,1) != -4 || sym(0,2) != 7 ||
314 sym(1,0) != -4 || sym(1,1) != 2 || sym(1,2) != 0 ||
315 sym(2,0) != 7 || sym(2,1) != 0 || sym(2,2) != 3 ) {
316 std::ostringstream oss;
317 oss << " Test: " << test_ << "\n"
318 << " Error: Construction failed\n"
319 << " Details:\n"
320 << " Result:\n" << sym << "\n"
321 << " Expected result:\n( 1 -4 7 )\n( -4 2 0 )\n( 7 0 3 )\n";
322 throw std::runtime_error( oss.str() );
323 }
324 }
325
326 // Conversion constructor (non-symmetric)
327 {
328 test_ = "Row-major SymmetricMatrix conversion constructor (non-symmetric)";
329
330 const blaze::StaticMatrix<int,3UL,3UL,blaze::rowMajor> mat( { { 1, -4, 7 },
331 { -4, 2, 0 },
332 { -5, 0, 3 } } );
333
334 try {
335 const ST sym( mat );
336
337 std::ostringstream oss;
338 oss << " Test: " << test_ << "\n"
339 << " Error: Setup of non-symmetric SymmetricMatrix succeeded\n"
340 << " Details:\n"
341 << " Result:\n" << sym << "\n";
342 throw std::runtime_error( oss.str() );
343 }
344 catch( std::invalid_argument& ) {}
345 }
346
347 // Conversion constructor (SymmetricMatrix)
348 {
349 test_ = "Row-major SymmetricMatrix conversion constructor (SymmetricMatrix)";
350
351 blaze::SymmetricMatrix< blaze::StaticMatrix<int,3UL,3UL,blaze::rowMajor> > sym1;
352 sym1(0,0) = 1;
353 sym1(0,1) = -4;
354 sym1(0,2) = 7;
355 sym1(1,1) = 2;
356 sym1(2,2) = 3;
357
358 const ST sym2( sym1 );
359
360 checkRows ( sym2, 3UL );
361 checkColumns ( sym2, 3UL );
362 checkCapacity( sym2, 7UL );
363 checkNonZeros( sym2, 7UL );
364
365 if( sym2(0,0) != 1 || sym2(0,1) != -4 || sym2(0,2) != 7 ||
366 sym2(1,0) != -4 || sym2(1,1) != 2 || sym2(1,2) != 0 ||
367 sym2(2,0) != 7 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
368 std::ostringstream oss;
369 oss << " Test: " << test_ << "\n"
370 << " Error: Construction failed\n"
371 << " Details:\n"
372 << " Result:\n" << sym2 << "\n"
373 << " Expected result:\n( 1 -4 7 )\n( -4 2 0 )\n( 7 0 3 )\n";
374 throw std::runtime_error( oss.str() );
375 }
376 }
377
378
379 //=====================================================================================
380 // Column-major default constructor
381 //=====================================================================================
382
383 // Default constructor (CompressedMatrix)
384 {
385 test_ = "Column-major SymmetricMatrix default constructor (CompressedMatrix)";
386
387 const OST sym;
388
389 checkRows ( sym, 0UL );
390 checkColumns ( sym, 0UL );
391 checkNonZeros( sym, 0UL );
392 }
393
394
395 //=====================================================================================
396 // Column-major size constructor
397 //=====================================================================================
398
399 // Size constructor (CompressedMatrix)
400 {
401 test_ = "Column-major SymmetricMatrix size constructor (CompressedMatrix)";
402
403 const OST sym( 2UL );
404
405 checkRows ( sym, 2UL );
406 checkColumns ( sym, 2UL );
407 checkNonZeros( sym, 0UL );
408 }
409
410
411 //=====================================================================================
412 // Column-major list initialization
413 //=====================================================================================
414
415 // Complete initializer list
416 {
417 test_ = "Column-major SymmetricMatrix initializer list constructor (complete list)";
418
419 const OST sym{ { 1, 2, 3 }, { 2, 4, 0 }, { 3, 0, 6 } };
420
421 checkRows ( sym, 3UL );
422 checkColumns ( sym, 3UL );
423 checkCapacity( sym, 7UL );
424 checkNonZeros( sym, 7UL );
425
426 if( sym(0,0) != 1 || sym(0,1) != 2 || sym(0,2) != 3 ||
427 sym(1,0) != 2 || sym(1,1) != 4 || sym(1,2) != 0 ||
428 sym(2,0) != 3 || sym(2,1) != 0 || sym(2,2) != 6 ) {
429 std::ostringstream oss;
430 oss << " Test: " << test_ << "\n"
431 << " Error: Construction failed\n"
432 << " Details:\n"
433 << " Result:\n" << sym << "\n"
434 << " Expected result:\n( 1 2 3 )\n( 2 4 0 )\n( 3 0 6 )\n";
435 throw std::runtime_error( oss.str() );
436 }
437 }
438
439 // Incomplete initializer list
440 {
441 test_ = "Column-major SymmetricMatrix initializer list constructor (incomplete list)";
442
443 const OST sym{ { 1, 2, 3 }, { 2, 4 }, { 3, 0, 6 } };
444
445 checkRows ( sym, 3UL );
446 checkColumns ( sym, 3UL );
447 checkCapacity( sym, 7UL );
448 checkNonZeros( sym, 7UL );
449
450 if( sym(0,0) != 1 || sym(0,1) != 2 || sym(0,2) != 3 ||
451 sym(1,0) != 2 || sym(1,1) != 4 || sym(1,2) != 0 ||
452 sym(2,0) != 3 || sym(2,1) != 0 || sym(2,2) != 6 ) {
453 std::ostringstream oss;
454 oss << " Test: " << test_ << "\n"
455 << " Error: Construction failed\n"
456 << " Details:\n"
457 << " Result:\n" << sym << "\n"
458 << " Expected result:\n( 1 2 3 )\n( 2 4 0 )\n( 3 0 6 )\n";
459 throw std::runtime_error( oss.str() );
460 }
461 }
462
463
464 //=====================================================================================
465 // Column-major copy constructor
466 //=====================================================================================
467
468 // Copy constructor (0x0)
469 {
470 test_ = "Column-major SymmetricMatrix copy constructor (0x0)";
471
472 const OST sym1;
473 const OST sym2( sym1 );
474
475 checkRows ( sym2, 0UL );
476 checkColumns ( sym2, 0UL );
477 checkNonZeros( sym2, 0UL );
478 }
479
480 // Copy constructor (3x3)
481 {
482 test_ = "Column-major SymmetricMatrix copy constructor (3x3)";
483
484 OST sym1( 3UL );
485 sym1(0,0) = 1;
486 sym1(0,1) = -4;
487 sym1(0,2) = 7;
488 sym1(1,1) = 2;
489 sym1(2,2) = 3;
490
491 const OST sym2( sym1 );
492
493 checkRows ( sym2, 3UL );
494 checkColumns ( sym2, 3UL );
495 checkCapacity( sym2, 7UL );
496 checkNonZeros( sym2, 7UL );
497
498 if( sym2(0,0) != 1 || sym2(0,1) != -4 || sym2(0,2) != 7 ||
499 sym2(1,0) != -4 || sym2(1,1) != 2 || sym2(1,2) != 0 ||
500 sym2(2,0) != 7 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
501 std::ostringstream oss;
502 oss << " Test: " << test_ << "\n"
503 << " Error: Construction failed\n"
504 << " Details:\n"
505 << " Result:\n" << sym2 << "\n"
506 << " Expected result:\n( 1 -4 7 )\n( -4 2 0 )\n( 7 0 3 )\n";
507 throw std::runtime_error( oss.str() );
508 }
509 }
510
511
512 //=====================================================================================
513 // Column-major move constructor
514 //=====================================================================================
515
516 // Move constructor (0x0)
517 {
518 test_ = "Column-major SymmetricMatrix move constructor (0x0)";
519
520 OST sym1;
521 OST sym2( std::move( sym1 ) );
522
523 checkRows ( sym2, 0UL );
524 checkColumns ( sym2, 0UL );
525 checkNonZeros( sym2, 0UL );
526 }
527
528 // Move constructor (3x3)
529 {
530 test_ = "Column-major SymmetricMatrix move constructor (3x3)";
531
532 OST sym1( 3UL );
533 sym1(0,0) = 1;
534 sym1(0,1) = -4;
535 sym1(0,2) = 7;
536 sym1(1,1) = 2;
537 sym1(2,2) = 3;
538
539 OST sym2( std::move( sym1 ) );
540
541 checkRows ( sym2, 3UL );
542 checkColumns ( sym2, 3UL );
543 checkCapacity( sym2, 7UL );
544 checkNonZeros( sym2, 7UL );
545
546 if( sym2(0,0) != 1 || sym2(0,1) != -4 || sym2(0,2) != 7 ||
547 sym2(1,0) != -4 || sym2(1,1) != 2 || sym2(1,2) != 0 ||
548 sym2(2,0) != 7 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
549 std::ostringstream oss;
550 oss << " Test: " << test_ << "\n"
551 << " Error: Construction failed\n"
552 << " Details:\n"
553 << " Result:\n" << sym2 << "\n"
554 << " Expected result:\n( 1 -4 7 )\n( -4 2 0 )\n( 7 0 3 )\n";
555 throw std::runtime_error( oss.str() );
556 }
557 }
558
559
560 //=====================================================================================
561 // Column-major conversion constructor
562 //=====================================================================================
563
564 // Conversion constructor (0x0)
565 {
566 test_ = "Column-major SymmetricMatrix conversion constructor (0x0)";
567
568 const blaze::DynamicMatrix<int,blaze::columnMajor> mat;
569 const OST sym( mat );
570
571 checkRows ( sym, 0UL );
572 checkColumns ( sym, 0UL );
573 checkNonZeros( sym, 0UL );
574 }
575
576 // Conversion constructor (symmetric)
577 {
578 test_ = "Column-major SymmetricMatrix conversion constructor (symmetric)";
579
580 const blaze::StaticMatrix<int,3UL,3UL,blaze::columnMajor> mat( { { 1, -4, 7 },
581 { -4, 2, 0 },
582 { 7, 0, 3 } } );
583
584 const OST sym( mat );
585
586 checkRows ( sym, 3UL );
587 checkColumns ( sym, 3UL );
588 checkCapacity( sym, 7UL );
589 checkNonZeros( sym, 7UL );
590
591 if( sym(0,0) != 1 || sym(0,1) != -4 || sym(0,2) != 7 ||
592 sym(1,0) != -4 || sym(1,1) != 2 || sym(1,2) != 0 ||
593 sym(2,0) != 7 || sym(2,1) != 0 || sym(2,2) != 3 ) {
594 std::ostringstream oss;
595 oss << " Test: " << test_ << "\n"
596 << " Error: Construction failed\n"
597 << " Details:\n"
598 << " Result:\n" << sym << "\n"
599 << " Expected result:\n( 1 -4 7 )\n( -4 2 0 )\n( 7 0 3 )\n";
600 throw std::runtime_error( oss.str() );
601 }
602 }
603
604 // Conversion constructor (non-symmetric)
605 {
606 test_ = "Column-major SymmetricMatrix conversion constructor (non-symmetric)";
607
608 const blaze::StaticMatrix<int,3UL,3UL,blaze::columnMajor> mat( { { 1, -4, 7 },
609 { -4, 2, 0 },
610 { -5, 0, 3 } } );
611
612 try {
613 const OST sym( mat );
614
615 std::ostringstream oss;
616 oss << " Test: " << test_ << "\n"
617 << " Error: Setup of non-symmetric SymmetricMatrix succeeded\n"
618 << " Details:\n"
619 << " Result:\n" << sym << "\n";
620 throw std::runtime_error( oss.str() );
621 }
622 catch( std::invalid_argument& ) {}
623 }
624
625 // Conversion constructor (SymmetricMatrix)
626 {
627 test_ = "Column-major SymmetricMatrix conversion constructor (SymmetricMatrix)";
628
629 blaze::SymmetricMatrix< blaze::StaticMatrix<int,3UL,3UL,blaze::columnMajor> > sym1;
630 sym1(0,0) = 1;
631 sym1(0,1) = -4;
632 sym1(0,2) = 7;
633 sym1(1,1) = 2;
634 sym1(2,2) = 3;
635
636 const OST sym2( sym1 );
637
638 checkRows ( sym2, 3UL );
639 checkColumns ( sym2, 3UL );
640 checkCapacity( sym2, 7UL );
641 checkNonZeros( sym2, 7UL );
642
643 if( sym2(0,0) != 1 || sym2(0,1) != -4 || sym2(0,2) != 7 ||
644 sym2(1,0) != -4 || sym2(1,1) != 2 || sym2(1,2) != 0 ||
645 sym2(2,0) != 7 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
646 std::ostringstream oss;
647 oss << " Test: " << test_ << "\n"
648 << " Error: Construction failed\n"
649 << " Details:\n"
650 << " Result:\n" << sym2 << "\n"
651 << " Expected result:\n( 1 -4 7 )\n( -4 2 0 )\n( 7 0 3 )\n";
652 throw std::runtime_error( oss.str() );
653 }
654 }
655 }
656 //*************************************************************************************************
657
658
659 //*************************************************************************************************
660 /*!\brief Test of the SymmetricMatrix assignment operators.
661 //
662 // \return void
663 // \exception std::runtime_error Error detected.
664 //
665 // This function performs a test of all assignment operators of the SymmetricMatrix specialization.
666 // In case an error is detected, a \a std::runtime_error exception is thrown.
667 */
testAssignment()668 void SparseScalarTest::testAssignment()
669 {
670 //=====================================================================================
671 // Row-major list assignment
672 //=====================================================================================
673
674 // Complete initializer list
675 {
676 test_ = "Row-major SymmetricMatrix initializer list assignment";
677
678 ST sym;
679 sym = { { 1, 2, 3 }, { 2, 4, 0 }, { 3, 0, 6 } };
680
681 checkRows ( sym, 3UL );
682 checkColumns ( sym, 3UL );
683 checkNonZeros( sym, 7UL );
684
685 if( sym(0,0) != 1 || sym(0,1) != 2 || sym(0,2) != 3 ||
686 sym(1,0) != 2 || sym(1,1) != 4 || sym(1,2) != 0 ||
687 sym(2,0) != 3 || sym(2,1) != 0 || sym(2,2) != 6 ) {
688 std::ostringstream oss;
689 oss << " Test: " << test_ << "\n"
690 << " Error: Assignment failed\n"
691 << " Details:\n"
692 << " Result:\n" << sym << "\n"
693 << " Expected result:\n( 1 2 3 )\n( 2 4 0 )\n( 3 0 6 )\n";
694 throw std::runtime_error( oss.str() );
695 }
696 }
697
698 // Incomplete initializer list
699 {
700 test_ = "Row-major SymmetricMatrix initializer list assignment";
701
702 ST sym;
703 sym = { { 1, 2, 3 }, { 2, 4 }, { 3, 0, 6 } };
704
705 checkRows ( sym, 3UL );
706 checkColumns ( sym, 3UL );
707 checkNonZeros( sym, 7UL );
708
709 if( sym(0,0) != 1 || sym(0,1) != 2 || sym(0,2) != 3 ||
710 sym(1,0) != 2 || sym(1,1) != 4 || sym(1,2) != 0 ||
711 sym(2,0) != 3 || sym(2,1) != 0 || sym(2,2) != 6 ) {
712 std::ostringstream oss;
713 oss << " Test: " << test_ << "\n"
714 << " Error: Assignment failed\n"
715 << " Details:\n"
716 << " Result:\n" << sym << "\n"
717 << " Expected result:\n( 1 2 3 )\n( 2 4 0 )\n( 3 0 6 )\n";
718 throw std::runtime_error( oss.str() );
719 }
720 }
721
722
723 //=====================================================================================
724 // Row-major copy assignment
725 //=====================================================================================
726
727 // Copy assignment (0x0)
728 {
729 test_ = "Row-major SymmetricMatrix copy assignment (0x0)";
730
731 ST sym1, sym2;
732
733 sym2 = sym1;
734
735 checkRows ( sym2, 0UL );
736 checkColumns ( sym2, 0UL );
737 checkNonZeros( sym2, 0UL );
738 }
739
740 // Copy assignment (3x3)
741 {
742 test_ = "Row-major SymmetricMatrix copy assignment (3x3)";
743
744 ST sym1( 3UL );
745 sym1(0,0) = 1;
746 sym1(0,1) = -4;
747 sym1(0,2) = 7;
748 sym1(1,1) = 2;
749 sym1(2,2) = 3;
750
751 ST sym2;
752 sym2 = sym1;
753
754 checkRows ( sym2, 3UL );
755 checkColumns ( sym2, 3UL );
756 checkNonZeros( sym2, 7UL );
757
758 if( sym2(0,0) != 1 || sym2(0,1) != -4 || sym2(0,2) != 7 ||
759 sym2(1,0) != -4 || sym2(1,1) != 2 || sym2(1,2) != 0 ||
760 sym2(2,0) != 7 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
761 std::ostringstream oss;
762 oss << " Test: " << test_ << "\n"
763 << " Error: Construction failed\n"
764 << " Details:\n"
765 << " Result:\n" << sym2 << "\n"
766 << " Expected result:\n( 1 -4 7 )\n( -4 2 0 )\n( 7 0 3 )\n";
767 throw std::runtime_error( oss.str() );
768 }
769 }
770
771
772 //=====================================================================================
773 // Row-major move assignment
774 //=====================================================================================
775
776 // Move assignment (0x0)
777 {
778 test_ = "Row-major SymmetricMatrix move assignment (0x0)";
779
780 ST sym1, sym2;
781
782 sym2 = std::move( sym1 );
783
784 checkRows ( sym2, 0UL );
785 checkColumns ( sym2, 0UL );
786 checkNonZeros( sym2, 0UL );
787 }
788
789 // Move assignment (3x3)
790 {
791 test_ = "Row-major SymmetricMatrix move assignment (3x3)";
792
793 ST sym1( 3UL );
794 sym1(0,0) = 1;
795 sym1(0,1) = -4;
796 sym1(0,2) = 7;
797 sym1(1,1) = 2;
798 sym1(2,2) = 3;
799
800 ST sym2;
801 sym2 = std::move( sym1 );
802
803 checkRows ( sym2, 3UL );
804 checkColumns ( sym2, 3UL );
805 checkNonZeros( sym2, 7UL );
806
807 if( sym2(0,0) != 1 || sym2(0,1) != -4 || sym2(0,2) != 7 ||
808 sym2(1,0) != -4 || sym2(1,1) != 2 || sym2(1,2) != 0 ||
809 sym2(2,0) != 7 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
810 std::ostringstream oss;
811 oss << " Test: " << test_ << "\n"
812 << " Error: Construction failed\n"
813 << " Details:\n"
814 << " Result:\n" << sym2 << "\n"
815 << " Expected result:\n( 1 -4 7 )\n( -4 2 0 )\n( 7 0 3 )\n";
816 throw std::runtime_error( oss.str() );
817 }
818 }
819
820
821 //=====================================================================================
822 // Row-major dense matrix assignment
823 //=====================================================================================
824
825 // Conversion assignment (0x0)
826 {
827 test_ = "Row-major SymmetricMatrix dense matrix assignment (0x0)";
828
829 const blaze::DynamicMatrix<int,blaze::rowMajor> mat;
830
831 ST sym;
832 sym = mat;
833
834 checkRows ( sym, 0UL );
835 checkColumns ( sym, 0UL );
836 checkNonZeros( sym, 0UL );
837 }
838
839 // Row-major/row-major dense matrix assignment (symmetric)
840 {
841 test_ = "Row-major/row-major SymmetricMatrix dense matrix assignment (symmetric)";
842
843 const blaze::StaticMatrix<int,3UL,3UL,blaze::rowMajor> mat( { { 1, -4, 7 },
844 { -4, 2, 0 },
845 { 7, 0, 3 } } );
846
847 ST sym;
848 sym = mat;
849
850 checkRows ( sym, 3UL );
851 checkColumns ( sym, 3UL );
852 checkNonZeros( sym, 7UL );
853
854 if( sym(0,0) != 1 || sym(0,1) != -4 || sym(0,2) != 7 ||
855 sym(1,0) != -4 || sym(1,1) != 2 || sym(1,2) != 0 ||
856 sym(2,0) != 7 || sym(2,1) != 0 || sym(2,2) != 3 ) {
857 std::ostringstream oss;
858 oss << " Test: " << test_ << "\n"
859 << " Error: Construction failed\n"
860 << " Details:\n"
861 << " Result:\n" << sym << "\n"
862 << " Expected result:\n( 1 -4 7 )\n( -4 2 0 )\n( 7 0 3 )\n";
863 throw std::runtime_error( oss.str() );
864 }
865 }
866
867 // Row-major/column-major dense matrix assignment (symmetric)
868 {
869 test_ = "Row-major/column-major SymmetricMatrix dense matrix assignment (symmetric)";
870
871 const blaze::StaticMatrix<int,3UL,3UL,blaze::columnMajor> mat( { { 1, -4, 7 },
872 { -4, 2, 0 },
873 { 7, 0, 3 } } );
874
875 ST sym;
876 sym = mat;
877
878 checkRows ( sym, 3UL );
879 checkColumns ( sym, 3UL );
880 checkNonZeros( sym, 7UL );
881
882 if( sym(0,0) != 1 || sym(0,1) != -4 || sym(0,2) != 7 ||
883 sym(1,0) != -4 || sym(1,1) != 2 || sym(1,2) != 0 ||
884 sym(2,0) != 7 || sym(2,1) != 0 || sym(2,2) != 3 ) {
885 std::ostringstream oss;
886 oss << " Test: " << test_ << "\n"
887 << " Error: Construction failed\n"
888 << " Details:\n"
889 << " Result:\n" << sym << "\n"
890 << " Expected result:\n( 1 -4 7 )\n( -4 2 0 )\n( 7 0 3 )\n";
891 throw std::runtime_error( oss.str() );
892 }
893 }
894
895 // Row-major/row-major dense matrix assignment (non-symmetric)
896 {
897 test_ = "Row-major/row-major SymmetricMatrix dense matrix assignment (non-symmetric)";
898
899 const blaze::StaticMatrix<int,3UL,3UL,blaze::rowMajor> mat( { { 1, -4, 7 },
900 { -4, 2, 0 },
901 { -5, 0, 3 } } );
902
903 try {
904 ST sym;
905 sym = mat;
906
907 std::ostringstream oss;
908 oss << " Test: " << test_ << "\n"
909 << " Error: Assignment of non-symmetric row-major matrix succeeded\n"
910 << " Details:\n"
911 << " Result:\n" << sym << "\n";
912 throw std::runtime_error( oss.str() );
913 }
914 catch( std::invalid_argument& ) {}
915 }
916
917 // Row-major/column-major dense matrix assignment (non-symmetric)
918 {
919 test_ = "Row-major/column-major SymmetricMatrix dense matrix assignment (non-symmetric)";
920
921 const blaze::StaticMatrix<int,3UL,3UL,blaze::columnMajor> mat( { { 1, -4, 7 },
922 { -4, 2, 0 },
923 { -5, 0, 3 } } );
924
925 try {
926 ST sym;
927 sym = mat;
928
929 std::ostringstream oss;
930 oss << " Test: " << test_ << "\n"
931 << " Error: Assignment of non-symmetric column-major matrix succeeded\n"
932 << " Details:\n"
933 << " Result:\n" << sym << "\n";
934 throw std::runtime_error( oss.str() );
935 }
936 catch( std::invalid_argument& ) {}
937 }
938
939 // Row-major/row-major dense matrix assignment (SymmetricMatrix)
940 {
941 test_ = "Row-major/row-major SymmetricMatrix dense matrix assignment (SymmetricMatrix)";
942
943 blaze::SymmetricMatrix< blaze::StaticMatrix<int,3UL,3UL,blaze::rowMajor> > sym1;
944 sym1(0,0) = 1;
945 sym1(0,1) = -4;
946 sym1(0,2) = 7;
947 sym1(1,1) = 2;
948 sym1(2,2) = 3;
949
950 ST sym2;
951 sym2 = sym1;
952
953 checkRows ( sym2, 3UL );
954 checkColumns ( sym2, 3UL );
955 checkNonZeros( sym2, 7UL );
956
957 if( sym2(0,0) != 1 || sym2(0,1) != -4 || sym2(0,2) != 7 ||
958 sym2(1,0) != -4 || sym2(1,1) != 2 || sym2(1,2) != 0 ||
959 sym2(2,0) != 7 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
960 std::ostringstream oss;
961 oss << " Test: " << test_ << "\n"
962 << " Error: Construction failed\n"
963 << " Details:\n"
964 << " Result:\n" << sym2 << "\n"
965 << " Expected result:\n( 1 -4 7 )\n( -4 2 0 )\n( 7 0 3 )\n";
966 throw std::runtime_error( oss.str() );
967 }
968 }
969
970 // Row-major/column-major dense matrix assignment (SymmetricMatrix)
971 {
972 test_ = "Row-major/column-major SymmetricMatrix dense matrix assignment (SymmetricMatrix)";
973
974 blaze::SymmetricMatrix< blaze::StaticMatrix<int,3UL,3UL,blaze::columnMajor> > sym1;
975 sym1(0,0) = 1;
976 sym1(0,1) = -4;
977 sym1(0,2) = 7;
978 sym1(1,1) = 2;
979 sym1(2,2) = 3;
980
981 ST sym2;
982 sym2 = sym1;
983
984 checkRows ( sym2, 3UL );
985 checkColumns ( sym2, 3UL );
986 checkNonZeros( sym2, 7UL );
987
988 if( sym2(0,0) != 1 || sym2(0,1) != -4 || sym2(0,2) != 7 ||
989 sym2(1,0) != -4 || sym2(1,1) != 2 || sym2(1,2) != 0 ||
990 sym2(2,0) != 7 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
991 std::ostringstream oss;
992 oss << " Test: " << test_ << "\n"
993 << " Error: Construction failed\n"
994 << " Details:\n"
995 << " Result:\n" << sym2 << "\n"
996 << " Expected result:\n( 1 -4 7 )\n( -4 2 0 )\n( 7 0 3 )\n";
997 throw std::runtime_error( oss.str() );
998 }
999 }
1000
1001
1002 //=====================================================================================
1003 // Row-major sparse matrix assignment
1004 //=====================================================================================
1005
1006 // Conversion assignment (0x0)
1007 {
1008 test_ = "Row-major SymmetricMatrix sparse matrix assignment (0x0)";
1009
1010 const blaze::CompressedMatrix<int,blaze::rowMajor> mat;
1011
1012 ST sym;
1013 sym = mat;
1014
1015 checkRows ( sym, 0UL );
1016 checkColumns ( sym, 0UL );
1017 checkNonZeros( sym, 0UL );
1018 }
1019
1020 // Row-major/row-major sparse matrix assignment (symmetric)
1021 {
1022 test_ = "Row-major/row-major SymmetricMatrix sparse matrix assignment (symmetric)";
1023
1024 blaze::CompressedMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 8UL );
1025 mat(0,0) = 1;
1026 mat(0,1) = -4;
1027 mat(0,2) = 7;
1028 mat(1,0) = -4;
1029 mat(1,1) = 2;
1030 mat(2,0) = 7;
1031 mat(2,2) = 3;
1032 mat.insert( 1UL, 2UL, 0 );
1033
1034 ST sym;
1035 sym = mat;
1036
1037 checkRows ( sym, 3UL );
1038 checkColumns ( sym, 3UL );
1039 checkNonZeros( sym, 8UL );
1040
1041 if( sym(0,0) != 1 || sym(0,1) != -4 || sym(0,2) != 7 ||
1042 sym(1,0) != -4 || sym(1,1) != 2 || sym(1,2) != 0 ||
1043 sym(2,0) != 7 || sym(2,1) != 0 || sym(2,2) != 3 ) {
1044 std::ostringstream oss;
1045 oss << " Test: " << test_ << "\n"
1046 << " Error: Construction failed\n"
1047 << " Details:\n"
1048 << " Result:\n" << sym << "\n"
1049 << " Expected result:\n( 1 -4 7 )\n( -4 2 0 )\n( 7 0 3 )\n";
1050 throw std::runtime_error( oss.str() );
1051 }
1052 }
1053
1054 // Row-major/column-major sparse matrix assignment (symmetric)
1055 {
1056 test_ = "Row-major/column-major SymmetricMatrix sparse matrix assignment (symmetric)";
1057
1058 blaze::CompressedMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 8UL );
1059 mat(0,0) = 1;
1060 mat(0,1) = -4;
1061 mat(0,2) = 7;
1062 mat(1,0) = -4;
1063 mat(1,1) = 2;
1064 mat(2,0) = 7;
1065 mat(2,2) = 3;
1066 mat.insert( 1UL, 2UL, 0 );
1067
1068 ST sym;
1069 sym = mat;
1070
1071 checkRows ( sym, 3UL );
1072 checkColumns ( sym, 3UL );
1073 checkNonZeros( sym, 8UL );
1074
1075 if( sym(0,0) != 1 || sym(0,1) != -4 || sym(0,2) != 7 ||
1076 sym(1,0) != -4 || sym(1,1) != 2 || sym(1,2) != 0 ||
1077 sym(2,0) != 7 || sym(2,1) != 0 || sym(2,2) != 3 ) {
1078 std::ostringstream oss;
1079 oss << " Test: " << test_ << "\n"
1080 << " Error: Construction failed\n"
1081 << " Details:\n"
1082 << " Result:\n" << sym << "\n"
1083 << " Expected result:\n( 1 -4 7 )\n( -4 2 0 )\n( 7 0 3 )\n";
1084 throw std::runtime_error( oss.str() );
1085 }
1086 }
1087
1088 // Row-major/row-major sparse matrix assignment (non-symmetric)
1089 {
1090 test_ = "Row-major/row-major SymmetricMatrix sparse matrix assignment (non-symmetric)";
1091
1092 blaze::CompressedMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 7UL );
1093 mat(0,0) = 1;
1094 mat(0,1) = -4;
1095 mat(0,2) = 7;
1096 mat(1,0) = -4;
1097 mat(1,1) = 2;
1098 mat(2,0) = -5;
1099 mat(2,2) = 3;
1100
1101 try {
1102 ST sym;
1103 sym = mat;
1104
1105 std::ostringstream oss;
1106 oss << " Test: " << test_ << "\n"
1107 << " Error: Assignment of non-symmetric row-major matrix succeeded\n"
1108 << " Details:\n"
1109 << " Result:\n" << sym << "\n";
1110 throw std::runtime_error( oss.str() );
1111 }
1112 catch( std::invalid_argument& ) {}
1113 }
1114
1115 // Row-major/column-major sparse matrix assignment (non-symmetric)
1116 {
1117 test_ = "Row-major/column-major SymmetricMatrix sparse matrix assignment (non-symmetric)";
1118
1119 blaze::CompressedMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 7UL );
1120 mat(0,0) = 1;
1121 mat(0,1) = -4;
1122 mat(0,2) = 7;
1123 mat(1,0) = -4;
1124 mat(1,1) = 2;
1125 mat(2,0) = -5;
1126 mat(2,2) = 3;
1127
1128 try {
1129 ST sym;
1130 sym = mat;
1131
1132 std::ostringstream oss;
1133 oss << " Test: " << test_ << "\n"
1134 << " Error: Assignment of non-symmetric column-major matrix succeeded\n"
1135 << " Details:\n"
1136 << " Result:\n" << sym << "\n";
1137 throw std::runtime_error( oss.str() );
1138 }
1139 catch( std::invalid_argument& ) {}
1140 }
1141
1142 // Row-major/row-major sparse matrix assignment (SymmetricMatrix)
1143 {
1144 test_ = "Row-major/row-major SymmetricMatrix sparse matrix assignment (SymmetricMatrix)";
1145
1146 blaze::SymmetricMatrix< blaze::CompressedMatrix<int,blaze::rowMajor> > sym1( 3UL, 7UL );
1147 sym1(0,0) = 1;
1148 sym1(0,1) = -4;
1149 sym1(0,2) = 7;
1150 sym1(1,1) = 2;
1151 sym1(2,2) = 3;
1152
1153 ST sym2;
1154 sym2 = sym1;
1155
1156 checkRows ( sym2, 3UL );
1157 checkColumns ( sym2, 3UL );
1158 checkNonZeros( sym2, 7UL );
1159
1160 if( sym2(0,0) != 1 || sym2(0,1) != -4 || sym2(0,2) != 7 ||
1161 sym2(1,0) != -4 || sym2(1,1) != 2 || sym2(1,2) != 0 ||
1162 sym2(2,0) != 7 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
1163 std::ostringstream oss;
1164 oss << " Test: " << test_ << "\n"
1165 << " Error: Construction failed\n"
1166 << " Details:\n"
1167 << " Result:\n" << sym2 << "\n"
1168 << " Expected result:\n( 1 -4 7 )\n( -4 2 0 )\n( 7 0 3 )\n";
1169 throw std::runtime_error( oss.str() );
1170 }
1171 }
1172
1173 // Row-major/column-major sparse matrix assignment (SymmetricMatrix)
1174 {
1175 test_ = "Row-major/column-major SymmetricMatrix sparse matrix assignment (SymmetricMatrix)";
1176
1177 blaze::SymmetricMatrix< blaze::CompressedMatrix<int,blaze::columnMajor> > sym1( 3UL, 7UL );
1178 sym1(0,0) = 1;
1179 sym1(0,1) = -4;
1180 sym1(0,2) = 7;
1181 sym1(1,1) = 2;
1182 sym1(2,2) = 3;
1183
1184 ST sym2;
1185 sym2 = sym1;
1186
1187 checkRows ( sym2, 3UL );
1188 checkColumns ( sym2, 3UL );
1189 checkNonZeros( sym2, 7UL );
1190
1191 if( sym2(0,0) != 1 || sym2(0,1) != -4 || sym2(0,2) != 7 ||
1192 sym2(1,0) != -4 || sym2(1,1) != 2 || sym2(1,2) != 0 ||
1193 sym2(2,0) != 7 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
1194 std::ostringstream oss;
1195 oss << " Test: " << test_ << "\n"
1196 << " Error: Construction failed\n"
1197 << " Details:\n"
1198 << " Result:\n" << sym2 << "\n"
1199 << " Expected result:\n( 1 -4 7 )\n( -4 2 0 )\n( 7 0 3 )\n";
1200 throw std::runtime_error( oss.str() );
1201 }
1202 }
1203
1204
1205 //=====================================================================================
1206 // Column-major list assignment
1207 //=====================================================================================
1208
1209 // Complete initializer list
1210 {
1211 test_ = "Column-major SymmetricMatrix initializer list assignment";
1212
1213 OST sym;
1214 sym = { { 1, 2, 3 }, { 2, 4, 0 }, { 3, 0, 6 } };
1215
1216 checkRows ( sym, 3UL );
1217 checkColumns ( sym, 3UL );
1218 checkNonZeros( sym, 7UL );
1219
1220 if( sym(0,0) != 1 || sym(0,1) != 2 || sym(0,2) != 3 ||
1221 sym(1,0) != 2 || sym(1,1) != 4 || sym(1,2) != 0 ||
1222 sym(2,0) != 3 || sym(2,1) != 0 || sym(2,2) != 6 ) {
1223 std::ostringstream oss;
1224 oss << " Test: " << test_ << "\n"
1225 << " Error: Assignment failed\n"
1226 << " Details:\n"
1227 << " Result:\n" << sym << "\n"
1228 << " Expected result:\n( 1 2 3 )\n( 2 4 0 )\n( 3 0 6 )\n";
1229 throw std::runtime_error( oss.str() );
1230 }
1231 }
1232
1233 // Incomplete initializer list
1234 {
1235 test_ = "Column-major SymmetricMatrix initializer list assignment";
1236
1237 OST sym;
1238 sym = { { 1, 2, 3 }, { 2, 4 }, { 3, 0, 6 } };
1239
1240 checkRows ( sym, 3UL );
1241 checkColumns ( sym, 3UL );
1242 checkNonZeros( sym, 7UL );
1243
1244 if( sym(0,0) != 1 || sym(0,1) != 2 || sym(0,2) != 3 ||
1245 sym(1,0) != 2 || sym(1,1) != 4 || sym(1,2) != 0 ||
1246 sym(2,0) != 3 || sym(2,1) != 0 || sym(2,2) != 6 ) {
1247 std::ostringstream oss;
1248 oss << " Test: " << test_ << "\n"
1249 << " Error: Assignment failed\n"
1250 << " Details:\n"
1251 << " Result:\n" << sym << "\n"
1252 << " Expected result:\n( 1 2 3 )\n( 2 4 0 )\n( 3 0 6 )\n";
1253 throw std::runtime_error( oss.str() );
1254 }
1255 }
1256
1257
1258 //=====================================================================================
1259 // Column-major copy assignment
1260 //=====================================================================================
1261
1262 // Copy assignment (0x0)
1263 {
1264 test_ = "Column-major SymmetricMatrix copy assignment (0x0)";
1265
1266 OST sym1, sym2;
1267
1268 sym2 = sym1;
1269
1270 checkRows ( sym2, 0UL );
1271 checkColumns ( sym2, 0UL );
1272 checkNonZeros( sym2, 0UL );
1273 }
1274
1275 // Copy assignment (3x3)
1276 {
1277 test_ = "Column-major SymmetricMatrix copy assignment (3x3)";
1278
1279 OST sym1( 3UL );
1280 sym1(0,0) = 1;
1281 sym1(0,1) = -4;
1282 sym1(0,2) = 7;
1283 sym1(1,1) = 2;
1284 sym1(2,2) = 3;
1285
1286 OST sym2;
1287 sym2 = sym1;
1288
1289 checkRows ( sym2, 3UL );
1290 checkColumns ( sym2, 3UL );
1291 checkNonZeros( sym2, 7UL );
1292
1293 if( sym2(0,0) != 1 || sym2(0,1) != -4 || sym2(0,2) != 7 ||
1294 sym2(1,0) != -4 || sym2(1,1) != 2 || sym2(1,2) != 0 ||
1295 sym2(2,0) != 7 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
1296 std::ostringstream oss;
1297 oss << " Test: " << test_ << "\n"
1298 << " Error: Construction failed\n"
1299 << " Details:\n"
1300 << " Result:\n" << sym2 << "\n"
1301 << " Expected result:\n( 1 -4 7 )\n( -4 2 0 )\n( 7 0 3 )\n";
1302 throw std::runtime_error( oss.str() );
1303 }
1304 }
1305
1306
1307 //=====================================================================================
1308 // Column-major move assignment
1309 //=====================================================================================
1310
1311 // Move assignment (0x0)
1312 {
1313 test_ = "Column-major SymmetricMatrix move assignment (0x0)";
1314
1315 OST sym1, sym2;
1316
1317 sym2 = std::move( sym1 );
1318
1319 checkRows ( sym2, 0UL );
1320 checkColumns ( sym2, 0UL );
1321 checkNonZeros( sym2, 0UL );
1322 }
1323
1324 // Move assignment (3x3)
1325 {
1326 test_ = "Column-major SymmetricMatrix move assignment (3x3)";
1327
1328 OST sym1( 3UL );
1329 sym1(0,0) = 1;
1330 sym1(0,1) = -4;
1331 sym1(0,2) = 7;
1332 sym1(1,1) = 2;
1333 sym1(2,2) = 3;
1334
1335 OST sym2;
1336 sym2 = std::move( sym1 );
1337
1338 checkRows ( sym2, 3UL );
1339 checkColumns ( sym2, 3UL );
1340 checkNonZeros( sym2, 7UL );
1341
1342 if( sym2(0,0) != 1 || sym2(0,1) != -4 || sym2(0,2) != 7 ||
1343 sym2(1,0) != -4 || sym2(1,1) != 2 || sym2(1,2) != 0 ||
1344 sym2(2,0) != 7 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
1345 std::ostringstream oss;
1346 oss << " Test: " << test_ << "\n"
1347 << " Error: Construction failed\n"
1348 << " Details:\n"
1349 << " Result:\n" << sym2 << "\n"
1350 << " Expected result:\n( 1 -4 7 )\n( -4 2 0 )\n( 7 0 3 )\n";
1351 throw std::runtime_error( oss.str() );
1352 }
1353 }
1354
1355
1356 //=====================================================================================
1357 // Column-major dense matrix assignment
1358 //=====================================================================================
1359
1360 // Conversion assignment (0x0)
1361 {
1362 test_ = "Column-major SymmetricMatrix dense matrix assignment (0x0)";
1363
1364 const blaze::DynamicMatrix<int,blaze::columnMajor> mat;
1365
1366 OST sym;
1367 sym = mat;
1368
1369 checkRows ( sym, 0UL );
1370 checkColumns ( sym, 0UL );
1371 checkNonZeros( sym, 0UL );
1372 }
1373
1374 // Column-major/row-major dense matrix assignment (symmetric)
1375 {
1376 test_ = "Column-major/row-major SymmetricMatrix dense matrix assignment (symmetric)";
1377
1378 const blaze::StaticMatrix<int,3UL,3UL,blaze::rowMajor> mat( { { 1, -4, 7 },
1379 { -4, 2, 0 },
1380 { 7, 0, 3 } } );
1381
1382 OST sym;
1383 sym = mat;
1384
1385 checkRows ( sym, 3UL );
1386 checkColumns ( sym, 3UL );
1387 checkNonZeros( sym, 7UL );
1388
1389 if( sym(0,0) != 1 || sym(0,1) != -4 || sym(0,2) != 7 ||
1390 sym(1,0) != -4 || sym(1,1) != 2 || sym(1,2) != 0 ||
1391 sym(2,0) != 7 || sym(2,1) != 0 || sym(2,2) != 3 ) {
1392 std::ostringstream oss;
1393 oss << " Test: " << test_ << "\n"
1394 << " Error: Construction failed\n"
1395 << " Details:\n"
1396 << " Result:\n" << sym << "\n"
1397 << " Expected result:\n( 1 -4 7 )\n( -4 2 0 )\n( 7 0 3 )\n";
1398 throw std::runtime_error( oss.str() );
1399 }
1400 }
1401
1402 // Column-major/column-major dense matrix assignment (symmetric)
1403 {
1404 test_ = "Column-major/column-major SymmetricMatrix dense matrix assignment (symmetric)";
1405
1406 const blaze::StaticMatrix<int,3UL,3UL,blaze::columnMajor> mat( { { 1, -4, 7 },
1407 { -4, 2, 0 },
1408 { 7, 0, 3 } } );
1409
1410 OST sym;
1411 sym = mat;
1412
1413 checkRows ( sym, 3UL );
1414 checkColumns ( sym, 3UL );
1415 checkNonZeros( sym, 7UL );
1416
1417 if( sym(0,0) != 1 || sym(0,1) != -4 || sym(0,2) != 7 ||
1418 sym(1,0) != -4 || sym(1,1) != 2 || sym(1,2) != 0 ||
1419 sym(2,0) != 7 || sym(2,1) != 0 || sym(2,2) != 3 ) {
1420 std::ostringstream oss;
1421 oss << " Test: " << test_ << "\n"
1422 << " Error: Construction failed\n"
1423 << " Details:\n"
1424 << " Result:\n" << sym << "\n"
1425 << " Expected result:\n( 1 -4 7 )\n( -4 2 0 )\n( 7 0 3 )\n";
1426 throw std::runtime_error( oss.str() );
1427 }
1428 }
1429
1430 // Column-major/row-major dense matrix assignment (non-symmetric)
1431 {
1432 test_ = "Column-major/row-major SymmetricMatrix dense matrix assignment (non-symmetric)";
1433
1434 const blaze::StaticMatrix<int,3UL,3UL,blaze::rowMajor> mat( { { 1, -4, 7 },
1435 { -4, 2, 0 },
1436 { -5, 0, 3 } } );
1437
1438 try {
1439 OST sym;
1440 sym = mat;
1441
1442 std::ostringstream oss;
1443 oss << " Test: " << test_ << "\n"
1444 << " Error: Assignment of non-symmetric row-major matrix succeeded\n"
1445 << " Details:\n"
1446 << " Result:\n" << sym << "\n";
1447 throw std::runtime_error( oss.str() );
1448 }
1449 catch( std::invalid_argument& ) {}
1450 }
1451
1452 // Column-major/column-major dense matrix assignment (non-symmetric)
1453 {
1454 test_ = "Column-major/column-major SymmetricMatrix dense matrix assignment (non-symmetric)";
1455
1456 const blaze::StaticMatrix<int,3UL,3UL,blaze::columnMajor> mat( { { 1, -4, 7 },
1457 { -4, 2, 0 },
1458 { -5, 0, 3 } } );
1459
1460 try {
1461 OST sym;
1462 sym = mat;
1463
1464 std::ostringstream oss;
1465 oss << " Test: " << test_ << "\n"
1466 << " Error: Assignment of non-symmetric column-major matrix succeeded\n"
1467 << " Details:\n"
1468 << " Result:\n" << sym << "\n";
1469 throw std::runtime_error( oss.str() );
1470 }
1471 catch( std::invalid_argument& ) {}
1472 }
1473
1474 // Column-major/row-major dense matrix assignment (SymmetricMatrix)
1475 {
1476 test_ = "Column-major/row-major SymmetricMatrix dense matrix assignment (SymmetricMatrix)";
1477
1478 blaze::SymmetricMatrix< blaze::StaticMatrix<int,3UL,3UL,blaze::rowMajor> > sym1;
1479 sym1(0,0) = 1;
1480 sym1(0,1) = -4;
1481 sym1(0,2) = 7;
1482 sym1(1,1) = 2;
1483 sym1(2,2) = 3;
1484
1485 OST sym2;
1486 sym2 = sym1;
1487
1488 checkRows ( sym2, 3UL );
1489 checkColumns ( sym2, 3UL );
1490 checkNonZeros( sym2, 7UL );
1491
1492 if( sym2(0,0) != 1 || sym2(0,1) != -4 || sym2(0,2) != 7 ||
1493 sym2(1,0) != -4 || sym2(1,1) != 2 || sym2(1,2) != 0 ||
1494 sym2(2,0) != 7 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
1495 std::ostringstream oss;
1496 oss << " Test: " << test_ << "\n"
1497 << " Error: Construction failed\n"
1498 << " Details:\n"
1499 << " Result:\n" << sym2 << "\n"
1500 << " Expected result:\n( 1 -4 7 )\n( -4 2 0 )\n( 7 0 3 )\n";
1501 throw std::runtime_error( oss.str() );
1502 }
1503 }
1504
1505 // Column-major/column-major dense matrix assignment (SymmetricMatrix)
1506 {
1507 test_ = "Column-major/column-major SymmetricMatrix dense matrix assignment (SymmetricMatrix)";
1508
1509 blaze::SymmetricMatrix< blaze::StaticMatrix<int,3UL,3UL,blaze::columnMajor> > sym1;
1510 sym1(0,0) = 1;
1511 sym1(0,1) = -4;
1512 sym1(0,2) = 7;
1513 sym1(1,1) = 2;
1514 sym1(2,2) = 3;
1515
1516 OST sym2;
1517 sym2 = sym1;
1518
1519 checkRows ( sym2, 3UL );
1520 checkColumns ( sym2, 3UL );
1521 checkNonZeros( sym2, 7UL );
1522
1523 if( sym2(0,0) != 1 || sym2(0,1) != -4 || sym2(0,2) != 7 ||
1524 sym2(1,0) != -4 || sym2(1,1) != 2 || sym2(1,2) != 0 ||
1525 sym2(2,0) != 7 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
1526 std::ostringstream oss;
1527 oss << " Test: " << test_ << "\n"
1528 << " Error: Construction failed\n"
1529 << " Details:\n"
1530 << " Result:\n" << sym2 << "\n"
1531 << " Expected result:\n( 1 -4 7 )\n( -4 2 0 )\n( 7 0 3 )\n";
1532 throw std::runtime_error( oss.str() );
1533 }
1534 }
1535
1536
1537 //=====================================================================================
1538 // Column-major sparse matrix assignment
1539 //=====================================================================================
1540
1541 // Conversion assignment (0x0)
1542 {
1543 test_ = "Column-major SymmetricMatrix sparse matrix assignment (0x0)";
1544
1545 const blaze::CompressedMatrix<int,blaze::columnMajor> mat;
1546
1547 OST sym;
1548 sym = mat;
1549
1550 checkRows ( sym, 0UL );
1551 checkColumns ( sym, 0UL );
1552 checkNonZeros( sym, 0UL );
1553 }
1554
1555 // Column-major/row-major sparse matrix assignment (symmetric)
1556 {
1557 test_ = "Column-major/row-major SymmetricMatrix sparse matrix assignment (symmetric)";
1558
1559 blaze::CompressedMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 8UL );
1560 mat(0,0) = 1;
1561 mat(0,1) = -4;
1562 mat(0,2) = 7;
1563 mat(1,0) = -4;
1564 mat(1,1) = 2;
1565 mat(2,0) = 7;
1566 mat(2,2) = 3;
1567 mat.insert( 1UL, 2UL, 0 );
1568
1569 OST sym;
1570 sym = mat;
1571
1572 checkRows ( sym, 3UL );
1573 checkColumns ( sym, 3UL );
1574 checkNonZeros( sym, 8UL );
1575
1576 if( sym(0,0) != 1 || sym(0,1) != -4 || sym(0,2) != 7 ||
1577 sym(1,0) != -4 || sym(1,1) != 2 || sym(1,2) != 0 ||
1578 sym(2,0) != 7 || sym(2,1) != 0 || sym(2,2) != 3 ) {
1579 std::ostringstream oss;
1580 oss << " Test: " << test_ << "\n"
1581 << " Error: Construction failed\n"
1582 << " Details:\n"
1583 << " Result:\n" << sym << "\n"
1584 << " Expected result:\n( 1 -4 7 )\n( -4 2 0 )\n( 7 0 3 )\n";
1585 throw std::runtime_error( oss.str() );
1586 }
1587 }
1588
1589 // Column-major/column-major sparse matrix assignment (symmetric)
1590 {
1591 test_ = "Column-major/column-major SymmetricMatrix sparse matrix assignment (symmetric)";
1592
1593 blaze::CompressedMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 8UL );
1594 mat(0,0) = 1;
1595 mat(0,1) = -4;
1596 mat(0,2) = 7;
1597 mat(1,0) = -4;
1598 mat(1,1) = 2;
1599 mat(2,0) = 7;
1600 mat(2,2) = 3;
1601 mat.insert( 1UL, 2UL, 0 );
1602
1603 OST sym;
1604 sym = mat;
1605
1606 checkRows ( sym, 3UL );
1607 checkColumns ( sym, 3UL );
1608 checkNonZeros( sym, 8UL );
1609
1610 if( sym(0,0) != 1 || sym(0,1) != -4 || sym(0,2) != 7 ||
1611 sym(1,0) != -4 || sym(1,1) != 2 || sym(1,2) != 0 ||
1612 sym(2,0) != 7 || sym(2,1) != 0 || sym(2,2) != 3 ) {
1613 std::ostringstream oss;
1614 oss << " Test: " << test_ << "\n"
1615 << " Error: Construction failed\n"
1616 << " Details:\n"
1617 << " Result:\n" << sym << "\n"
1618 << " Expected result:\n( 1 -4 7 )\n( -4 2 0 )\n( 7 0 3 )\n";
1619 throw std::runtime_error( oss.str() );
1620 }
1621 }
1622
1623 // Column-major/row-major sparse matrix assignment (non-symmetric)
1624 {
1625 test_ = "Column-major/row-major SymmetricMatrix sparse matrix assignment (non-symmetric)";
1626
1627 blaze::CompressedMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 7UL );
1628 mat(0,0) = 1;
1629 mat(0,1) = -4;
1630 mat(0,2) = 7;
1631 mat(1,0) = -4;
1632 mat(1,1) = 2;
1633 mat(2,0) = -5;
1634 mat(2,2) = 3;
1635
1636 try {
1637 OST sym;
1638 sym = mat;
1639
1640 std::ostringstream oss;
1641 oss << " Test: " << test_ << "\n"
1642 << " Error: Assignment of non-symmetric row-major matrix succeeded\n"
1643 << " Details:\n"
1644 << " Result:\n" << sym << "\n";
1645 throw std::runtime_error( oss.str() );
1646 }
1647 catch( std::invalid_argument& ) {}
1648 }
1649
1650 // Column-major/column-major sparse matrix assignment (non-symmetric)
1651 {
1652 test_ = "Column-major/column-major SymmetricMatrix sparse matrix assignment (non-symmetric)";
1653
1654 blaze::CompressedMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 7UL );
1655 mat(0,0) = 1;
1656 mat(0,1) = -4;
1657 mat(0,2) = 7;
1658 mat(1,0) = -4;
1659 mat(1,1) = 2;
1660 mat(2,0) = -5;
1661 mat(2,2) = 3;
1662
1663 try {
1664 OST sym;
1665 sym = mat;
1666
1667 std::ostringstream oss;
1668 oss << " Test: " << test_ << "\n"
1669 << " Error: Assignment of non-symmetric column-major matrix succeeded\n"
1670 << " Details:\n"
1671 << " Result:\n" << sym << "\n";
1672 throw std::runtime_error( oss.str() );
1673 }
1674 catch( std::invalid_argument& ) {}
1675 }
1676
1677 // Column-major/row-major sparse matrix assignment (SymmetricMatrix)
1678 {
1679 test_ = "Column-major/row-major SymmetricMatrix sparse matrix assignment (SymmetricMatrix)";
1680
1681 blaze::SymmetricMatrix< blaze::CompressedMatrix<int,blaze::rowMajor> > sym1( 3UL, 7UL );
1682 sym1(0,0) = 1;
1683 sym1(0,1) = -4;
1684 sym1(0,2) = 7;
1685 sym1(1,1) = 2;
1686 sym1(2,2) = 3;
1687
1688 OST sym2;
1689 sym2 = sym1;
1690
1691 checkRows ( sym2, 3UL );
1692 checkColumns ( sym2, 3UL );
1693 checkNonZeros( sym2, 7UL );
1694
1695 if( sym2(0,0) != 1 || sym2(0,1) != -4 || sym2(0,2) != 7 ||
1696 sym2(1,0) != -4 || sym2(1,1) != 2 || sym2(1,2) != 0 ||
1697 sym2(2,0) != 7 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
1698 std::ostringstream oss;
1699 oss << " Test: " << test_ << "\n"
1700 << " Error: Construction failed\n"
1701 << " Details:\n"
1702 << " Result:\n" << sym2 << "\n"
1703 << " Expected result:\n( 1 -4 7 )\n( -4 2 0 )\n( 7 0 3 )\n";
1704 throw std::runtime_error( oss.str() );
1705 }
1706 }
1707
1708 // Column-major/column-major sparse matrix assignment (SymmetricMatrix)
1709 {
1710 test_ = "Column-major/column-major SymmetricMatrix sparse matrix assignment (SymmetricMatrix)";
1711
1712 blaze::SymmetricMatrix< blaze::CompressedMatrix<int,blaze::columnMajor> > sym1( 3UL, 7UL );
1713 sym1(0,0) = 1;
1714 sym1(0,1) = -4;
1715 sym1(0,2) = 7;
1716 sym1(1,1) = 2;
1717 sym1(2,2) = 3;
1718
1719 OST sym2;
1720 sym2 = sym1;
1721
1722 checkRows ( sym2, 3UL );
1723 checkColumns ( sym2, 3UL );
1724 checkNonZeros( sym2, 7UL );
1725
1726 if( sym2(0,0) != 1 || sym2(0,1) != -4 || sym2(0,2) != 7 ||
1727 sym2(1,0) != -4 || sym2(1,1) != 2 || sym2(1,2) != 0 ||
1728 sym2(2,0) != 7 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
1729 std::ostringstream oss;
1730 oss << " Test: " << test_ << "\n"
1731 << " Error: Construction failed\n"
1732 << " Details:\n"
1733 << " Result:\n" << sym2 << "\n"
1734 << " Expected result:\n( 1 -4 7 )\n( -4 2 0 )\n( 7 0 3 )\n";
1735 throw std::runtime_error( oss.str() );
1736 }
1737 }
1738 }
1739 //*************************************************************************************************
1740
1741
1742 //*************************************************************************************************
1743 /*!\brief Test of the SymmetricMatrix addition assignment operators.
1744 //
1745 // \return void
1746 // \exception std::runtime_error Error detected.
1747 //
1748 // This function performs a test of the addition assignment operators of the SymmetricMatrix
1749 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
1750 */
testAddAssign()1751 void SparseScalarTest::testAddAssign()
1752 {
1753 //=====================================================================================
1754 // Row-major dense matrix addition assignment
1755 //=====================================================================================
1756
1757 // Row-major/row-major dense matrix addition assignment (symmetric)
1758 {
1759 test_ = "Row-major/row-major SymmetricMatrix dense matrix addition assignment (symmetric)";
1760
1761 blaze::DynamicMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 0 );
1762 mat(0,1) = -2;
1763 mat(0,2) = 6;
1764 mat(1,0) = -2;
1765 mat(1,1) = 3;
1766 mat(2,0) = 6;
1767
1768 ST sym( 3UL );
1769 sym(0,0) = 1;
1770 sym(0,1) = -4;
1771 sym(0,2) = 7;
1772 sym(1,1) = 2;
1773 sym(2,2) = 3;
1774
1775 sym += mat;
1776
1777 checkRows ( sym, 3UL );
1778 checkColumns ( sym, 3UL );
1779 checkCapacity( sym, 7UL );
1780 checkNonZeros( sym, 7UL );
1781 checkNonZeros( sym, 0UL, 3UL );
1782 checkNonZeros( sym, 1UL, 2UL );
1783 checkNonZeros( sym, 2UL, 2UL );
1784
1785 if( sym(0,0) != 1 || sym(0,1) != -6 || sym(0,2) != 13 ||
1786 sym(1,0) != -6 || sym(1,1) != 5 || sym(1,2) != 0 ||
1787 sym(2,0) != 13 || sym(2,1) != 0 || sym(2,2) != 3 ) {
1788 std::ostringstream oss;
1789 oss << " Test: " << test_ << "\n"
1790 << " Error: Addition assignment failed\n"
1791 << " Details:\n"
1792 << " Result:\n" << sym << "\n"
1793 << " Expected result:\n( 1 -6 13 )\n( -6 5 0 )\n( 13 0 3 )\n";
1794 throw std::runtime_error( oss.str() );
1795 }
1796 }
1797
1798 // Row-major/column-major dense matrix addition assignment (symmetric)
1799 {
1800 test_ = "Row-major/column-major SymmetricMatrix dense matrix addition assignment (symmetric)";
1801
1802 blaze::DynamicMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 0 );
1803 mat(0,1) = -2;
1804 mat(0,2) = 6;
1805 mat(1,0) = -2;
1806 mat(1,1) = 3;
1807 mat(2,0) = 6;
1808
1809 ST sym( 3UL );
1810 sym(0,0) = 1;
1811 sym(0,1) = -4;
1812 sym(0,2) = 7;
1813 sym(1,1) = 2;
1814 sym(2,2) = 3;
1815
1816 sym += mat;
1817
1818 checkRows ( sym, 3UL );
1819 checkColumns ( sym, 3UL );
1820 checkCapacity( sym, 7UL );
1821 checkNonZeros( sym, 7UL );
1822 checkNonZeros( sym, 0UL, 3UL );
1823 checkNonZeros( sym, 1UL, 2UL );
1824 checkNonZeros( sym, 2UL, 2UL );
1825
1826 if( sym(0,0) != 1 || sym(0,1) != -6 || sym(0,2) != 13 ||
1827 sym(1,0) != -6 || sym(1,1) != 5 || sym(1,2) != 0 ||
1828 sym(2,0) != 13 || sym(2,1) != 0 || sym(2,2) != 3 ) {
1829 std::ostringstream oss;
1830 oss << " Test: " << test_ << "\n"
1831 << " Error: Addition assignment failed\n"
1832 << " Details:\n"
1833 << " Result:\n" << sym << "\n"
1834 << " Expected result:\n( 1 -6 13 )\n( -6 5 0 )\n( 13 0 3 )\n";
1835 throw std::runtime_error( oss.str() );
1836 }
1837 }
1838
1839 // Row-major/row-major dense matrix addition assignment (non-symmetric)
1840 {
1841 test_ = "Row-major/row-major SymmetricMatrix dense matrix addition assignment (non-symmetric)";
1842
1843 blaze::DynamicMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 0 );
1844 mat(0,1) = -2;
1845 mat(0,2) = 6;
1846 mat(1,1) = 3;
1847 mat(2,0) = 6;
1848
1849 ST sym( 3UL );
1850 sym(0,0) = 1;
1851 sym(0,1) = -4;
1852 sym(0,2) = 7;
1853 sym(1,1) = 2;
1854 sym(2,2) = 3;
1855
1856 try {
1857 sym += mat;
1858
1859 std::ostringstream oss;
1860 oss << " Test: " << test_ << "\n"
1861 << " Error: Addition assignment of non-symmetric row-major matrix succeeded\n"
1862 << " Details:\n"
1863 << " Result:\n" << sym << "\n";
1864 throw std::runtime_error( oss.str() );
1865 }
1866 catch( std::invalid_argument& ) {}
1867 }
1868
1869 // Row-major/column-major dense matrix addition assignment (non-symmetric)
1870 {
1871 test_ = "Row-major/column-major SymmetricMatrix dense matrix addition assignment (non-symmetric)";
1872
1873 blaze::DynamicMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 0 );
1874 mat(0,1) = -2;
1875 mat(0,2) = 6;
1876 mat(1,1) = 3;
1877 mat(2,0) = 6;
1878
1879 ST sym( 3UL );
1880 sym(0,0) = 1;
1881 sym(0,1) = -4;
1882 sym(0,2) = 7;
1883 sym(1,1) = 2;
1884 sym(2,2) = 3;
1885
1886 try {
1887 sym += mat;
1888
1889 std::ostringstream oss;
1890 oss << " Test: " << test_ << "\n"
1891 << " Error: Addition assignment of non-symmetric column-major matrix succeeded\n"
1892 << " Details:\n"
1893 << " Result:\n" << sym << "\n";
1894 throw std::runtime_error( oss.str() );
1895 }
1896 catch( std::invalid_argument& ) {}
1897 }
1898
1899 // Row-major/row-major dense matrix addition assignment (SymmetricMatrix)
1900 {
1901 test_ = "Row-major/row-major SymmetricMatrix dense matrix addition assignment (SymmetricMatrix)";
1902
1903 ST sym1( 3UL );
1904 sym1(0,1) = -2;
1905 sym1(0,2) = 6;
1906 sym1(1,1) = 3;
1907
1908 ST sym2( 3UL );
1909 sym2(0,0) = 1;
1910 sym2(0,1) = -4;
1911 sym2(0,2) = 7;
1912 sym2(1,1) = 2;
1913 sym2(2,2) = 3;
1914
1915 sym2 += sym1;
1916
1917 checkRows ( sym2, 3UL );
1918 checkColumns ( sym2, 3UL );
1919 checkCapacity( sym2, 7UL );
1920 checkNonZeros( sym2, 7UL );
1921 checkNonZeros( sym2, 0UL, 3UL );
1922 checkNonZeros( sym2, 1UL, 2UL );
1923 checkNonZeros( sym2, 2UL, 2UL );
1924
1925 if( sym2(0,0) != 1 || sym2(0,1) != -6 || sym2(0,2) != 13 ||
1926 sym2(1,0) != -6 || sym2(1,1) != 5 || sym2(1,2) != 0 ||
1927 sym2(2,0) != 13 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
1928 std::ostringstream oss;
1929 oss << " Test: " << test_ << "\n"
1930 << " Error: Addition assignment failed\n"
1931 << " Details:\n"
1932 << " Result:\n" << sym2 << "\n"
1933 << " Expected result:\n( 1 -6 13 )\n( -6 5 0 )\n( 13 0 3 )\n";
1934 throw std::runtime_error( oss.str() );
1935 }
1936 }
1937
1938 // Row-major/column-major dense matrix addition assignment (SymmetricMatrix)
1939 {
1940 test_ = "Row-major/column-major SymmetricMatrix dense matrix addition assignment (SymmetricMatrix)";
1941
1942 OST sym1( 3UL );
1943 sym1(0,1) = -2;
1944 sym1(0,2) = 6;
1945 sym1(1,1) = 3;
1946
1947 ST sym2( 3UL );
1948 sym2(0,0) = 1;
1949 sym2(0,1) = -4;
1950 sym2(0,2) = 7;
1951 sym2(1,1) = 2;
1952 sym2(2,2) = 3;
1953
1954 sym2 += sym1;
1955
1956 checkRows ( sym2, 3UL );
1957 checkColumns ( sym2, 3UL );
1958 checkCapacity( sym2, 7UL );
1959 checkNonZeros( sym2, 7UL );
1960 checkNonZeros( sym2, 0UL, 3UL );
1961 checkNonZeros( sym2, 1UL, 2UL );
1962 checkNonZeros( sym2, 2UL, 2UL );
1963
1964 if( sym2(0,0) != 1 || sym2(0,1) != -6 || sym2(0,2) != 13 ||
1965 sym2(1,0) != -6 || sym2(1,1) != 5 || sym2(1,2) != 0 ||
1966 sym2(2,0) != 13 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
1967 std::ostringstream oss;
1968 oss << " Test: " << test_ << "\n"
1969 << " Error: Addition assignment failed\n"
1970 << " Details:\n"
1971 << " Result:\n" << sym2 << "\n"
1972 << " Expected result:\n( 1 -6 13 )\n( -6 5 0 )\n( 13 0 3 )\n";
1973 throw std::runtime_error( oss.str() );
1974 }
1975 }
1976
1977
1978 //=====================================================================================
1979 // Row-major sparse matrix addition assignment
1980 //=====================================================================================
1981
1982 // Row-major/row-major sparse matrix addition assignment (symmetric)
1983 {
1984 test_ = "Row-major/row-major SymmetricMatrix sparse matrix addition assignment (symmetric)";
1985
1986 blaze::CompressedMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 6UL );
1987 mat(0,1) = -2;
1988 mat(0,2) = 6;
1989 mat(1,0) = -2;
1990 mat(1,1) = 3;
1991 mat(2,0) = 6;
1992 mat.insert( 1UL, 2UL, 0 );
1993
1994 ST sym( 3UL );
1995 sym(0,0) = 1;
1996 sym(0,1) = -4;
1997 sym(0,2) = 7;
1998 sym(1,1) = 2;
1999 sym(2,2) = 3;
2000
2001 sym += mat;
2002
2003 checkRows ( sym, 3UL );
2004 checkColumns ( sym, 3UL );
2005 checkCapacity( sym, 8UL );
2006 checkNonZeros( sym, 8UL );
2007 checkNonZeros( sym, 0UL, 3UL );
2008 checkNonZeros( sym, 1UL, 3UL );
2009 checkNonZeros( sym, 2UL, 2UL );
2010
2011 if( sym(0,0) != 1 || sym(0,1) != -6 || sym(0,2) != 13 ||
2012 sym(1,0) != -6 || sym(1,1) != 5 || sym(1,2) != 0 ||
2013 sym(2,0) != 13 || sym(2,1) != 0 || sym(2,2) != 3 ) {
2014 std::ostringstream oss;
2015 oss << " Test: " << test_ << "\n"
2016 << " Error: Addition assignment failed\n"
2017 << " Details:\n"
2018 << " Result:\n" << sym << "\n"
2019 << " Expected result:\n( 1 -6 13 )\n( -6 5 0 )\n( 13 0 3 )\n";
2020 throw std::runtime_error( oss.str() );
2021 }
2022 }
2023
2024 // Row-major/column-major sparse matrix addition assignment (symmetric)
2025 {
2026 test_ = "Row-major/column-major SymmetricMatrix sparse matrix addition assignment (symmetric)";
2027
2028 blaze::CompressedMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 6UL );
2029 mat(0,1) = -2;
2030 mat(0,2) = 6;
2031 mat(1,0) = -2;
2032 mat(1,1) = 3;
2033 mat(2,0) = 6;
2034 mat.insert( 1UL, 2UL, 0 );
2035
2036 ST sym( 3UL );
2037 sym(0,0) = 1;
2038 sym(0,1) = -4;
2039 sym(0,2) = 7;
2040 sym(1,1) = 2;
2041 sym(2,2) = 3;
2042
2043 sym += mat;
2044
2045 checkRows ( sym, 3UL );
2046 checkColumns ( sym, 3UL );
2047 checkCapacity( sym, 8UL );
2048 checkNonZeros( sym, 8UL );
2049 checkNonZeros( sym, 0UL, 3UL );
2050 checkNonZeros( sym, 1UL, 2UL );
2051 checkNonZeros( sym, 2UL, 3UL );
2052
2053 if( sym(0,0) != 1 || sym(0,1) != -6 || sym(0,2) != 13 ||
2054 sym(1,0) != -6 || sym(1,1) != 5 || sym(1,2) != 0 ||
2055 sym(2,0) != 13 || sym(2,1) != 0 || sym(2,2) != 3 ) {
2056 std::ostringstream oss;
2057 oss << " Test: " << test_ << "\n"
2058 << " Error: Addition assignment failed\n"
2059 << " Details:\n"
2060 << " Result:\n" << sym << "\n"
2061 << " Expected result:\n( 1 -6 13 )\n( -6 5 0 )\n( 13 0 3 )\n";
2062 throw std::runtime_error( oss.str() );
2063 }
2064 }
2065
2066 // Row-major/row-major sparse matrix addition assignment (non-symmetric)
2067 {
2068 test_ = "Row-major/row-major SymmetricMatrix sparse matrix addition assignment (non-symmetric)";
2069
2070 blaze::CompressedMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 4UL );
2071 mat(0,1) = -2;
2072 mat(0,2) = 6;
2073 mat(1,1) = 3;
2074 mat(2,0) = 6;
2075
2076 ST sym( 3UL );
2077 sym(0,0) = 1;
2078 sym(0,1) = -4;
2079 sym(0,2) = 7;
2080 sym(1,1) = 2;
2081 sym(2,2) = 3;
2082
2083 try {
2084 sym += mat;
2085
2086 std::ostringstream oss;
2087 oss << " Test: " << test_ << "\n"
2088 << " Error: Addition assignment of non-symmetric row-major matrix succeeded\n"
2089 << " Details:\n"
2090 << " Result:\n" << sym << "\n";
2091 throw std::runtime_error( oss.str() );
2092 }
2093 catch( std::invalid_argument& ) {}
2094 }
2095
2096 // Row-major/column-major sparse matrix addition assignment (non-symmetric)
2097 {
2098 test_ = "Row-major/column-major SymmetricMatrix sparse matrix addition assignment (non-symmetric)";
2099
2100 blaze::CompressedMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 4UL );
2101 mat(0,1) = -2;
2102 mat(0,2) = 6;
2103 mat(1,1) = 3;
2104 mat(2,0) = 6;
2105
2106 ST sym( 3UL );
2107 sym(0,0) = 1;
2108 sym(0,1) = -4;
2109 sym(0,2) = 7;
2110 sym(1,1) = 2;
2111 sym(2,2) = 3;
2112
2113 try {
2114 sym += mat;
2115
2116 std::ostringstream oss;
2117 oss << " Test: " << test_ << "\n"
2118 << " Error: Addition assignment of non-symmetric column-major matrix succeeded\n"
2119 << " Details:\n"
2120 << " Result:\n" << sym << "\n";
2121 throw std::runtime_error( oss.str() );
2122 }
2123 catch( std::invalid_argument& ) {}
2124 }
2125
2126 // Row-major/row-major sparse matrix addition assignment (SymmetricMatrix)
2127 {
2128 test_ = "Row-major/row-major SymmetricMatrix sparse matrix addition assignment (SymmetricMatrix)";
2129
2130 blaze::SymmetricMatrix< blaze::CompressedMatrix<int,blaze::rowMajor> > sym1( 3UL, 5UL );
2131 sym1(0,1) = -2;
2132 sym1(0,2) = 6;
2133 sym1(1,1) = 3;
2134
2135 ST sym2( 3UL );
2136 sym2(0,0) = 1;
2137 sym2(0,1) = -4;
2138 sym2(0,2) = 7;
2139 sym2(1,1) = 2;
2140 sym2(2,2) = 3;
2141
2142 sym2 += sym1;
2143
2144 checkRows ( sym2, 3UL );
2145 checkColumns ( sym2, 3UL );
2146 checkCapacity( sym2, 7UL );
2147 checkNonZeros( sym2, 7UL );
2148 checkNonZeros( sym2, 0UL, 3UL );
2149 checkNonZeros( sym2, 1UL, 2UL );
2150 checkNonZeros( sym2, 2UL, 2UL );
2151
2152 if( sym2(0,0) != 1 || sym2(0,1) != -6 || sym2(0,2) != 13 ||
2153 sym2(1,0) != -6 || sym2(1,1) != 5 || sym2(1,2) != 0 ||
2154 sym2(2,0) != 13 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
2155 std::ostringstream oss;
2156 oss << " Test: " << test_ << "\n"
2157 << " Error: Addition assignment failed\n"
2158 << " Details:\n"
2159 << " Result:\n" << sym2 << "\n"
2160 << " Expected result:\n( 1 -6 13 )\n( -6 5 0 )\n( 13 0 3 )\n";
2161 throw std::runtime_error( oss.str() );
2162 }
2163 }
2164
2165 // Row-major/column-major sparse matrix addition assignment (SymmetricMatrix)
2166 {
2167 test_ = "Row-major/column-major SymmetricMatrix sparse matrix addition assignment (SymmetricMatrix)";
2168
2169 blaze::SymmetricMatrix< blaze::CompressedMatrix<int,blaze::columnMajor> > sym1( 3UL, 5UL );
2170 sym1(0,1) = -2;
2171 sym1(0,2) = 6;
2172 sym1(1,1) = 3;
2173
2174 ST sym2( 3UL );
2175 sym2(0,0) = 1;
2176 sym2(0,1) = -4;
2177 sym2(0,2) = 7;
2178 sym2(1,1) = 2;
2179 sym2(2,2) = 3;
2180
2181 sym2 += sym1;
2182
2183 checkRows ( sym2, 3UL );
2184 checkColumns ( sym2, 3UL );
2185 checkCapacity( sym2, 7UL );
2186 checkNonZeros( sym2, 7UL );
2187 checkNonZeros( sym2, 0UL, 3UL );
2188 checkNonZeros( sym2, 1UL, 2UL );
2189 checkNonZeros( sym2, 2UL, 2UL );
2190
2191 if( sym2(0,0) != 1 || sym2(0,1) != -6 || sym2(0,2) != 13 ||
2192 sym2(1,0) != -6 || sym2(1,1) != 5 || sym2(1,2) != 0 ||
2193 sym2(2,0) != 13 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
2194 std::ostringstream oss;
2195 oss << " Test: " << test_ << "\n"
2196 << " Error: Addition assignment failed\n"
2197 << " Details:\n"
2198 << " Result:\n" << sym2 << "\n"
2199 << " Expected result:\n( 1 -6 13 )\n( -6 5 0 )\n( 13 0 3 )\n";
2200 throw std::runtime_error( oss.str() );
2201 }
2202 }
2203
2204
2205 //=====================================================================================
2206 // Column-major dense matrix addition assignment
2207 //=====================================================================================
2208
2209 // Column-major/row-major dense matrix addition assignment (symmetric)
2210 {
2211 test_ = "Column-major/row-major SymmetricMatrix dense matrix addition assignment (symmetric)";
2212
2213 blaze::DynamicMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 0 );
2214 mat(0,1) = -2;
2215 mat(0,2) = 6;
2216 mat(1,0) = -2;
2217 mat(1,1) = 3;
2218 mat(2,0) = 6;
2219
2220 OST sym( 3UL );
2221 sym(0,0) = 1;
2222 sym(0,1) = -4;
2223 sym(0,2) = 7;
2224 sym(1,1) = 2;
2225 sym(2,2) = 3;
2226
2227 sym += mat;
2228
2229 checkRows ( sym, 3UL );
2230 checkColumns ( sym, 3UL );
2231 checkCapacity( sym, 7UL );
2232 checkNonZeros( sym, 7UL );
2233 checkNonZeros( sym, 0UL, 3UL );
2234 checkNonZeros( sym, 1UL, 2UL );
2235 checkNonZeros( sym, 2UL, 2UL );
2236
2237 if( sym(0,0) != 1 || sym(0,1) != -6 || sym(0,2) != 13 ||
2238 sym(1,0) != -6 || sym(1,1) != 5 || sym(1,2) != 0 ||
2239 sym(2,0) != 13 || sym(2,1) != 0 || sym(2,2) != 3 ) {
2240 std::ostringstream oss;
2241 oss << " Test: " << test_ << "\n"
2242 << " Error: Addition assignment failed\n"
2243 << " Details:\n"
2244 << " Result:\n" << sym << "\n"
2245 << " Expected result:\n( 1 -6 13 )\n( -6 5 0 )\n( 13 0 3 )\n";
2246 throw std::runtime_error( oss.str() );
2247 }
2248 }
2249
2250 // Column-major/column-major dense matrix addition assignment (symmetric)
2251 {
2252 test_ = "Column-major/column-major SymmetricMatrix dense matrix addition assignment (symmetric)";
2253
2254 blaze::DynamicMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 0 );
2255 mat(0,1) = -2;
2256 mat(0,2) = 6;
2257 mat(1,0) = -2;
2258 mat(1,1) = 3;
2259 mat(2,0) = 6;
2260
2261 OST sym( 3UL );
2262 sym(0,0) = 1;
2263 sym(0,1) = -4;
2264 sym(0,2) = 7;
2265 sym(1,1) = 2;
2266 sym(2,2) = 3;
2267
2268 sym += mat;
2269
2270 checkRows ( sym, 3UL );
2271 checkColumns ( sym, 3UL );
2272 checkCapacity( sym, 7UL );
2273 checkNonZeros( sym, 7UL );
2274 checkNonZeros( sym, 0UL, 3UL );
2275 checkNonZeros( sym, 1UL, 2UL );
2276 checkNonZeros( sym, 2UL, 2UL );
2277
2278 if( sym(0,0) != 1 || sym(0,1) != -6 || sym(0,2) != 13 ||
2279 sym(1,0) != -6 || sym(1,1) != 5 || sym(1,2) != 0 ||
2280 sym(2,0) != 13 || sym(2,1) != 0 || sym(2,2) != 3 ) {
2281 std::ostringstream oss;
2282 oss << " Test: " << test_ << "\n"
2283 << " Error: Addition assignment failed\n"
2284 << " Details:\n"
2285 << " Result:\n" << sym << "\n"
2286 << " Expected result:\n( 1 -6 13 )\n( -6 5 0 )\n( 13 0 3 )\n";
2287 throw std::runtime_error( oss.str() );
2288 }
2289 }
2290
2291 // Column-major/row-major dense matrix addition assignment (non-symmetric)
2292 {
2293 test_ = "Column-major/row-major SymmetricMatrix dense matrix addition assignment (non-symmetric)";
2294
2295 blaze::DynamicMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 0 );
2296 mat(0,1) = -2;
2297 mat(0,2) = 6;
2298 mat(1,1) = 3;
2299 mat(2,0) = 6;
2300
2301 OST sym( 3UL );
2302 sym(0,0) = 1;
2303 sym(0,1) = -4;
2304 sym(0,2) = 7;
2305 sym(1,1) = 2;
2306 sym(2,2) = 3;
2307
2308 try {
2309 sym += mat;
2310
2311 std::ostringstream oss;
2312 oss << " Test: " << test_ << "\n"
2313 << " Error: Addition assignment of non-symmetric row-major matrix succeeded\n"
2314 << " Details:\n"
2315 << " Result:\n" << sym << "\n";
2316 throw std::runtime_error( oss.str() );
2317 }
2318 catch( std::invalid_argument& ) {}
2319 }
2320
2321 // Column-major/column-major dense matrix addition assignment (non-symmetric)
2322 {
2323 test_ = "Column-major/column-major SymmetricMatrix dense matrix addition assignment (non-symmetric)";
2324
2325 blaze::DynamicMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 0 );
2326 mat(0,1) = -2;
2327 mat(0,2) = 6;
2328 mat(1,1) = 3;
2329 mat(2,0) = 6;
2330
2331 OST sym( 3UL );
2332 sym(0,0) = 1;
2333 sym(0,1) = -4;
2334 sym(0,2) = 7;
2335 sym(1,1) = 2;
2336 sym(2,2) = 3;
2337
2338 try {
2339 sym += mat;
2340
2341 std::ostringstream oss;
2342 oss << " Test: " << test_ << "\n"
2343 << " Error: Addition assignment of non-symmetric column-major matrix succeeded\n"
2344 << " Details:\n"
2345 << " Result:\n" << sym << "\n";
2346 throw std::runtime_error( oss.str() );
2347 }
2348 catch( std::invalid_argument& ) {}
2349 }
2350
2351 // Column-major/row-major dense matrix addition assignment (SymmetricMatrix)
2352 {
2353 test_ = "Column-major/row-major SymmetricMatrix dense matrix addition assignment (SymmetricMatrix)";
2354
2355 ST sym1( 3UL );
2356 sym1(0,1) = -2;
2357 sym1(0,2) = 6;
2358 sym1(1,1) = 3;
2359
2360 OST sym2( 3UL );
2361 sym2(0,0) = 1;
2362 sym2(0,1) = -4;
2363 sym2(0,2) = 7;
2364 sym2(1,1) = 2;
2365 sym2(2,2) = 3;
2366
2367 sym2 += sym1;
2368
2369 checkRows ( sym2, 3UL );
2370 checkColumns ( sym2, 3UL );
2371 checkCapacity( sym2, 7UL );
2372 checkNonZeros( sym2, 7UL );
2373 checkNonZeros( sym2, 0UL, 3UL );
2374 checkNonZeros( sym2, 1UL, 2UL );
2375 checkNonZeros( sym2, 2UL, 2UL );
2376
2377 if( sym2(0,0) != 1 || sym2(0,1) != -6 || sym2(0,2) != 13 ||
2378 sym2(1,0) != -6 || sym2(1,1) != 5 || sym2(1,2) != 0 ||
2379 sym2(2,0) != 13 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
2380 std::ostringstream oss;
2381 oss << " Test: " << test_ << "\n"
2382 << " Error: Addition assignment failed\n"
2383 << " Details:\n"
2384 << " Result:\n" << sym2 << "\n"
2385 << " Expected result:\n( 1 -6 13 )\n( -6 5 0 )\n( 13 0 3 )\n";
2386 throw std::runtime_error( oss.str() );
2387 }
2388 }
2389
2390 // Column-major/column-major dense matrix addition assignment (SymmetricMatrix)
2391 {
2392 test_ = "Column-major/column-major SymmetricMatrix dense matrix addition assignment (SymmetricMatrix)";
2393
2394 OST sym1( 3UL );
2395 sym1(0,1) = -2;
2396 sym1(0,2) = 6;
2397 sym1(1,1) = 3;
2398
2399 OST sym2( 3UL );
2400 sym2(0,0) = 1;
2401 sym2(0,1) = -4;
2402 sym2(0,2) = 7;
2403 sym2(1,1) = 2;
2404 sym2(2,2) = 3;
2405
2406 sym2 += sym1;
2407
2408 checkRows ( sym2, 3UL );
2409 checkColumns ( sym2, 3UL );
2410 checkCapacity( sym2, 7UL );
2411 checkNonZeros( sym2, 7UL );
2412 checkNonZeros( sym2, 0UL, 3UL );
2413 checkNonZeros( sym2, 1UL, 2UL );
2414 checkNonZeros( sym2, 2UL, 2UL );
2415
2416 if( sym2(0,0) != 1 || sym2(0,1) != -6 || sym2(0,2) != 13 ||
2417 sym2(1,0) != -6 || sym2(1,1) != 5 || sym2(1,2) != 0 ||
2418 sym2(2,0) != 13 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
2419 std::ostringstream oss;
2420 oss << " Test: " << test_ << "\n"
2421 << " Error: Addition assignment failed\n"
2422 << " Details:\n"
2423 << " Result:\n" << sym2 << "\n"
2424 << " Expected result:\n( 1 -6 13 )\n( -6 5 0 )\n( 13 0 3 )\n";
2425 throw std::runtime_error( oss.str() );
2426 }
2427 }
2428
2429
2430 //=====================================================================================
2431 // Column-major sparse matrix addition assignment
2432 //=====================================================================================
2433
2434 // Column-major/row-major sparse matrix addition assignment (symmetric)
2435 {
2436 test_ = "Column-major/row-major SymmetricMatrix sparse matrix addition assignment (symmetric)";
2437
2438 blaze::CompressedMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 6UL );
2439 mat(0,1) = -2;
2440 mat(0,2) = 6;
2441 mat(1,0) = -2;
2442 mat(1,1) = 3;
2443 mat(2,0) = 6;
2444 mat.insert( 1UL, 2UL, 0 );
2445
2446 OST sym( 3UL );
2447 sym(0,0) = 1;
2448 sym(0,1) = -4;
2449 sym(0,2) = 7;
2450 sym(1,1) = 2;
2451 sym(2,2) = 3;
2452
2453 sym += mat;
2454
2455 checkRows ( sym, 3UL );
2456 checkColumns ( sym, 3UL );
2457 checkCapacity( sym, 8UL );
2458 checkNonZeros( sym, 8UL );
2459 checkNonZeros( sym, 0UL, 3UL );
2460 checkNonZeros( sym, 1UL, 3UL );
2461 checkNonZeros( sym, 2UL, 2UL );
2462
2463 if( sym(0,0) != 1 || sym(0,1) != -6 || sym(0,2) != 13 ||
2464 sym(1,0) != -6 || sym(1,1) != 5 || sym(1,2) != 0 ||
2465 sym(2,0) != 13 || sym(2,1) != 0 || sym(2,2) != 3 ) {
2466 std::ostringstream oss;
2467 oss << " Test: " << test_ << "\n"
2468 << " Error: Addition assignment failed\n"
2469 << " Details:\n"
2470 << " Result:\n" << sym << "\n"
2471 << " Expected result:\n( 1 -6 13 )\n( -6 5 0 )\n( 13 0 3 )\n";
2472 throw std::runtime_error( oss.str() );
2473 }
2474 }
2475
2476 // Column-major/column-major sparse matrix addition assignment (symmetric)
2477 {
2478 test_ = "Column-major/column-major SymmetricMatrix sparse matrix addition assignment (symmetric)";
2479
2480 blaze::CompressedMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 6UL );
2481 mat(0,1) = -2;
2482 mat(0,2) = 6;
2483 mat(1,0) = -2;
2484 mat(1,1) = 3;
2485 mat(2,0) = 6;
2486 mat.insert( 1UL, 2UL, 0 );
2487
2488 OST sym( 3UL );
2489 sym(0,0) = 1;
2490 sym(0,1) = -4;
2491 sym(0,2) = 7;
2492 sym(1,1) = 2;
2493 sym(2,2) = 3;
2494
2495 sym += mat;
2496
2497 checkRows ( sym, 3UL );
2498 checkColumns ( sym, 3UL );
2499 checkCapacity( sym, 8UL );
2500 checkNonZeros( sym, 8UL );
2501 checkNonZeros( sym, 0UL, 3UL );
2502 checkNonZeros( sym, 1UL, 2UL );
2503 checkNonZeros( sym, 2UL, 3UL );
2504
2505 if( sym(0,0) != 1 || sym(0,1) != -6 || sym(0,2) != 13 ||
2506 sym(1,0) != -6 || sym(1,1) != 5 || sym(1,2) != 0 ||
2507 sym(2,0) != 13 || sym(2,1) != 0 || sym(2,2) != 3 ) {
2508 std::ostringstream oss;
2509 oss << " Test: " << test_ << "\n"
2510 << " Error: Addition assignment failed\n"
2511 << " Details:\n"
2512 << " Result:\n" << sym << "\n"
2513 << " Expected result:\n( 1 -6 13 )\n( -6 5 0 )\n( 13 0 3 )\n";
2514 throw std::runtime_error( oss.str() );
2515 }
2516 }
2517
2518 // Column-major/row-major sparse matrix addition assignment (non-symmetric)
2519 {
2520 test_ = "Column-major/row-major SymmetricMatrix sparse matrix addition assignment (non-symmetric)";
2521
2522 blaze::CompressedMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 4UL );
2523 mat(0,1) = -2;
2524 mat(0,2) = 6;
2525 mat(1,1) = 3;
2526 mat(2,0) = 6;
2527
2528 OST sym( 3UL );
2529 sym(0,0) = 1;
2530 sym(0,1) = -4;
2531 sym(0,2) = 7;
2532 sym(1,1) = 2;
2533 sym(2,2) = 3;
2534
2535 try {
2536 sym += mat;
2537
2538 std::ostringstream oss;
2539 oss << " Test: " << test_ << "\n"
2540 << " Error: Addition assignment of non-symmetric row-major matrix succeeded\n"
2541 << " Details:\n"
2542 << " Result:\n" << sym << "\n";
2543 throw std::runtime_error( oss.str() );
2544 }
2545 catch( std::invalid_argument& ) {}
2546 }
2547
2548 // Column-major/column-major sparse matrix addition assignment (non-symmetric)
2549 {
2550 test_ = "Column-major/column-major SymmetricMatrix sparse matrix addition assignment (non-symmetric)";
2551
2552 blaze::CompressedMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 4UL );
2553 mat(0,1) = -2;
2554 mat(0,2) = 6;
2555 mat(1,1) = 3;
2556 mat(2,0) = 6;
2557
2558 OST sym( 3UL );
2559 sym(0,0) = 1;
2560 sym(0,1) = -4;
2561 sym(0,2) = 7;
2562 sym(1,1) = 2;
2563 sym(2,2) = 3;
2564
2565 try {
2566 sym += mat;
2567
2568 std::ostringstream oss;
2569 oss << " Test: " << test_ << "\n"
2570 << " Error: Addition assignment of non-symmetric column-major matrix succeeded\n"
2571 << " Details:\n"
2572 << " Result:\n" << sym << "\n";
2573 throw std::runtime_error( oss.str() );
2574 }
2575 catch( std::invalid_argument& ) {}
2576 }
2577
2578 // Column-major/row-major sparse matrix addition assignment (SymmetricMatrix)
2579 {
2580 test_ = "Column-major/row-major SymmetricMatrix sparse matrix addition assignment (SymmetricMatrix)";
2581
2582 blaze::SymmetricMatrix< blaze::CompressedMatrix<int,blaze::rowMajor> > sym1( 3UL, 5UL );
2583 sym1(0,1) = -2;
2584 sym1(0,2) = 6;
2585 sym1(1,1) = 3;
2586
2587 OST sym2( 3UL );
2588 sym2(0,0) = 1;
2589 sym2(0,1) = -4;
2590 sym2(0,2) = 7;
2591 sym2(1,1) = 2;
2592 sym2(2,2) = 3;
2593
2594 sym2 += sym1;
2595
2596 checkRows ( sym2, 3UL );
2597 checkColumns ( sym2, 3UL );
2598 checkCapacity( sym2, 7UL );
2599 checkNonZeros( sym2, 7UL );
2600 checkNonZeros( sym2, 0UL, 3UL );
2601 checkNonZeros( sym2, 1UL, 2UL );
2602 checkNonZeros( sym2, 2UL, 2UL );
2603
2604 if( sym2(0,0) != 1 || sym2(0,1) != -6 || sym2(0,2) != 13 ||
2605 sym2(1,0) != -6 || sym2(1,1) != 5 || sym2(1,2) != 0 ||
2606 sym2(2,0) != 13 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
2607 std::ostringstream oss;
2608 oss << " Test: " << test_ << "\n"
2609 << " Error: Addition assignment failed\n"
2610 << " Details:\n"
2611 << " Result:\n" << sym2 << "\n"
2612 << " Expected result:\n( 1 -6 13 )\n( -6 5 0 )\n( 13 0 3 )\n";
2613 throw std::runtime_error( oss.str() );
2614 }
2615 }
2616
2617 // Column-major/column-major sparse matrix addition assignment (SymmetricMatrix)
2618 {
2619 test_ = "Column-major/column-major SymmetricMatrix sparse matrix addition assignment (SymmetricMatrix)";
2620
2621 blaze::SymmetricMatrix< blaze::CompressedMatrix<int,blaze::columnMajor> > sym1( 3UL, 5UL );
2622 sym1(0,1) = -2;
2623 sym1(0,2) = 6;
2624 sym1(1,1) = 3;
2625
2626 OST sym2( 3UL );
2627 sym2(0,0) = 1;
2628 sym2(0,1) = -4;
2629 sym2(0,2) = 7;
2630 sym2(1,1) = 2;
2631 sym2(2,2) = 3;
2632
2633 sym2 += sym1;
2634
2635 checkRows ( sym2, 3UL );
2636 checkColumns ( sym2, 3UL );
2637 checkCapacity( sym2, 7UL );
2638 checkNonZeros( sym2, 7UL );
2639 checkNonZeros( sym2, 0UL, 3UL );
2640 checkNonZeros( sym2, 1UL, 2UL );
2641 checkNonZeros( sym2, 2UL, 2UL );
2642
2643 if( sym2(0,0) != 1 || sym2(0,1) != -6 || sym2(0,2) != 13 ||
2644 sym2(1,0) != -6 || sym2(1,1) != 5 || sym2(1,2) != 0 ||
2645 sym2(2,0) != 13 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
2646 std::ostringstream oss;
2647 oss << " Test: " << test_ << "\n"
2648 << " Error: Addition assignment failed\n"
2649 << " Details:\n"
2650 << " Result:\n" << sym2 << "\n"
2651 << " Expected result:\n( 1 -6 13 )\n( -6 5 0 )\n( 13 0 3 )\n";
2652 throw std::runtime_error( oss.str() );
2653 }
2654 }
2655 }
2656 //*************************************************************************************************
2657
2658
2659 //*************************************************************************************************
2660 /*!\brief Test of the SymmetricMatrix subtraction assignment operators.
2661 //
2662 // \return void
2663 // \exception std::runtime_error Error detected.
2664 //
2665 // This function performs a test of the subtraction assignment operators of the SymmetricMatrix
2666 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
2667 */
testSubAssign()2668 void SparseScalarTest::testSubAssign()
2669 {
2670 //=====================================================================================
2671 // Row-major dense matrix subtraction assignment
2672 //=====================================================================================
2673
2674 // Row-major/row-major dense matrix subtraction assignment (symmetric)
2675 {
2676 test_ = "Row-major/row-major SymmetricMatrix dense matrix subtraction assignment (symmetric)";
2677
2678 blaze::DynamicMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 0 );
2679 mat(0,1) = -2;
2680 mat(0,2) = 6;
2681 mat(1,0) = -2;
2682 mat(1,1) = 3;
2683 mat(2,0) = 6;
2684
2685 ST sym( 3UL );
2686 sym(0,0) = 1;
2687 sym(0,1) = -4;
2688 sym(0,2) = 7;
2689 sym(1,1) = 2;
2690 sym(2,2) = 3;
2691
2692 sym -= mat;
2693
2694 checkRows ( sym, 3UL );
2695 checkColumns ( sym, 3UL );
2696 checkCapacity( sym, 7UL );
2697 checkNonZeros( sym, 7UL );
2698 checkNonZeros( sym, 0UL, 3UL );
2699 checkNonZeros( sym, 1UL, 2UL );
2700 checkNonZeros( sym, 2UL, 2UL );
2701
2702 if( sym(0,0) != 1 || sym(0,1) != -2 || sym(0,2) != 1 ||
2703 sym(1,0) != -2 || sym(1,1) != -1 || sym(1,2) != 0 ||
2704 sym(2,0) != 1 || sym(2,1) != 0 || sym(2,2) != 3 ) {
2705 std::ostringstream oss;
2706 oss << " Test: " << test_ << "\n"
2707 << " Error: Subtraction assignment failed\n"
2708 << " Details:\n"
2709 << " Result:\n" << sym << "\n"
2710 << " Expected result:\n( 1 -2 1 )\n( -2 -1 0 )\n( 1 0 3 )\n";
2711 throw std::runtime_error( oss.str() );
2712 }
2713 }
2714
2715 // Row-major/column-major dense matrix subtraction assignment (symmetric)
2716 {
2717 test_ = "Row-major/column-major SymmetricMatrix dense matrix subtraction assignment (symmetric)";
2718
2719 blaze::DynamicMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 0 );
2720 mat(0,1) = -2;
2721 mat(0,2) = 6;
2722 mat(1,0) = -2;
2723 mat(1,1) = 3;
2724 mat(2,0) = 6;
2725
2726 ST sym( 3UL );
2727 sym(0,0) = 1;
2728 sym(0,1) = -4;
2729 sym(0,2) = 7;
2730 sym(1,1) = 2;
2731 sym(2,2) = 3;
2732
2733 sym -= mat;
2734
2735 checkRows ( sym, 3UL );
2736 checkColumns ( sym, 3UL );
2737 checkCapacity( sym, 7UL );
2738 checkNonZeros( sym, 7UL );
2739 checkNonZeros( sym, 0UL, 3UL );
2740 checkNonZeros( sym, 1UL, 2UL );
2741 checkNonZeros( sym, 2UL, 2UL );
2742
2743 if( sym(0,0) != 1 || sym(0,1) != -2 || sym(0,2) != 1 ||
2744 sym(1,0) != -2 || sym(1,1) != -1 || sym(1,2) != 0 ||
2745 sym(2,0) != 1 || sym(2,1) != 0 || sym(2,2) != 3 ) {
2746 std::ostringstream oss;
2747 oss << " Test: " << test_ << "\n"
2748 << " Error: Subtraction assignment failed\n"
2749 << " Details:\n"
2750 << " Result:\n" << sym << "\n"
2751 << " Expected result:\n( 1 -2 1 )\n( -2 -1 0 )\n( 1 0 3 )\n";
2752 throw std::runtime_error( oss.str() );
2753 }
2754 }
2755
2756 // Row-major/row-major dense matrix subtraction assignment (non-symmetric)
2757 {
2758 test_ = "Row-major/row-major SymmetricMatrix dense matrix subtraction assignment (non-symmetric)";
2759
2760 blaze::DynamicMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 0 );
2761 mat(0,1) = -2;
2762 mat(0,2) = 6;
2763 mat(1,1) = 3;
2764 mat(2,0) = 6;
2765
2766 ST sym( 3UL );
2767 sym(0,0) = 1;
2768 sym(0,1) = -4;
2769 sym(0,2) = 7;
2770 sym(1,1) = 2;
2771 sym(2,2) = 3;
2772
2773 try {
2774 sym -= mat;
2775
2776 std::ostringstream oss;
2777 oss << " Test: " << test_ << "\n"
2778 << " Error: Subtraction assignment of non-symmetric row-major matrix succeeded\n"
2779 << " Details:\n"
2780 << " Result:\n" << sym << "\n";
2781 throw std::runtime_error( oss.str() );
2782 }
2783 catch( std::invalid_argument& ) {}
2784 }
2785
2786 // Row-major/column-major dense matrix subtraction assignment (non-symmetric)
2787 {
2788 test_ = "Row-major/column-major SymmetricMatrix dense matrix subtraction assignment (non-symmetric)";
2789
2790 blaze::DynamicMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 0 );
2791 mat(0,1) = -2;
2792 mat(0,2) = 6;
2793 mat(1,1) = 3;
2794 mat(2,0) = 6;
2795
2796 ST sym( 3UL );
2797 sym(0,0) = 1;
2798 sym(0,1) = -4;
2799 sym(0,2) = 7;
2800 sym(1,1) = 2;
2801 sym(2,2) = 3;
2802
2803 try {
2804 sym -= mat;
2805
2806 std::ostringstream oss;
2807 oss << " Test: " << test_ << "\n"
2808 << " Error: Subtraction assignment of non-symmetric column-major matrix succeeded\n"
2809 << " Details:\n"
2810 << " Result:\n" << sym << "\n";
2811 throw std::runtime_error( oss.str() );
2812 }
2813 catch( std::invalid_argument& ) {}
2814 }
2815
2816 // Row-major/row-major dense matrix subtraction assignment (SymmetricMatrix)
2817 {
2818 test_ = "Row-major/row-major SymmetricMatrix dense matrix subtraction assignment (SymmetricMatrix)";
2819
2820 ST sym1( 3UL );
2821 sym1(0,1) = -2;
2822 sym1(0,2) = 6;
2823 sym1(1,1) = 3;
2824
2825 ST sym2( 3UL );
2826 sym2(0,0) = 1;
2827 sym2(0,1) = -4;
2828 sym2(0,2) = 7;
2829 sym2(1,1) = 2;
2830 sym2(2,2) = 3;
2831
2832 sym2 -= sym1;
2833
2834 checkRows ( sym2, 3UL );
2835 checkColumns ( sym2, 3UL );
2836 checkCapacity( sym2, 7UL );
2837 checkNonZeros( sym2, 7UL );
2838 checkNonZeros( sym2, 0UL, 3UL );
2839 checkNonZeros( sym2, 1UL, 2UL );
2840 checkNonZeros( sym2, 2UL, 2UL );
2841
2842 if( sym2(0,0) != 1 || sym2(0,1) != -2 || sym2(0,2) != 1 ||
2843 sym2(1,0) != -2 || sym2(1,1) != -1 || sym2(1,2) != 0 ||
2844 sym2(2,0) != 1 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
2845 std::ostringstream oss;
2846 oss << " Test: " << test_ << "\n"
2847 << " Error: Subtraction assignment failed\n"
2848 << " Details:\n"
2849 << " Result:\n" << sym2 << "\n"
2850 << " Expected result:\n( 1 -2 1 )\n( -2 -1 0 )\n( 1 0 3 )\n";
2851 throw std::runtime_error( oss.str() );
2852 }
2853 }
2854
2855 // Row-major/column-major dense matrix subtraction assignment (SymmetricMatrix)
2856 {
2857 test_ = "Row-major/column-major SymmetricMatrix dense matrix subtraction assignment (SymmetricMatrix)";
2858
2859 OST sym1( 3UL );
2860 sym1(0,1) = -2;
2861 sym1(0,2) = 6;
2862 sym1(1,1) = 3;
2863
2864 ST sym2( 3UL );
2865 sym2(0,0) = 1;
2866 sym2(0,1) = -4;
2867 sym2(0,2) = 7;
2868 sym2(1,1) = 2;
2869 sym2(2,2) = 3;
2870
2871 sym2 -= sym1;
2872
2873 checkRows ( sym2, 3UL );
2874 checkColumns ( sym2, 3UL );
2875 checkCapacity( sym2, 7UL );
2876 checkNonZeros( sym2, 7UL );
2877 checkNonZeros( sym2, 0UL, 3UL );
2878 checkNonZeros( sym2, 1UL, 2UL );
2879 checkNonZeros( sym2, 2UL, 2UL );
2880
2881 if( sym2(0,0) != 1 || sym2(0,1) != -2 || sym2(0,2) != 1 ||
2882 sym2(1,0) != -2 || sym2(1,1) != -1 || sym2(1,2) != 0 ||
2883 sym2(2,0) != 1 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
2884 std::ostringstream oss;
2885 oss << " Test: " << test_ << "\n"
2886 << " Error: Subtraction assignment failed\n"
2887 << " Details:\n"
2888 << " Result:\n" << sym2 << "\n"
2889 << " Expected result:\n( 1 -2 1 )\n( -2 -1 0 )\n( 1 0 3 )\n";
2890 throw std::runtime_error( oss.str() );
2891 }
2892 }
2893
2894
2895 //=====================================================================================
2896 // Row-major sparse matrix subtraction assignment
2897 //=====================================================================================
2898
2899 // Row-major/row-major sparse matrix subtraction assignment (symmetric)
2900 {
2901 test_ = "Row-major/row-major SymmetricMatrix sparse matrix subtraction assignment (symmetric)";
2902
2903 blaze::CompressedMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 6UL );
2904 mat(0,1) = -2;
2905 mat(0,2) = 6;
2906 mat(1,0) = -2;
2907 mat(1,1) = 3;
2908 mat(2,0) = 6;
2909 mat.insert( 1UL, 2UL, 0 );
2910
2911 ST sym( 3UL );
2912 sym(0,0) = 1;
2913 sym(0,1) = -4;
2914 sym(0,2) = 7;
2915 sym(1,1) = 2;
2916 sym(2,2) = 3;
2917
2918 sym -= mat;
2919
2920 checkRows ( sym, 3UL );
2921 checkColumns ( sym, 3UL );
2922 checkCapacity( sym, 8UL );
2923 checkNonZeros( sym, 8UL );
2924 checkNonZeros( sym, 0UL, 3UL );
2925 checkNonZeros( sym, 1UL, 3UL );
2926 checkNonZeros( sym, 2UL, 2UL );
2927
2928 if( sym(0,0) != 1 || sym(0,1) != -2 || sym(0,2) != 1 ||
2929 sym(1,0) != -2 || sym(1,1) != -1 || sym(1,2) != 0 ||
2930 sym(2,0) != 1 || sym(2,1) != 0 || sym(2,2) != 3 ) {
2931 std::ostringstream oss;
2932 oss << " Test: " << test_ << "\n"
2933 << " Error: Subtraction assignment failed\n"
2934 << " Details:\n"
2935 << " Result:\n" << sym << "\n"
2936 << " Expected result:\n( 1 -2 1 )\n( -2 -1 0 )\n( 1 0 3 )\n";
2937 throw std::runtime_error( oss.str() );
2938 }
2939 }
2940
2941 // Row-major/column-major sparse matrix subtraction assignment (symmetric)
2942 {
2943 test_ = "Row-major/column-major SymmetricMatrix sparse matrix subtraction assignment (symmetric)";
2944
2945 blaze::CompressedMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 6UL );
2946 mat(0,1) = -2;
2947 mat(0,2) = 6;
2948 mat(1,0) = -2;
2949 mat(1,1) = 3;
2950 mat(2,0) = 6;
2951 mat.insert( 1UL, 2UL, 0 );
2952
2953 ST sym( 3UL );
2954 sym(0,0) = 1;
2955 sym(0,1) = -4;
2956 sym(0,2) = 7;
2957 sym(1,1) = 2;
2958 sym(2,2) = 3;
2959
2960 sym -= mat;
2961
2962 checkRows ( sym, 3UL );
2963 checkColumns ( sym, 3UL );
2964 checkCapacity( sym, 8UL );
2965 checkNonZeros( sym, 8UL );
2966 checkNonZeros( sym, 0UL, 3UL );
2967 checkNonZeros( sym, 1UL, 2UL );
2968 checkNonZeros( sym, 2UL, 3UL );
2969
2970 if( sym(0,0) != 1 || sym(0,1) != -2 || sym(0,2) != 1 ||
2971 sym(1,0) != -2 || sym(1,1) != -1 || sym(1,2) != 0 ||
2972 sym(2,0) != 1 || sym(2,1) != 0 || sym(2,2) != 3 ) {
2973 std::ostringstream oss;
2974 oss << " Test: " << test_ << "\n"
2975 << " Error: Subtraction assignment failed\n"
2976 << " Details:\n"
2977 << " Result:\n" << sym << "\n"
2978 << " Expected result:\n( 1 -2 1 )\n( -2 -1 0 )\n( 1 0 3 )\n";
2979 throw std::runtime_error( oss.str() );
2980 }
2981 }
2982
2983 // Row-major/row-major sparse matrix subtraction assignment (non-symmetric)
2984 {
2985 test_ = "Row-major/row-major SymmetricMatrix sparse matrix subtraction assignment (non-symmetric)";
2986
2987 blaze::CompressedMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 4UL );
2988 mat(0,1) = -2;
2989 mat(0,2) = 6;
2990 mat(1,1) = 3;
2991 mat(2,0) = 6;
2992
2993 ST sym( 3UL );
2994 sym(0,0) = 1;
2995 sym(0,1) = -4;
2996 sym(0,2) = 7;
2997 sym(1,1) = 2;
2998 sym(2,2) = 3;
2999
3000 try {
3001 sym -= mat;
3002
3003 std::ostringstream oss;
3004 oss << " Test: " << test_ << "\n"
3005 << " Error: Subtraction assignment of non-symmetric row-major matrix succeeded\n"
3006 << " Details:\n"
3007 << " Result:\n" << sym << "\n";
3008 throw std::runtime_error( oss.str() );
3009 }
3010 catch( std::invalid_argument& ) {}
3011 }
3012
3013 // Row-major/column-major sparse matrix subtraction assignment (non-symmetric)
3014 {
3015 test_ = "Row-major/column-major SymmetricMatrix sparse matrix subtraction assignment (non-symmetric)";
3016
3017 blaze::CompressedMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 4UL );
3018 mat(0,1) = -2;
3019 mat(0,2) = 6;
3020 mat(1,1) = 3;
3021 mat(2,0) = 6;
3022
3023 ST sym( 3UL );
3024 sym(0,0) = 1;
3025 sym(0,1) = -4;
3026 sym(0,2) = 7;
3027 sym(1,1) = 2;
3028 sym(2,2) = 3;
3029
3030 try {
3031 sym -= mat;
3032
3033 std::ostringstream oss;
3034 oss << " Test: " << test_ << "\n"
3035 << " Error: Subtraction assignment of non-symmetric column-major matrix succeeded\n"
3036 << " Details:\n"
3037 << " Result:\n" << sym << "\n";
3038 throw std::runtime_error( oss.str() );
3039 }
3040 catch( std::invalid_argument& ) {}
3041 }
3042
3043 // Row-major/row-major sparse matrix subtraction assignment (SymmetricMatrix)
3044 {
3045 test_ = "Row-major/row-major SymmetricMatrix sparse matrix subtraction assignment (SymmetricMatrix)";
3046
3047 blaze::SymmetricMatrix< blaze::CompressedMatrix<int,blaze::rowMajor> > sym1( 3UL, 5UL );
3048 sym1(0,1) = -2;
3049 sym1(0,2) = 6;
3050 sym1(1,1) = 3;
3051
3052 ST sym2( 3UL );
3053 sym2(0,0) = 1;
3054 sym2(0,1) = -4;
3055 sym2(0,2) = 7;
3056 sym2(1,1) = 2;
3057 sym2(2,2) = 3;
3058
3059 sym2 -= sym1;
3060
3061 checkRows ( sym2, 3UL );
3062 checkColumns ( sym2, 3UL );
3063 checkCapacity( sym2, 7UL );
3064 checkNonZeros( sym2, 7UL );
3065 checkNonZeros( sym2, 0UL, 3UL );
3066 checkNonZeros( sym2, 1UL, 2UL );
3067 checkNonZeros( sym2, 2UL, 2UL );
3068
3069 if( sym2(0,0) != 1 || sym2(0,1) != -2 || sym2(0,2) != 1 ||
3070 sym2(1,0) != -2 || sym2(1,1) != -1 || sym2(1,2) != 0 ||
3071 sym2(2,0) != 1 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
3072 std::ostringstream oss;
3073 oss << " Test: " << test_ << "\n"
3074 << " Error: Subtraction assignment failed\n"
3075 << " Details:\n"
3076 << " Result:\n" << sym2 << "\n"
3077 << " Expected result:\n( 1 -2 1 )\n( -2 -1 0 )\n( 1 0 3 )\n";
3078 throw std::runtime_error( oss.str() );
3079 }
3080 }
3081
3082 // Row-major/column-major sparse matrix subtraction assignment (SymmetricMatrix)
3083 {
3084 test_ = "Row-major/column-major SymmetricMatrix sparse matrix subtraction assignment (SymmetricMatrix)";
3085
3086 blaze::SymmetricMatrix< blaze::CompressedMatrix<int,blaze::columnMajor> > sym1( 3UL, 5UL );
3087 sym1(0,1) = -2;
3088 sym1(0,2) = 6;
3089 sym1(1,1) = 3;
3090
3091 ST sym2( 3UL );
3092 sym2(0,0) = 1;
3093 sym2(0,1) = -4;
3094 sym2(0,2) = 7;
3095 sym2(1,1) = 2;
3096 sym2(2,2) = 3;
3097
3098 sym2 -= sym1;
3099
3100 checkRows ( sym2, 3UL );
3101 checkColumns ( sym2, 3UL );
3102 checkCapacity( sym2, 7UL );
3103 checkNonZeros( sym2, 7UL );
3104 checkNonZeros( sym2, 0UL, 3UL );
3105 checkNonZeros( sym2, 1UL, 2UL );
3106 checkNonZeros( sym2, 2UL, 2UL );
3107
3108 if( sym2(0,0) != 1 || sym2(0,1) != -2 || sym2(0,2) != 1 ||
3109 sym2(1,0) != -2 || sym2(1,1) != -1 || sym2(1,2) != 0 ||
3110 sym2(2,0) != 1 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
3111 std::ostringstream oss;
3112 oss << " Test: " << test_ << "\n"
3113 << " Error: Subtraction assignment failed\n"
3114 << " Details:\n"
3115 << " Result:\n" << sym2 << "\n"
3116 << " Expected result:\n( 1 -2 1 )\n( -2 -1 0 )\n( 1 0 3 )\n";
3117 throw std::runtime_error( oss.str() );
3118 }
3119 }
3120
3121
3122 //=====================================================================================
3123 // Column-major dense matrix subtraction assignment
3124 //=====================================================================================
3125
3126 // Column-major/row-major dense matrix subtraction assignment (symmetric)
3127 {
3128 test_ = "Column-major/row-major SymmetricMatrix dense matrix subtraction assignment (symmetric)";
3129
3130 blaze::DynamicMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 0 );
3131 mat(0,1) = -2;
3132 mat(0,2) = 6;
3133 mat(1,0) = -2;
3134 mat(1,1) = 3;
3135 mat(2,0) = 6;
3136
3137 OST sym( 3UL );
3138 sym(0,0) = 1;
3139 sym(0,1) = -4;
3140 sym(0,2) = 7;
3141 sym(1,1) = 2;
3142 sym(2,2) = 3;
3143
3144 sym -= mat;
3145
3146 checkRows ( sym, 3UL );
3147 checkColumns ( sym, 3UL );
3148 checkCapacity( sym, 7UL );
3149 checkNonZeros( sym, 7UL );
3150 checkNonZeros( sym, 0UL, 3UL );
3151 checkNonZeros( sym, 1UL, 2UL );
3152 checkNonZeros( sym, 2UL, 2UL );
3153
3154 if( sym(0,0) != 1 || sym(0,1) != -2 || sym(0,2) != 1 ||
3155 sym(1,0) != -2 || sym(1,1) != -1 || sym(1,2) != 0 ||
3156 sym(2,0) != 1 || sym(2,1) != 0 || sym(2,2) != 3 ) {
3157 std::ostringstream oss;
3158 oss << " Test: " << test_ << "\n"
3159 << " Error: Subtraction assignment failed\n"
3160 << " Details:\n"
3161 << " Result:\n" << sym << "\n"
3162 << " Expected result:\n( 1 -2 1 )\n( -2 -1 0 )\n( 1 0 3 )\n";
3163 throw std::runtime_error( oss.str() );
3164 }
3165 }
3166
3167 // Column-major/column-major dense matrix subtraction assignment (symmetric)
3168 {
3169 test_ = "Column-major/column-major SymmetricMatrix dense matrix subtraction assignment (symmetric)";
3170
3171 blaze::DynamicMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 0 );
3172 mat(0,1) = -2;
3173 mat(0,2) = 6;
3174 mat(1,0) = -2;
3175 mat(1,1) = 3;
3176 mat(2,0) = 6;
3177
3178 OST sym( 3UL );
3179 sym(0,0) = 1;
3180 sym(0,1) = -4;
3181 sym(0,2) = 7;
3182 sym(1,1) = 2;
3183 sym(2,2) = 3;
3184
3185 sym -= mat;
3186
3187 checkRows ( sym, 3UL );
3188 checkColumns ( sym, 3UL );
3189 checkCapacity( sym, 7UL );
3190 checkNonZeros( sym, 7UL );
3191 checkNonZeros( sym, 0UL, 3UL );
3192 checkNonZeros( sym, 1UL, 2UL );
3193 checkNonZeros( sym, 2UL, 2UL );
3194
3195 if( sym(0,0) != 1 || sym(0,1) != -2 || sym(0,2) != 1 ||
3196 sym(1,0) != -2 || sym(1,1) != -1 || sym(1,2) != 0 ||
3197 sym(2,0) != 1 || sym(2,1) != 0 || sym(2,2) != 3 ) {
3198 std::ostringstream oss;
3199 oss << " Test: " << test_ << "\n"
3200 << " Error: Subtraction assignment failed\n"
3201 << " Details:\n"
3202 << " Result:\n" << sym << "\n"
3203 << " Expected result:\n( 1 -2 1 )\n( -2 -1 0 )\n( 1 0 3 )\n";
3204 throw std::runtime_error( oss.str() );
3205 }
3206 }
3207
3208 // Column-major/row-major dense matrix subtraction assignment (non-symmetric)
3209 {
3210 test_ = "Column-major/row-major SymmetricMatrix dense matrix subtraction assignment (non-symmetric)";
3211
3212 blaze::DynamicMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 0 );
3213 mat(0,1) = -2;
3214 mat(0,2) = 6;
3215 mat(1,1) = 3;
3216 mat(2,0) = 6;
3217
3218 OST sym( 3UL );
3219 sym(0,0) = 1;
3220 sym(0,1) = -4;
3221 sym(0,2) = 7;
3222 sym(1,1) = 2;
3223 sym(2,2) = 3;
3224
3225 try {
3226 sym -= mat;
3227
3228 std::ostringstream oss;
3229 oss << " Test: " << test_ << "\n"
3230 << " Error: Subtraction assignment of non-symmetric row-major matrix succeeded\n"
3231 << " Details:\n"
3232 << " Result:\n" << sym << "\n";
3233 throw std::runtime_error( oss.str() );
3234 }
3235 catch( std::invalid_argument& ) {}
3236 }
3237
3238 // Column-major/column-major dense matrix subtraction assignment (non-symmetric)
3239 {
3240 test_ = "Column-major/column-major SymmetricMatrix dense matrix subtraction assignment (non-symmetric)";
3241
3242 blaze::DynamicMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 0 );
3243 mat(0,1) = -2;
3244 mat(0,2) = 6;
3245 mat(1,1) = 3;
3246 mat(2,0) = 6;
3247
3248 OST sym( 3UL );
3249 sym(0,0) = 1;
3250 sym(0,1) = -4;
3251 sym(0,2) = 7;
3252 sym(1,1) = 2;
3253 sym(2,2) = 3;
3254
3255 try {
3256 sym -= mat;
3257
3258 std::ostringstream oss;
3259 oss << " Test: " << test_ << "\n"
3260 << " Error: Subtraction assignment of non-symmetric column-major matrix succeeded\n"
3261 << " Details:\n"
3262 << " Result:\n" << sym << "\n";
3263 throw std::runtime_error( oss.str() );
3264 }
3265 catch( std::invalid_argument& ) {}
3266 }
3267
3268 // Column-major/row-major dense matrix subtraction assignment (SymmetricMatrix)
3269 {
3270 test_ = "Column-major/row-major SymmetricMatrix dense matrix subtraction assignment (SymmetricMatrix)";
3271
3272 ST sym1( 3UL );
3273 sym1(0,1) = -2;
3274 sym1(0,2) = 6;
3275 sym1(1,1) = 3;
3276
3277 OST sym2( 3UL );
3278 sym2(0,0) = 1;
3279 sym2(0,1) = -4;
3280 sym2(0,2) = 7;
3281 sym2(1,1) = 2;
3282 sym2(2,2) = 3;
3283
3284 sym2 -= sym1;
3285
3286 checkRows ( sym2, 3UL );
3287 checkColumns ( sym2, 3UL );
3288 checkCapacity( sym2, 7UL );
3289 checkNonZeros( sym2, 7UL );
3290 checkNonZeros( sym2, 0UL, 3UL );
3291 checkNonZeros( sym2, 1UL, 2UL );
3292 checkNonZeros( sym2, 2UL, 2UL );
3293
3294 if( sym2(0,0) != 1 || sym2(0,1) != -2 || sym2(0,2) != 1 ||
3295 sym2(1,0) != -2 || sym2(1,1) != -1 || sym2(1,2) != 0 ||
3296 sym2(2,0) != 1 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
3297 std::ostringstream oss;
3298 oss << " Test: " << test_ << "\n"
3299 << " Error: Subtraction assignment failed\n"
3300 << " Details:\n"
3301 << " Result:\n" << sym2 << "\n"
3302 << " Expected result:\n( 1 -2 1 )\n( -2 -1 0 )\n( 1 0 3 )\n";
3303 throw std::runtime_error( oss.str() );
3304 }
3305 }
3306
3307 // Column-major/column-major dense matrix subtraction assignment (SymmetricMatrix)
3308 {
3309 test_ = "Column-major/column-major SymmetricMatrix dense matrix subtraction assignment (SymmetricMatrix)";
3310
3311 OST sym1( 3UL );
3312 sym1(0,1) = -2;
3313 sym1(0,2) = 6;
3314 sym1(1,1) = 3;
3315
3316 OST sym2( 3UL );
3317 sym2(0,0) = 1;
3318 sym2(0,1) = -4;
3319 sym2(0,2) = 7;
3320 sym2(1,1) = 2;
3321 sym2(2,2) = 3;
3322
3323 sym2 -= sym1;
3324
3325 checkRows ( sym2, 3UL );
3326 checkColumns ( sym2, 3UL );
3327 checkCapacity( sym2, 7UL );
3328 checkNonZeros( sym2, 7UL );
3329 checkNonZeros( sym2, 0UL, 3UL );
3330 checkNonZeros( sym2, 1UL, 2UL );
3331 checkNonZeros( sym2, 2UL, 2UL );
3332
3333 if( sym2(0,0) != 1 || sym2(0,1) != -2 || sym2(0,2) != 1 ||
3334 sym2(1,0) != -2 || sym2(1,1) != -1 || sym2(1,2) != 0 ||
3335 sym2(2,0) != 1 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
3336 std::ostringstream oss;
3337 oss << " Test: " << test_ << "\n"
3338 << " Error: Subtraction assignment failed\n"
3339 << " Details:\n"
3340 << " Result:\n" << sym2 << "\n"
3341 << " Expected result:\n( 1 -2 1 )\n( -2 -1 0 )\n( 1 0 3 )\n";
3342 throw std::runtime_error( oss.str() );
3343 }
3344 }
3345
3346
3347 //=====================================================================================
3348 // Column-major sparse matrix subtraction assignment
3349 //=====================================================================================
3350
3351 // Column-major/row-major sparse matrix subtraction assignment (symmetric)
3352 {
3353 test_ = "Column-major/row-major SymmetricMatrix sparse matrix subtraction assignment (symmetric)";
3354
3355 blaze::CompressedMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 6UL );
3356 mat(0,1) = -2;
3357 mat(0,2) = 6;
3358 mat(1,0) = -2;
3359 mat(1,1) = 3;
3360 mat(2,0) = 6;
3361 mat.insert( 1UL, 2UL, 0 );
3362
3363 OST sym( 3UL );
3364 sym(0,0) = 1;
3365 sym(0,1) = -4;
3366 sym(0,2) = 7;
3367 sym(1,1) = 2;
3368 sym(2,2) = 3;
3369
3370 sym -= mat;
3371
3372 checkRows ( sym, 3UL );
3373 checkColumns ( sym, 3UL );
3374 checkCapacity( sym, 8UL );
3375 checkNonZeros( sym, 8UL );
3376 checkNonZeros( sym, 0UL, 3UL );
3377 checkNonZeros( sym, 1UL, 3UL );
3378 checkNonZeros( sym, 2UL, 2UL );
3379
3380 if( sym(0,0) != 1 || sym(0,1) != -2 || sym(0,2) != 1 ||
3381 sym(1,0) != -2 || sym(1,1) != -1 || sym(1,2) != 0 ||
3382 sym(2,0) != 1 || sym(2,1) != 0 || sym(2,2) != 3 ) {
3383 std::ostringstream oss;
3384 oss << " Test: " << test_ << "\n"
3385 << " Error: Subtraction assignment failed\n"
3386 << " Details:\n"
3387 << " Result:\n" << sym << "\n"
3388 << " Expected result:\n( 1 -2 1 )\n( -2 -1 0 )\n( 1 0 3 )\n";
3389 throw std::runtime_error( oss.str() );
3390 }
3391 }
3392
3393 // Column-major/column-major sparse matrix subtraction assignment (symmetric)
3394 {
3395 test_ = "Column-major/column-major SymmetricMatrix sparse matrix subtraction assignment (symmetric)";
3396
3397 blaze::CompressedMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 6UL );
3398 mat(0,1) = -2;
3399 mat(0,2) = 6;
3400 mat(1,0) = -2;
3401 mat(1,1) = 3;
3402 mat(2,0) = 6;
3403 mat.insert( 1UL, 2UL, 0 );
3404
3405 OST sym( 3UL );
3406 sym(0,0) = 1;
3407 sym(0,1) = -4;
3408 sym(0,2) = 7;
3409 sym(1,1) = 2;
3410 sym(2,2) = 3;
3411
3412 sym -= mat;
3413
3414 checkRows ( sym, 3UL );
3415 checkColumns ( sym, 3UL );
3416 checkCapacity( sym, 8UL );
3417 checkNonZeros( sym, 8UL );
3418 checkNonZeros( sym, 0UL, 3UL );
3419 checkNonZeros( sym, 1UL, 2UL );
3420 checkNonZeros( sym, 2UL, 3UL );
3421
3422 if( sym(0,0) != 1 || sym(0,1) != -2 || sym(0,2) != 1 ||
3423 sym(1,0) != -2 || sym(1,1) != -1 || sym(1,2) != 0 ||
3424 sym(2,0) != 1 || sym(2,1) != 0 || sym(2,2) != 3 ) {
3425 std::ostringstream oss;
3426 oss << " Test: " << test_ << "\n"
3427 << " Error: Subtraction assignment failed\n"
3428 << " Details:\n"
3429 << " Result:\n" << sym << "\n"
3430 << " Expected result:\n( 1 -2 1 )\n( -2 -1 0 )\n( 1 0 3 )\n";
3431 throw std::runtime_error( oss.str() );
3432 }
3433 }
3434
3435 // Column-major/row-major sparse matrix subtraction assignment (non-symmetric)
3436 {
3437 test_ = "Column-major/row-major SymmetricMatrix sparse matrix subtraction assignment (non-symmetric)";
3438
3439 blaze::CompressedMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 4UL );
3440 mat(0,1) = -2;
3441 mat(0,2) = 6;
3442 mat(1,1) = 3;
3443 mat(2,0) = 6;
3444
3445 OST sym( 3UL );
3446 sym(0,0) = 1;
3447 sym(0,1) = -4;
3448 sym(0,2) = 7;
3449 sym(1,1) = 2;
3450 sym(2,2) = 3;
3451
3452 try {
3453 sym -= mat;
3454
3455 std::ostringstream oss;
3456 oss << " Test: " << test_ << "\n"
3457 << " Error: Subtraction assignment of non-symmetric row-major matrix succeeded\n"
3458 << " Details:\n"
3459 << " Result:\n" << sym << "\n";
3460 throw std::runtime_error( oss.str() );
3461 }
3462 catch( std::invalid_argument& ) {}
3463 }
3464
3465 // Column-major/column-major sparse matrix subtraction assignment (non-symmetric)
3466 {
3467 test_ = "Column-major/column-major SymmetricMatrix sparse matrix subtraction assignment (non-symmetric)";
3468
3469 blaze::CompressedMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 4UL );
3470 mat(0,1) = -2;
3471 mat(0,2) = 6;
3472 mat(1,1) = 3;
3473 mat(2,0) = 6;
3474
3475 OST sym( 3UL );
3476 sym(0,0) = 1;
3477 sym(0,1) = -4;
3478 sym(0,2) = 7;
3479 sym(1,1) = 2;
3480 sym(2,2) = 3;
3481
3482 try {
3483 sym -= mat;
3484
3485 std::ostringstream oss;
3486 oss << " Test: " << test_ << "\n"
3487 << " Error: Subtraction assignment of non-symmetric column-major matrix succeeded\n"
3488 << " Details:\n"
3489 << " Result:\n" << sym << "\n";
3490 throw std::runtime_error( oss.str() );
3491 }
3492 catch( std::invalid_argument& ) {}
3493 }
3494
3495 // Column-major/row-major sparse matrix subtraction assignment (SymmetricMatrix)
3496 {
3497 test_ = "Column-major/row-major SymmetricMatrix sparse matrix subtraction assignment (SymmetricMatrix)";
3498
3499 blaze::SymmetricMatrix< blaze::CompressedMatrix<int,blaze::rowMajor> > sym1( 3UL, 5UL );
3500 sym1(0,1) = -2;
3501 sym1(0,2) = 6;
3502 sym1(1,1) = 3;
3503
3504 OST sym2( 3UL );
3505 sym2(0,0) = 1;
3506 sym2(0,1) = -4;
3507 sym2(0,2) = 7;
3508 sym2(1,1) = 2;
3509 sym2(2,2) = 3;
3510
3511 sym2 -= sym1;
3512
3513 checkRows ( sym2, 3UL );
3514 checkColumns ( sym2, 3UL );
3515 checkCapacity( sym2, 7UL );
3516 checkNonZeros( sym2, 7UL );
3517 checkNonZeros( sym2, 0UL, 3UL );
3518 checkNonZeros( sym2, 1UL, 2UL );
3519 checkNonZeros( sym2, 2UL, 2UL );
3520
3521 if( sym2(0,0) != 1 || sym2(0,1) != -2 || sym2(0,2) != 1 ||
3522 sym2(1,0) != -2 || sym2(1,1) != -1 || sym2(1,2) != 0 ||
3523 sym2(2,0) != 1 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
3524 std::ostringstream oss;
3525 oss << " Test: " << test_ << "\n"
3526 << " Error: Subtraction assignment failed\n"
3527 << " Details:\n"
3528 << " Result:\n" << sym2 << "\n"
3529 << " Expected result:\n( 1 -2 1 )\n( -2 -1 0 )\n( 1 0 3 )\n";
3530 throw std::runtime_error( oss.str() );
3531 }
3532 }
3533
3534 // Column-major/column-major sparse matrix subtraction assignment (SymmetricMatrix)
3535 {
3536 test_ = "Column-major/column-major SymmetricMatrix sparse matrix subtraction assignment (SymmetricMatrix)";
3537
3538 blaze::SymmetricMatrix< blaze::CompressedMatrix<int,blaze::columnMajor> > sym1( 3UL, 5UL );
3539 sym1(0,1) = -2;
3540 sym1(0,2) = 6;
3541 sym1(1,1) = 3;
3542
3543 OST sym2( 3UL );
3544 sym2(0,0) = 1;
3545 sym2(0,1) = -4;
3546 sym2(0,2) = 7;
3547 sym2(1,1) = 2;
3548 sym2(2,2) = 3;
3549
3550 sym2 -= sym1;
3551
3552 checkRows ( sym2, 3UL );
3553 checkColumns ( sym2, 3UL );
3554 checkCapacity( sym2, 7UL );
3555 checkNonZeros( sym2, 7UL );
3556 checkNonZeros( sym2, 0UL, 3UL );
3557 checkNonZeros( sym2, 1UL, 2UL );
3558 checkNonZeros( sym2, 2UL, 2UL );
3559
3560 if( sym2(0,0) != 1 || sym2(0,1) != -2 || sym2(0,2) != 1 ||
3561 sym2(1,0) != -2 || sym2(1,1) != -1 || sym2(1,2) != 0 ||
3562 sym2(2,0) != 1 || sym2(2,1) != 0 || sym2(2,2) != 3 ) {
3563 std::ostringstream oss;
3564 oss << " Test: " << test_ << "\n"
3565 << " Error: Subtraction assignment failed\n"
3566 << " Details:\n"
3567 << " Result:\n" << sym2 << "\n"
3568 << " Expected result:\n( 1 -2 1 )\n( -2 -1 0 )\n( 1 0 3 )\n";
3569 throw std::runtime_error( oss.str() );
3570 }
3571 }
3572 }
3573 //*************************************************************************************************
3574
3575
3576 //*************************************************************************************************
3577 /*!\brief Test of the SymmetricMatrix Schur product assignment operators.
3578 //
3579 // \return void
3580 // \exception std::runtime_error Error detected.
3581 //
3582 // This function performs a test of the Schur product assignment operators of the SymmetricMatrix
3583 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
3584 */
testSchurAssign()3585 void SparseScalarTest::testSchurAssign()
3586 {
3587 //=====================================================================================
3588 // Row-major dense matrix Schur product assignment
3589 //=====================================================================================
3590
3591 // Row-major/row-major dense matrix Schur product assignment (symmetric)
3592 {
3593 test_ = "Row-major/row-major SymmetricMatrix dense matrix Schur product assignment (symmetric)";
3594
3595 blaze::DynamicMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 0 );
3596 mat(0,1) = -2;
3597 mat(0,2) = 6;
3598 mat(1,0) = -2;
3599 mat(1,1) = 3;
3600 mat(2,0) = 6;
3601
3602 ST sym( 3UL );
3603 sym(0,0) = 1;
3604 sym(0,1) = -4;
3605 sym(0,2) = 7;
3606 sym(1,1) = 2;
3607 sym(2,2) = 3;
3608
3609 sym %= mat;
3610
3611 checkRows ( sym, 3UL );
3612 checkColumns ( sym, 3UL );
3613 checkCapacity( sym, 7UL );
3614 checkNonZeros( sym, 7UL );
3615 checkNonZeros( sym, 0UL, 3UL );
3616 checkNonZeros( sym, 1UL, 2UL );
3617 checkNonZeros( sym, 2UL, 2UL );
3618
3619 if( sym(0,0) != 0 || sym(0,1) != 8 || sym(0,2) != 42 ||
3620 sym(1,0) != 8 || sym(1,1) != 6 || sym(1,2) != 0 ||
3621 sym(2,0) != 42 || sym(2,1) != 0 || sym(2,2) != 0 ) {
3622 std::ostringstream oss;
3623 oss << " Test: " << test_ << "\n"
3624 << " Error: Schur product assignment failed\n"
3625 << " Details:\n"
3626 << " Result:\n" << sym << "\n"
3627 << " Expected result:\n( 1 8 42 )\n( 8 6 0 )\n( 42 0 0 )\n";
3628 throw std::runtime_error( oss.str() );
3629 }
3630 }
3631
3632 // Row-major/column-major dense matrix Schur product assignment (symmetric)
3633 {
3634 test_ = "Row-major/column-major SymmetricMatrix dense matrix Schur product assignment (symmetric)";
3635
3636 blaze::DynamicMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 0 );
3637 mat(0,1) = -2;
3638 mat(0,2) = 6;
3639 mat(1,0) = -2;
3640 mat(1,1) = 3;
3641 mat(2,0) = 6;
3642
3643 ST sym( 3UL );
3644 sym(0,0) = 1;
3645 sym(0,1) = -4;
3646 sym(0,2) = 7;
3647 sym(1,1) = 2;
3648 sym(2,2) = 3;
3649
3650 sym %= mat;
3651
3652 checkRows ( sym, 3UL );
3653 checkColumns ( sym, 3UL );
3654 checkCapacity( sym, 7UL );
3655 checkNonZeros( sym, 7UL );
3656 checkNonZeros( sym, 0UL, 3UL );
3657 checkNonZeros( sym, 1UL, 2UL );
3658 checkNonZeros( sym, 2UL, 2UL );
3659
3660 if( sym(0,0) != 0 || sym(0,1) != 8 || sym(0,2) != 42 ||
3661 sym(1,0) != 8 || sym(1,1) != 6 || sym(1,2) != 0 ||
3662 sym(2,0) != 42 || sym(2,1) != 0 || sym(2,2) != 0 ) {
3663 std::ostringstream oss;
3664 oss << " Test: " << test_ << "\n"
3665 << " Error: Schur product assignment failed\n"
3666 << " Details:\n"
3667 << " Result:\n" << sym << "\n"
3668 << " Expected result:\n( 1 8 42 )\n( 8 6 0 )\n( 42 0 0 )\n";
3669 throw std::runtime_error( oss.str() );
3670 }
3671 }
3672
3673 // Row-major/row-major dense matrix Schur product assignment (non-symmetric)
3674 {
3675 test_ = "Row-major/row-major SymmetricMatrix dense matrix Schur product assignment (non-symmetric)";
3676
3677 blaze::DynamicMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 0 );
3678 mat(0,1) = -2;
3679 mat(0,2) = 6;
3680 mat(1,1) = 3;
3681 mat(2,0) = 6;
3682
3683 ST sym( 3UL );
3684 sym(0,0) = 1;
3685 sym(0,1) = -4;
3686 sym(0,2) = 7;
3687 sym(1,1) = 2;
3688 sym(2,2) = 3;
3689
3690 try {
3691 sym %= mat;
3692
3693 std::ostringstream oss;
3694 oss << " Test: " << test_ << "\n"
3695 << " Error: Schur product assignment of non-symmetric row-major matrix succeeded\n"
3696 << " Details:\n"
3697 << " Result:\n" << sym << "\n";
3698 throw std::runtime_error( oss.str() );
3699 }
3700 catch( std::invalid_argument& ) {}
3701 }
3702
3703 // Row-major/column-major dense matrix Schur product assignment (non-symmetric)
3704 {
3705 test_ = "Row-major/column-major SymmetricMatrix dense matrix Schur product assignment (non-symmetric)";
3706
3707 blaze::DynamicMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 0 );
3708 mat(0,1) = -2;
3709 mat(0,2) = 6;
3710 mat(1,1) = 3;
3711 mat(2,0) = 6;
3712
3713 ST sym( 3UL );
3714 sym(0,0) = 1;
3715 sym(0,1) = -4;
3716 sym(0,2) = 7;
3717 sym(1,1) = 2;
3718 sym(2,2) = 3;
3719
3720 try {
3721 sym %= mat;
3722
3723 std::ostringstream oss;
3724 oss << " Test: " << test_ << "\n"
3725 << " Error: Schur product assignment of non-symmetric column-major matrix succeeded\n"
3726 << " Details:\n"
3727 << " Result:\n" << sym << "\n";
3728 throw std::runtime_error( oss.str() );
3729 }
3730 catch( std::invalid_argument& ) {}
3731 }
3732
3733 // Row-major/row-major dense matrix Schur product assignment (SymmetricMatrix)
3734 {
3735 test_ = "Row-major/row-major SymmetricMatrix dense matrix Schur product assignment (SymmetricMatrix)";
3736
3737 ST sym1( 3UL );
3738 sym1(0,1) = -2;
3739 sym1(0,2) = 6;
3740 sym1(1,1) = 3;
3741
3742 ST sym2( 3UL );
3743 sym2(0,0) = 1;
3744 sym2(0,1) = -4;
3745 sym2(0,2) = 7;
3746 sym2(1,1) = 2;
3747 sym2(2,2) = 3;
3748
3749 sym2 %= sym1;
3750
3751 checkRows ( sym2, 3UL );
3752 checkColumns ( sym2, 3UL );
3753 checkCapacity( sym2, 5UL );
3754 checkNonZeros( sym2, 5UL );
3755 checkNonZeros( sym2, 0UL, 2UL );
3756 checkNonZeros( sym2, 1UL, 2UL );
3757 checkNonZeros( sym2, 2UL, 1UL );
3758
3759 if( sym2(0,0) != 0 || sym2(0,1) != 8 || sym2(0,2) != 42 ||
3760 sym2(1,0) != 8 || sym2(1,1) != 6 || sym2(1,2) != 0 ||
3761 sym2(2,0) != 42 || sym2(2,1) != 0 || sym2(2,2) != 0 ) {
3762 std::ostringstream oss;
3763 oss << " Test: " << test_ << "\n"
3764 << " Error: Schur product assignment failed\n"
3765 << " Details:\n"
3766 << " Result:\n" << sym2 << "\n"
3767 << " Expected result:\n( 1 8 42 )\n( 8 6 0 )\n( 42 0 0 )\n";
3768 throw std::runtime_error( oss.str() );
3769 }
3770 }
3771
3772 // Row-major/column-major dense matrix Schur product assignment (SymmetricMatrix)
3773 {
3774 test_ = "Row-major/column-major SymmetricMatrix dense matrix Schur product assignment (SymmetricMatrix)";
3775
3776 OST sym1( 3UL );
3777 sym1(0,1) = -2;
3778 sym1(0,2) = 6;
3779 sym1(1,1) = 3;
3780
3781 ST sym2( 3UL );
3782 sym2(0,0) = 1;
3783 sym2(0,1) = -4;
3784 sym2(0,2) = 7;
3785 sym2(1,1) = 2;
3786 sym2(2,2) = 3;
3787
3788 sym2 %= sym1;
3789
3790 checkRows ( sym2, 3UL );
3791 checkColumns ( sym2, 3UL );
3792 checkCapacity( sym2, 5UL );
3793 checkNonZeros( sym2, 5UL );
3794 checkNonZeros( sym2, 0UL, 2UL );
3795 checkNonZeros( sym2, 1UL, 2UL );
3796 checkNonZeros( sym2, 2UL, 1UL );
3797
3798 if( sym2(0,0) != 0 || sym2(0,1) != 8 || sym2(0,2) != 42 ||
3799 sym2(1,0) != 8 || sym2(1,1) != 6 || sym2(1,2) != 0 ||
3800 sym2(2,0) != 42 || sym2(2,1) != 0 || sym2(2,2) != 0 ) {
3801 std::ostringstream oss;
3802 oss << " Test: " << test_ << "\n"
3803 << " Error: Schur product assignment failed\n"
3804 << " Details:\n"
3805 << " Result:\n" << sym2 << "\n"
3806 << " Expected result:\n( 1 8 42 )\n( 8 6 0 )\n( 42 0 0 )\n";
3807 throw std::runtime_error( oss.str() );
3808 }
3809 }
3810
3811
3812 //=====================================================================================
3813 // Row-major sparse matrix Schur product assignment
3814 //=====================================================================================
3815
3816 // Row-major/row-major sparse matrix Schur product assignment (symmetric)
3817 {
3818 test_ = "Row-major/row-major SymmetricMatrix sparse matrix Schur product assignment (symmetric)";
3819
3820 blaze::CompressedMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 6UL );
3821 mat(0,1) = -2;
3822 mat(0,2) = 6;
3823 mat(1,0) = -2;
3824 mat(1,1) = 3;
3825 mat(2,0) = 6;
3826 mat.insert( 1UL, 2UL, 0 );
3827
3828 ST sym( 3UL );
3829 sym(0,0) = 1;
3830 sym(0,1) = -4;
3831 sym(0,2) = 7;
3832 sym(1,1) = 2;
3833 sym(2,2) = 3;
3834
3835 sym %= mat;
3836
3837 checkRows ( sym, 3UL );
3838 checkColumns ( sym, 3UL );
3839 checkCapacity( sym, 5UL );
3840 checkNonZeros( sym, 5UL );
3841 checkNonZeros( sym, 0UL, 2UL );
3842 checkNonZeros( sym, 1UL, 2UL );
3843 checkNonZeros( sym, 2UL, 1UL );
3844
3845 if( sym(0,0) != 0 || sym(0,1) != 8 || sym(0,2) != 42 ||
3846 sym(1,0) != 8 || sym(1,1) != 6 || sym(1,2) != 0 ||
3847 sym(2,0) != 42 || sym(2,1) != 0 || sym(2,2) != 0 ) {
3848 std::ostringstream oss;
3849 oss << " Test: " << test_ << "\n"
3850 << " Error: Schur product assignment failed\n"
3851 << " Details:\n"
3852 << " Result:\n" << sym << "\n"
3853 << " Expected result:\n( 1 8 42 )\n( 8 6 0 )\n( 42 0 0 )\n";
3854 throw std::runtime_error( oss.str() );
3855 }
3856 }
3857
3858 // Row-major/column-major sparse matrix Schur product assignment (symmetric)
3859 {
3860 test_ = "Row-major/column-major SymmetricMatrix sparse matrix Schur product assignment (symmetric)";
3861
3862 blaze::CompressedMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 6UL );
3863 mat(0,1) = -2;
3864 mat(0,2) = 6;
3865 mat(1,0) = -2;
3866 mat(1,1) = 3;
3867 mat(2,0) = 6;
3868 mat.insert( 1UL, 2UL, 0 );
3869
3870 ST sym( 3UL );
3871 sym(0,0) = 1;
3872 sym(0,1) = -4;
3873 sym(0,2) = 7;
3874 sym(1,1) = 2;
3875 sym(2,2) = 3;
3876
3877 sym %= mat;
3878
3879 checkRows ( sym, 3UL );
3880 checkColumns ( sym, 3UL );
3881 checkCapacity( sym, 5UL );
3882 checkNonZeros( sym, 5UL );
3883 checkNonZeros( sym, 0UL, 2UL );
3884 checkNonZeros( sym, 1UL, 2UL );
3885 checkNonZeros( sym, 2UL, 1UL );
3886
3887 if( sym(0,0) != 0 || sym(0,1) != 8 || sym(0,2) != 42 ||
3888 sym(1,0) != 8 || sym(1,1) != 6 || sym(1,2) != 0 ||
3889 sym(2,0) != 42 || sym(2,1) != 0 || sym(2,2) != 0 ) {
3890 std::ostringstream oss;
3891 oss << " Test: " << test_ << "\n"
3892 << " Error: Schur product assignment failed\n"
3893 << " Details:\n"
3894 << " Result:\n" << sym << "\n"
3895 << " Expected result:\n( 1 8 42 )\n( 8 6 0 )\n( 42 0 0 )\n";
3896 throw std::runtime_error( oss.str() );
3897 }
3898 }
3899
3900 // Row-major/row-major sparse matrix Schur product assignment (non-symmetric)
3901 {
3902 test_ = "Row-major/row-major SymmetricMatrix sparse matrix Schur product assignment (non-symmetric)";
3903
3904 blaze::CompressedMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 4UL );
3905 mat(0,1) = -2;
3906 mat(0,2) = 6;
3907 mat(1,1) = 3;
3908 mat(2,0) = 6;
3909
3910 ST sym( 3UL );
3911 sym(0,0) = 1;
3912 sym(0,1) = -4;
3913 sym(0,2) = 7;
3914 sym(1,1) = 2;
3915 sym(2,2) = 3;
3916
3917 try {
3918 sym %= mat;
3919
3920 std::ostringstream oss;
3921 oss << " Test: " << test_ << "\n"
3922 << " Error: Schur product assignment of non-symmetric row-major matrix succeeded\n"
3923 << " Details:\n"
3924 << " Result:\n" << sym << "\n";
3925 throw std::runtime_error( oss.str() );
3926 }
3927 catch( std::invalid_argument& ) {}
3928 }
3929
3930 // Row-major/column-major sparse matrix Schur product assignment (non-symmetric)
3931 {
3932 test_ = "Row-major/column-major SymmetricMatrix sparse matrix Schur product assignment (non-symmetric)";
3933
3934 blaze::CompressedMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 4UL );
3935 mat(0,1) = -2;
3936 mat(0,2) = 6;
3937 mat(1,1) = 3;
3938 mat(2,0) = 6;
3939
3940 ST sym( 3UL );
3941 sym(0,0) = 1;
3942 sym(0,1) = -4;
3943 sym(0,2) = 7;
3944 sym(1,1) = 2;
3945 sym(2,2) = 3;
3946
3947 try {
3948 sym %= mat;
3949
3950 std::ostringstream oss;
3951 oss << " Test: " << test_ << "\n"
3952 << " Error: Schur product assignment of non-symmetric column-major matrix succeeded\n"
3953 << " Details:\n"
3954 << " Result:\n" << sym << "\n";
3955 throw std::runtime_error( oss.str() );
3956 }
3957 catch( std::invalid_argument& ) {}
3958 }
3959
3960 // Row-major/row-major sparse matrix Schur product assignment (SymmetricMatrix)
3961 {
3962 test_ = "Row-major/row-major SymmetricMatrix sparse matrix Schur product assignment (SymmetricMatrix)";
3963
3964 blaze::SymmetricMatrix< blaze::CompressedMatrix<int,blaze::rowMajor> > sym1( 3UL, 5UL );
3965 sym1(0,1) = -2;
3966 sym1(0,2) = 6;
3967 sym1(1,1) = 3;
3968
3969 ST sym2( 3UL );
3970 sym2(0,0) = 1;
3971 sym2(0,1) = -4;
3972 sym2(0,2) = 7;
3973 sym2(1,1) = 2;
3974 sym2(2,2) = 3;
3975
3976 sym2 %= sym1;
3977
3978 checkRows ( sym2, 3UL );
3979 checkColumns ( sym2, 3UL );
3980 checkCapacity( sym2, 5UL );
3981 checkNonZeros( sym2, 5UL );
3982 checkNonZeros( sym2, 0UL, 2UL );
3983 checkNonZeros( sym2, 1UL, 2UL );
3984 checkNonZeros( sym2, 2UL, 1UL );
3985
3986 if( sym2(0,0) != 0 || sym2(0,1) != 8 || sym2(0,2) != 42 ||
3987 sym2(1,0) != 8 || sym2(1,1) != 6 || sym2(1,2) != 0 ||
3988 sym2(2,0) != 42 || sym2(2,1) != 0 || sym2(2,2) != 0 ) {
3989 std::ostringstream oss;
3990 oss << " Test: " << test_ << "\n"
3991 << " Error: Schur product assignment failed\n"
3992 << " Details:\n"
3993 << " Result:\n" << sym2 << "\n"
3994 << " Expected result:\n( 1 8 42 )\n( 8 6 0 )\n( 42 0 0 )\n";
3995 throw std::runtime_error( oss.str() );
3996 }
3997 }
3998
3999 // Row-major/column-major sparse matrix Schur product assignment (SymmetricMatrix)
4000 {
4001 test_ = "Row-major/column-major SymmetricMatrix sparse matrix Schur product assignment (SymmetricMatrix)";
4002
4003 blaze::SymmetricMatrix< blaze::CompressedMatrix<int,blaze::columnMajor> > sym1( 3UL, 5UL );
4004 sym1(0,1) = -2;
4005 sym1(0,2) = 6;
4006 sym1(1,1) = 3;
4007
4008 ST sym2( 3UL );
4009 sym2(0,0) = 1;
4010 sym2(0,1) = -4;
4011 sym2(0,2) = 7;
4012 sym2(1,1) = 2;
4013 sym2(2,2) = 3;
4014
4015 sym2 %= sym1;
4016
4017 checkRows ( sym2, 3UL );
4018 checkColumns ( sym2, 3UL );
4019 checkCapacity( sym2, 5UL );
4020 checkNonZeros( sym2, 5UL );
4021 checkNonZeros( sym2, 0UL, 2UL );
4022 checkNonZeros( sym2, 1UL, 2UL );
4023 checkNonZeros( sym2, 2UL, 1UL );
4024
4025 if( sym2(0,0) != 0 || sym2(0,1) != 8 || sym2(0,2) != 42 ||
4026 sym2(1,0) != 8 || sym2(1,1) != 6 || sym2(1,2) != 0 ||
4027 sym2(2,0) != 42 || sym2(2,1) != 0 || sym2(2,2) != 0 ) {
4028 std::ostringstream oss;
4029 oss << " Test: " << test_ << "\n"
4030 << " Error: Schur product assignment failed\n"
4031 << " Details:\n"
4032 << " Result:\n" << sym2 << "\n"
4033 << " Expected result:\n( 1 8 42 )\n( 8 6 0 )\n( 42 0 0 )\n";
4034 throw std::runtime_error( oss.str() );
4035 }
4036 }
4037
4038
4039 //=====================================================================================
4040 // Column-major dense matrix Schur product assignment
4041 //=====================================================================================
4042
4043 // Column-major/row-major dense matrix Schur product assignment (symmetric)
4044 {
4045 test_ = "Column-major/row-major SymmetricMatrix dense matrix Schur product assignment (symmetric)";
4046
4047 blaze::DynamicMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 0 );
4048 mat(0,1) = -2;
4049 mat(0,2) = 6;
4050 mat(1,0) = -2;
4051 mat(1,1) = 3;
4052 mat(2,0) = 6;
4053
4054 OST sym( 3UL );
4055 sym(0,0) = 1;
4056 sym(0,1) = -4;
4057 sym(0,2) = 7;
4058 sym(1,1) = 2;
4059 sym(2,2) = 3;
4060
4061 sym %= mat;
4062
4063 checkRows ( sym, 3UL );
4064 checkColumns ( sym, 3UL );
4065 checkCapacity( sym, 7UL );
4066 checkNonZeros( sym, 7UL );
4067 checkNonZeros( sym, 0UL, 3UL );
4068 checkNonZeros( sym, 1UL, 2UL );
4069 checkNonZeros( sym, 2UL, 2UL );
4070
4071 if( sym(0,0) != 0 || sym(0,1) != 8 || sym(0,2) != 42 ||
4072 sym(1,0) != 8 || sym(1,1) != 6 || sym(1,2) != 0 ||
4073 sym(2,0) != 42 || sym(2,1) != 0 || sym(2,2) != 0 ) {
4074 std::ostringstream oss;
4075 oss << " Test: " << test_ << "\n"
4076 << " Error: Schur product assignment failed\n"
4077 << " Details:\n"
4078 << " Result:\n" << sym << "\n"
4079 << " Expected result:\n( 1 8 42 )\n( 8 6 0 )\n( 42 0 0 )\n";
4080 throw std::runtime_error( oss.str() );
4081 }
4082 }
4083
4084 // Column-major/column-major dense matrix Schur product assignment (symmetric)
4085 {
4086 test_ = "Column-major/column-major SymmetricMatrix dense matrix Schur product assignment (symmetric)";
4087
4088 blaze::DynamicMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 0 );
4089 mat(0,1) = -2;
4090 mat(0,2) = 6;
4091 mat(1,0) = -2;
4092 mat(1,1) = 3;
4093 mat(2,0) = 6;
4094
4095 OST sym( 3UL );
4096 sym(0,0) = 1;
4097 sym(0,1) = -4;
4098 sym(0,2) = 7;
4099 sym(1,1) = 2;
4100 sym(2,2) = 3;
4101
4102 sym %= mat;
4103
4104 checkRows ( sym, 3UL );
4105 checkColumns ( sym, 3UL );
4106 checkCapacity( sym, 7UL );
4107 checkNonZeros( sym, 7UL );
4108 checkNonZeros( sym, 0UL, 3UL );
4109 checkNonZeros( sym, 1UL, 2UL );
4110 checkNonZeros( sym, 2UL, 2UL );
4111
4112 if( sym(0,0) != 0 || sym(0,1) != 8 || sym(0,2) != 42 ||
4113 sym(1,0) != 8 || sym(1,1) != 6 || sym(1,2) != 0 ||
4114 sym(2,0) != 42 || sym(2,1) != 0 || sym(2,2) != 0 ) {
4115 std::ostringstream oss;
4116 oss << " Test: " << test_ << "\n"
4117 << " Error: Schur product assignment failed\n"
4118 << " Details:\n"
4119 << " Result:\n" << sym << "\n"
4120 << " Expected result:\n( 1 8 42 )\n( 8 6 0 )\n( 42 0 0 )\n";
4121 throw std::runtime_error( oss.str() );
4122 }
4123 }
4124
4125 // Column-major/row-major dense matrix Schur product assignment (non-symmetric)
4126 {
4127 test_ = "Column-major/row-major SymmetricMatrix dense matrix Schur product assignment (non-symmetric)";
4128
4129 blaze::DynamicMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 0 );
4130 mat(0,1) = -2;
4131 mat(0,2) = 6;
4132 mat(1,1) = 3;
4133 mat(2,0) = 6;
4134
4135 OST sym( 3UL );
4136 sym(0,0) = 1;
4137 sym(0,1) = -4;
4138 sym(0,2) = 7;
4139 sym(1,1) = 2;
4140 sym(2,2) = 3;
4141
4142 try {
4143 sym %= mat;
4144
4145 std::ostringstream oss;
4146 oss << " Test: " << test_ << "\n"
4147 << " Error: Schur product assignment of non-symmetric row-major matrix succeeded\n"
4148 << " Details:\n"
4149 << " Result:\n" << sym << "\n";
4150 throw std::runtime_error( oss.str() );
4151 }
4152 catch( std::invalid_argument& ) {}
4153 }
4154
4155 // Column-major/column-major dense matrix Schur product assignment (non-symmetric)
4156 {
4157 test_ = "Column-major/column-major SymmetricMatrix dense matrix Schur product assignment (non-symmetric)";
4158
4159 blaze::DynamicMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 0 );
4160 mat(0,1) = -2;
4161 mat(0,2) = 6;
4162 mat(1,1) = 3;
4163 mat(2,0) = 6;
4164
4165 OST sym( 3UL );
4166 sym(0,0) = 1;
4167 sym(0,1) = -4;
4168 sym(0,2) = 7;
4169 sym(1,1) = 2;
4170 sym(2,2) = 3;
4171
4172 try {
4173 sym %= mat;
4174
4175 std::ostringstream oss;
4176 oss << " Test: " << test_ << "\n"
4177 << " Error: Schur product assignment of non-symmetric column-major matrix succeeded\n"
4178 << " Details:\n"
4179 << " Result:\n" << sym << "\n";
4180 throw std::runtime_error( oss.str() );
4181 }
4182 catch( std::invalid_argument& ) {}
4183 }
4184
4185 // Column-major/row-major dense matrix Schur product assignment (SymmetricMatrix)
4186 {
4187 test_ = "Column-major/row-major SymmetricMatrix dense matrix Schur product assignment (SymmetricMatrix)";
4188
4189 ST sym1( 3UL );
4190 sym1(0,1) = -2;
4191 sym1(0,2) = 6;
4192 sym1(1,1) = 3;
4193
4194 OST sym2( 3UL );
4195 sym2(0,0) = 1;
4196 sym2(0,1) = -4;
4197 sym2(0,2) = 7;
4198 sym2(1,1) = 2;
4199 sym2(2,2) = 3;
4200
4201 sym2 %= sym1;
4202
4203 checkRows ( sym2, 3UL );
4204 checkColumns ( sym2, 3UL );
4205 checkCapacity( sym2, 5UL );
4206 checkNonZeros( sym2, 5UL );
4207 checkNonZeros( sym2, 0UL, 2UL );
4208 checkNonZeros( sym2, 1UL, 2UL );
4209 checkNonZeros( sym2, 2UL, 1UL );
4210
4211 if( sym2(0,0) != 0 || sym2(0,1) != 8 || sym2(0,2) != 42 ||
4212 sym2(1,0) != 8 || sym2(1,1) != 6 || sym2(1,2) != 0 ||
4213 sym2(2,0) != 42 || sym2(2,1) != 0 || sym2(2,2) != 0 ) {
4214 std::ostringstream oss;
4215 oss << " Test: " << test_ << "\n"
4216 << " Error: Schur product assignment failed\n"
4217 << " Details:\n"
4218 << " Result:\n" << sym2 << "\n"
4219 << " Expected result:\n( 1 8 42 )\n( 8 6 0 )\n( 42 0 0 )\n";
4220 throw std::runtime_error( oss.str() );
4221 }
4222 }
4223
4224 // Column-major/column-major dense matrix Schur product assignment (SymmetricMatrix)
4225 {
4226 test_ = "Column-major/column-major SymmetricMatrix dense matrix Schur product assignment (SymmetricMatrix)";
4227
4228 OST sym1( 3UL );
4229 sym1(0,1) = -2;
4230 sym1(0,2) = 6;
4231 sym1(1,1) = 3;
4232
4233 OST sym2( 3UL );
4234 sym2(0,0) = 1;
4235 sym2(0,1) = -4;
4236 sym2(0,2) = 7;
4237 sym2(1,1) = 2;
4238 sym2(2,2) = 3;
4239
4240 sym2 %= sym1;
4241
4242 checkRows ( sym2, 3UL );
4243 checkColumns ( sym2, 3UL );
4244 checkCapacity( sym2, 5UL );
4245 checkNonZeros( sym2, 5UL );
4246 checkNonZeros( sym2, 0UL, 2UL );
4247 checkNonZeros( sym2, 1UL, 2UL );
4248 checkNonZeros( sym2, 2UL, 1UL );
4249
4250 if( sym2(0,0) != 0 || sym2(0,1) != 8 || sym2(0,2) != 42 ||
4251 sym2(1,0) != 8 || sym2(1,1) != 6 || sym2(1,2) != 0 ||
4252 sym2(2,0) != 42 || sym2(2,1) != 0 || sym2(2,2) != 0 ) {
4253 std::ostringstream oss;
4254 oss << " Test: " << test_ << "\n"
4255 << " Error: Schur product assignment failed\n"
4256 << " Details:\n"
4257 << " Result:\n" << sym2 << "\n"
4258 << " Expected result:\n( 1 8 42 )\n( 8 6 0 )\n( 42 0 0 )\n";
4259 throw std::runtime_error( oss.str() );
4260 }
4261 }
4262
4263
4264 //=====================================================================================
4265 // Column-major sparse matrix Schur product assignment
4266 //=====================================================================================
4267
4268 // Column-major/row-major sparse matrix Schur product assignment (symmetric)
4269 {
4270 test_ = "Column-major/row-major SymmetricMatrix sparse matrix Schur product assignment (symmetric)";
4271
4272 blaze::CompressedMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 6UL );
4273 mat(0,1) = -2;
4274 mat(0,2) = 6;
4275 mat(1,0) = -2;
4276 mat(1,1) = 3;
4277 mat(2,0) = 6;
4278 mat.insert( 1UL, 2UL, 0 );
4279
4280 OST sym( 3UL );
4281 sym(0,0) = 1;
4282 sym(0,1) = -4;
4283 sym(0,2) = 7;
4284 sym(1,1) = 2;
4285 sym(2,2) = 3;
4286
4287 sym %= mat;
4288
4289 checkRows ( sym, 3UL );
4290 checkColumns ( sym, 3UL );
4291 checkCapacity( sym, 5UL );
4292 checkNonZeros( sym, 5UL );
4293 checkNonZeros( sym, 0UL, 2UL );
4294 checkNonZeros( sym, 1UL, 2UL );
4295 checkNonZeros( sym, 2UL, 1UL );
4296
4297 if( sym(0,0) != 0 || sym(0,1) != 8 || sym(0,2) != 42 ||
4298 sym(1,0) != 8 || sym(1,1) != 6 || sym(1,2) != 0 ||
4299 sym(2,0) != 42 || sym(2,1) != 0 || sym(2,2) != 0 ) {
4300 std::ostringstream oss;
4301 oss << " Test: " << test_ << "\n"
4302 << " Error: Schur product assignment failed\n"
4303 << " Details:\n"
4304 << " Result:\n" << sym << "\n"
4305 << " Expected result:\n( 1 8 42 )\n( 8 6 0 )\n( 42 0 0 )\n";
4306 throw std::runtime_error( oss.str() );
4307 }
4308 }
4309
4310 // Column-major/column-major sparse matrix Schur product assignment (symmetric)
4311 {
4312 test_ = "Column-major/column-major SymmetricMatrix sparse matrix Schur product assignment (symmetric)";
4313
4314 blaze::CompressedMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 6UL );
4315 mat(0,1) = -2;
4316 mat(0,2) = 6;
4317 mat(1,0) = -2;
4318 mat(1,1) = 3;
4319 mat(2,0) = 6;
4320 mat.insert( 1UL, 2UL, 0 );
4321
4322 OST sym( 3UL );
4323 sym(0,0) = 1;
4324 sym(0,1) = -4;
4325 sym(0,2) = 7;
4326 sym(1,1) = 2;
4327 sym(2,2) = 3;
4328
4329 sym %= mat;
4330
4331 checkRows ( sym, 3UL );
4332 checkColumns ( sym, 3UL );
4333 checkCapacity( sym, 5UL );
4334 checkNonZeros( sym, 5UL );
4335 checkNonZeros( sym, 0UL, 2UL );
4336 checkNonZeros( sym, 1UL, 2UL );
4337 checkNonZeros( sym, 2UL, 1UL );
4338
4339 if( sym(0,0) != 0 || sym(0,1) != 8 || sym(0,2) != 42 ||
4340 sym(1,0) != 8 || sym(1,1) != 6 || sym(1,2) != 0 ||
4341 sym(2,0) != 42 || sym(2,1) != 0 || sym(2,2) != 0 ) {
4342 std::ostringstream oss;
4343 oss << " Test: " << test_ << "\n"
4344 << " Error: Schur product assignment failed\n"
4345 << " Details:\n"
4346 << " Result:\n" << sym << "\n"
4347 << " Expected result:\n( 1 8 42 )\n( 8 6 0 )\n( 42 0 0 )\n";
4348 throw std::runtime_error( oss.str() );
4349 }
4350 }
4351
4352 // Column-major/row-major sparse matrix Schur product assignment (non-symmetric)
4353 {
4354 test_ = "Column-major/row-major SymmetricMatrix sparse matrix Schur product assignment (non-symmetric)";
4355
4356 blaze::CompressedMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 4UL );
4357 mat(0,1) = -2;
4358 mat(0,2) = 6;
4359 mat(1,1) = 3;
4360 mat(2,0) = 6;
4361
4362 OST sym( 3UL );
4363 sym(0,0) = 1;
4364 sym(0,1) = -4;
4365 sym(0,2) = 7;
4366 sym(1,1) = 2;
4367 sym(2,2) = 3;
4368
4369 try {
4370 sym %= mat;
4371
4372 std::ostringstream oss;
4373 oss << " Test: " << test_ << "\n"
4374 << " Error: Schur product assignment of non-symmetric row-major matrix succeeded\n"
4375 << " Details:\n"
4376 << " Result:\n" << sym << "\n";
4377 throw std::runtime_error( oss.str() );
4378 }
4379 catch( std::invalid_argument& ) {}
4380 }
4381
4382 // Column-major/column-major sparse matrix Schur product assignment (non-symmetric)
4383 {
4384 test_ = "Column-major/column-major SymmetricMatrix sparse matrix Schur product assignment (non-symmetric)";
4385
4386 blaze::CompressedMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 4UL );
4387 mat(0,1) = -2;
4388 mat(0,2) = 6;
4389 mat(1,1) = 3;
4390 mat(2,0) = 6;
4391
4392 OST sym( 3UL );
4393 sym(0,0) = 1;
4394 sym(0,1) = -4;
4395 sym(0,2) = 7;
4396 sym(1,1) = 2;
4397 sym(2,2) = 3;
4398
4399 try {
4400 sym %= mat;
4401
4402 std::ostringstream oss;
4403 oss << " Test: " << test_ << "\n"
4404 << " Error: Schur product assignment of non-symmetric column-major matrix succeeded\n"
4405 << " Details:\n"
4406 << " Result:\n" << sym << "\n";
4407 throw std::runtime_error( oss.str() );
4408 }
4409 catch( std::invalid_argument& ) {}
4410 }
4411
4412 // Column-major/row-major sparse matrix Schur product assignment (SymmetricMatrix)
4413 {
4414 test_ = "Column-major/row-major SymmetricMatrix sparse matrix Schur product assignment (SymmetricMatrix)";
4415
4416 blaze::SymmetricMatrix< blaze::CompressedMatrix<int,blaze::rowMajor> > sym1( 3UL, 5UL );
4417 sym1(0,1) = -2;
4418 sym1(0,2) = 6;
4419 sym1(1,1) = 3;
4420
4421 OST sym2( 3UL );
4422 sym2(0,0) = 1;
4423 sym2(0,1) = -4;
4424 sym2(0,2) = 7;
4425 sym2(1,1) = 2;
4426 sym2(2,2) = 3;
4427
4428 sym2 %= sym1;
4429
4430 checkRows ( sym2, 3UL );
4431 checkColumns ( sym2, 3UL );
4432 checkCapacity( sym2, 5UL );
4433 checkNonZeros( sym2, 5UL );
4434 checkNonZeros( sym2, 0UL, 2UL );
4435 checkNonZeros( sym2, 1UL, 2UL );
4436 checkNonZeros( sym2, 2UL, 1UL );
4437
4438 if( sym2(0,0) != 0 || sym2(0,1) != 8 || sym2(0,2) != 42 ||
4439 sym2(1,0) != 8 || sym2(1,1) != 6 || sym2(1,2) != 0 ||
4440 sym2(2,0) != 42 || sym2(2,1) != 0 || sym2(2,2) != 0 ) {
4441 std::ostringstream oss;
4442 oss << " Test: " << test_ << "\n"
4443 << " Error: Schur product assignment failed\n"
4444 << " Details:\n"
4445 << " Result:\n" << sym2 << "\n"
4446 << " Expected result:\n( 1 8 42 )\n( 8 6 0 )\n( 42 0 0 )\n";
4447 throw std::runtime_error( oss.str() );
4448 }
4449 }
4450
4451 // Column-major/column-major sparse matrix Schur product assignment (SymmetricMatrix)
4452 {
4453 test_ = "Column-major/column-major SymmetricMatrix sparse matrix Schur product assignment (SymmetricMatrix)";
4454
4455 blaze::SymmetricMatrix< blaze::CompressedMatrix<int,blaze::columnMajor> > sym1( 3UL, 5UL );
4456 sym1(0,1) = -2;
4457 sym1(0,2) = 6;
4458 sym1(1,1) = 3;
4459
4460 OST sym2( 3UL );
4461 sym2(0,0) = 1;
4462 sym2(0,1) = -4;
4463 sym2(0,2) = 7;
4464 sym2(1,1) = 2;
4465 sym2(2,2) = 3;
4466
4467 sym2 %= sym1;
4468
4469 checkRows ( sym2, 3UL );
4470 checkColumns ( sym2, 3UL );
4471 checkCapacity( sym2, 5UL );
4472 checkNonZeros( sym2, 5UL );
4473 checkNonZeros( sym2, 0UL, 2UL );
4474 checkNonZeros( sym2, 1UL, 2UL );
4475 checkNonZeros( sym2, 2UL, 1UL );
4476
4477 if( sym2(0,0) != 0 || sym2(0,1) != 8 || sym2(0,2) != 42 ||
4478 sym2(1,0) != 8 || sym2(1,1) != 6 || sym2(1,2) != 0 ||
4479 sym2(2,0) != 42 || sym2(2,1) != 0 || sym2(2,2) != 0 ) {
4480 std::ostringstream oss;
4481 oss << " Test: " << test_ << "\n"
4482 << " Error: Schur product assignment failed\n"
4483 << " Details:\n"
4484 << " Result:\n" << sym2 << "\n"
4485 << " Expected result:\n( 1 8 42 )\n( 8 6 0 )\n( 42 0 0 )\n";
4486 throw std::runtime_error( oss.str() );
4487 }
4488 }
4489 }
4490 //*************************************************************************************************
4491
4492
4493 //*************************************************************************************************
4494 /*!\brief Test of the SymmetricMatrix multiplication assignment operators.
4495 //
4496 // \return void
4497 // \exception std::runtime_error Error detected.
4498 //
4499 // This function performs a test of the multiplication assignment operators of the SymmetricMatrix
4500 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
4501 */
testMultAssign()4502 void SparseScalarTest::testMultAssign()
4503 {
4504 //=====================================================================================
4505 // Row-major dense matrix multiplication assignment
4506 //=====================================================================================
4507
4508 // Row-major/row-major dense matrix multiplication assignment (symmetric)
4509 {
4510 test_ = "Row-major/row-major SymmetricMatrix dense matrix multiplication assignment (symmetric)";
4511
4512 blaze::DynamicMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 0 );
4513 mat(0,0) = 2;
4514 mat(1,1) = 2;
4515 mat(2,2) = 2;
4516
4517 ST sym( 3UL );
4518 sym(0,0) = 1;
4519 sym(0,1) = -4;
4520 sym(0,2) = 7;
4521 sym(1,1) = 2;
4522 sym(2,2) = 3;
4523
4524 sym *= mat;
4525
4526 checkRows ( sym, 3UL );
4527 checkColumns ( sym, 3UL );
4528 checkCapacity( sym, 7UL );
4529 checkNonZeros( sym, 7UL );
4530 checkNonZeros( sym, 0UL, 3UL );
4531 checkNonZeros( sym, 1UL, 2UL );
4532 checkNonZeros( sym, 2UL, 2UL );
4533
4534 if( sym(0,0) != 2 || sym(0,1) != -8 || sym(0,2) != 14 ||
4535 sym(1,0) != -8 || sym(1,1) != 4 || sym(1,2) != 0 ||
4536 sym(2,0) != 14 || sym(2,1) != 0 || sym(2,2) != 6 ) {
4537 std::ostringstream oss;
4538 oss << " Test: " << test_ << "\n"
4539 << " Error: Multiplication assignment failed\n"
4540 << " Details:\n"
4541 << " Result:\n" << sym << "\n"
4542 << " Expected result:\n( 2 -8 14 )\n( -8 4 0 )\n( 14 0 6 )\n";
4543 throw std::runtime_error( oss.str() );
4544 }
4545 }
4546
4547 // Row-major/column-major dense matrix multiplication assignment (symmetric)
4548 {
4549 test_ = "Row-major/column-major SymmetricMatrix dense matrix multiplication assignment (symmetric)";
4550
4551 blaze::DynamicMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 0 );
4552 mat(0,0) = 2;
4553 mat(1,1) = 2;
4554 mat(2,2) = 2;
4555
4556 ST sym( 3UL );
4557 sym(0,0) = 1;
4558 sym(0,1) = -4;
4559 sym(0,2) = 7;
4560 sym(1,1) = 2;
4561 sym(2,2) = 3;
4562
4563 sym *= mat;
4564
4565 checkRows ( sym, 3UL );
4566 checkColumns ( sym, 3UL );
4567 checkCapacity( sym, 7UL );
4568 checkNonZeros( sym, 7UL );
4569 checkNonZeros( sym, 0UL, 3UL );
4570 checkNonZeros( sym, 1UL, 2UL );
4571 checkNonZeros( sym, 2UL, 2UL );
4572
4573 if( sym(0,0) != 2 || sym(0,1) != -8 || sym(0,2) != 14 ||
4574 sym(1,0) != -8 || sym(1,1) != 4 || sym(1,2) != 0 ||
4575 sym(2,0) != 14 || sym(2,1) != 0 || sym(2,2) != 6 ) {
4576 std::ostringstream oss;
4577 oss << " Test: " << test_ << "\n"
4578 << " Error: Multiplication assignment failed\n"
4579 << " Details:\n"
4580 << " Result:\n" << sym << "\n"
4581 << " Expected result:\n( 2 -8 14 )\n( -8 4 0 )\n( 14 0 6 )\n";
4582 throw std::runtime_error( oss.str() );
4583 }
4584 }
4585
4586 // Row-major/row-major dense matrix multiplication assignment (non-symmetric)
4587 {
4588 test_ = "Row-major/row-major SymmetricMatrix dense matrix multiplication assignment (non-symmetric)";
4589
4590 blaze::DynamicMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 0 );
4591 mat(0,1) = -2;
4592 mat(0,2) = 6;
4593 mat(1,1) = 3;
4594 mat(2,0) = 6;
4595
4596 ST sym( 3UL );
4597 sym(0,0) = 1;
4598 sym(0,1) = -4;
4599 sym(0,2) = 7;
4600 sym(1,1) = 2;
4601 sym(2,2) = 3;
4602
4603 try {
4604 sym *= mat;
4605
4606 std::ostringstream oss;
4607 oss << " Test: " << test_ << "\n"
4608 << " Error: Multiplication assignment of non-symmetric row-major matrix succeeded\n"
4609 << " Details:\n"
4610 << " Result:\n" << sym << "\n";
4611 throw std::runtime_error( oss.str() );
4612 }
4613 catch( std::invalid_argument& ) {}
4614 }
4615
4616 // Row-major/column-major dense matrix multiplication assignment (non-symmetric)
4617 {
4618 test_ = "Row-major/column-major SymmetricMatrix dense matrix multiplication assignment (non-symmetric)";
4619
4620 blaze::DynamicMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 0 );
4621 mat(0,1) = -2;
4622 mat(0,2) = 6;
4623 mat(1,1) = 3;
4624 mat(2,0) = 6;
4625
4626 ST sym( 3UL );
4627 sym(0,0) = 1;
4628 sym(0,1) = -4;
4629 sym(0,2) = 7;
4630 sym(1,1) = 2;
4631 sym(2,2) = 3;
4632
4633 try {
4634 sym *= mat;
4635
4636 std::ostringstream oss;
4637 oss << " Test: " << test_ << "\n"
4638 << " Error: Multiplication assignment of non-symmetric column-major matrix succeeded\n"
4639 << " Details:\n"
4640 << " Result:\n" << sym << "\n";
4641 throw std::runtime_error( oss.str() );
4642 }
4643 catch( std::invalid_argument& ) {}
4644 }
4645
4646 // Row-major/row-major dense matrix multiplication assignment (SymmetricMatrix)
4647 {
4648 test_ = "Row-major/row-major SymmetricMatrix dense matrix multiplication assignment (SymmetricMatrix)";
4649
4650 ST sym1( 3UL );
4651 sym1(0,0) = 2;
4652 sym1(1,1) = 2;
4653 sym1(2,2) = 2;
4654
4655 ST sym2( 3UL );
4656 sym2(0,0) = 1;
4657 sym2(0,1) = -4;
4658 sym2(0,2) = 7;
4659 sym2(1,1) = 2;
4660 sym2(2,2) = 3;
4661
4662 sym2 *= sym1;
4663
4664 checkRows ( sym2, 3UL );
4665 checkColumns ( sym2, 3UL );
4666 checkCapacity( sym2, 7UL );
4667 checkNonZeros( sym2, 7UL );
4668 checkNonZeros( sym2, 0UL, 3UL );
4669 checkNonZeros( sym2, 1UL, 2UL );
4670 checkNonZeros( sym2, 2UL, 2UL );
4671
4672 if( sym2(0,0) != 2 || sym2(0,1) != -8 || sym2(0,2) != 14 ||
4673 sym2(1,0) != -8 || sym2(1,1) != 4 || sym2(1,2) != 0 ||
4674 sym2(2,0) != 14 || sym2(2,1) != 0 || sym2(2,2) != 6 ) {
4675 std::ostringstream oss;
4676 oss << " Test: " << test_ << "\n"
4677 << " Error: Multiplication assignment failed\n"
4678 << " Details:\n"
4679 << " Result:\n" << sym2 << "\n"
4680 << " Expected result:\n( 2 -8 14 )\n( -8 4 0 )\n( 14 0 6 )\n";
4681 throw std::runtime_error( oss.str() );
4682 }
4683 }
4684
4685 // Row-major/column-major dense matrix multiplication assignment (SymmetricMatrix)
4686 {
4687 test_ = "Row-major/column-major SymmetricMatrix dense matrix multiplication assignment (SymmetricMatrix)";
4688
4689 OST sym1( 3UL );
4690 sym1(0,0) = 2;
4691 sym1(1,1) = 2;
4692 sym1(2,2) = 2;
4693
4694 ST sym2( 3UL );
4695 sym2(0,0) = 1;
4696 sym2(0,1) = -4;
4697 sym2(0,2) = 7;
4698 sym2(1,1) = 2;
4699 sym2(2,2) = 3;
4700
4701 sym2 *= sym1;
4702
4703 checkRows ( sym2, 3UL );
4704 checkColumns ( sym2, 3UL );
4705 checkCapacity( sym2, 7UL );
4706 checkNonZeros( sym2, 7UL );
4707 checkNonZeros( sym2, 0UL, 3UL );
4708 checkNonZeros( sym2, 1UL, 2UL );
4709 checkNonZeros( sym2, 2UL, 2UL );
4710
4711 if( sym2(0,0) != 2 || sym2(0,1) != -8 || sym2(0,2) != 14 ||
4712 sym2(1,0) != -8 || sym2(1,1) != 4 || sym2(1,2) != 0 ||
4713 sym2(2,0) != 14 || sym2(2,1) != 0 || sym2(2,2) != 6 ) {
4714 std::ostringstream oss;
4715 oss << " Test: " << test_ << "\n"
4716 << " Error: Multiplication assignment failed\n"
4717 << " Details:\n"
4718 << " Result:\n" << sym2 << "\n"
4719 << " Expected result:\n( 2 -8 14 )\n( -8 4 0 )\n( 14 0 6 )\n";
4720 throw std::runtime_error( oss.str() );
4721 }
4722 }
4723
4724
4725 //=====================================================================================
4726 // Row-major sparse matrix multiplication assignment
4727 //=====================================================================================
4728
4729 // Row-major/row-major sparse matrix multiplication assignment (symmetric)
4730 {
4731 test_ = "Row-major/row-major SymmetricMatrix sparse matrix multiplication assignment (symmetric)";
4732
4733 blaze::CompressedMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 4UL );
4734 mat(0,0) = 2;
4735 mat(1,1) = 2;
4736 mat(2,2) = 2;
4737 mat.insert( 1UL, 2UL, 0 );
4738
4739 ST sym( 3UL );
4740 sym(0,0) = 1;
4741 sym(0,1) = -4;
4742 sym(0,2) = 7;
4743 sym(1,1) = 2;
4744 sym(2,2) = 3;
4745
4746 sym *= mat;
4747
4748 checkRows ( sym, 3UL );
4749 checkColumns ( sym, 3UL );
4750 checkCapacity( sym, 7UL );
4751 checkNonZeros( sym, 7UL );
4752 checkNonZeros( sym, 0UL, 3UL );
4753 checkNonZeros( sym, 1UL, 2UL );
4754 checkNonZeros( sym, 2UL, 2UL );
4755
4756 if( sym(0,0) != 2 || sym(0,1) != -8 || sym(0,2) != 14 ||
4757 sym(1,0) != -8 || sym(1,1) != 4 || sym(1,2) != 0 ||
4758 sym(2,0) != 14 || sym(2,1) != 0 || sym(2,2) != 6 ) {
4759 std::ostringstream oss;
4760 oss << " Test: " << test_ << "\n"
4761 << " Error: Multiplication assignment failed\n"
4762 << " Details:\n"
4763 << " Result:\n" << sym << "\n"
4764 << " Expected result:\n( 2 -8 14 )\n( -8 4 0 )\n( 14 0 6 )\n";
4765 throw std::runtime_error( oss.str() );
4766 }
4767 }
4768
4769 // Row-major/column-major sparse matrix multiplication assignment (symmetric)
4770 {
4771 test_ = "Row-major/column-major SymmetricMatrix sparse matrix multiplication assignment (symmetric)";
4772
4773 blaze::CompressedMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 4UL );
4774 mat(0,0) = 2;
4775 mat(1,1) = 2;
4776 mat(2,2) = 2;
4777 mat.insert( 1UL, 2UL, 0 );
4778
4779 ST sym( 3UL );
4780 sym(0,0) = 1;
4781 sym(0,1) = -4;
4782 sym(0,2) = 7;
4783 sym(1,1) = 2;
4784 sym(2,2) = 3;
4785
4786 sym *= mat;
4787
4788 checkRows ( sym, 3UL );
4789 checkColumns ( sym, 3UL );
4790 checkCapacity( sym, 7UL );
4791 checkNonZeros( sym, 7UL );
4792 checkNonZeros( sym, 0UL, 3UL );
4793 checkNonZeros( sym, 1UL, 2UL );
4794 checkNonZeros( sym, 2UL, 2UL );
4795
4796 if( sym(0,0) != 2 || sym(0,1) != -8 || sym(0,2) != 14 ||
4797 sym(1,0) != -8 || sym(1,1) != 4 || sym(1,2) != 0 ||
4798 sym(2,0) != 14 || sym(2,1) != 0 || sym(2,2) != 6 ) {
4799 std::ostringstream oss;
4800 oss << " Test: " << test_ << "\n"
4801 << " Error: Multiplication assignment failed\n"
4802 << " Details:\n"
4803 << " Result:\n" << sym << "\n"
4804 << " Expected result:\n( 2 -8 14 )\n( -8 4 0 )\n( 14 0 6 )\n";
4805 throw std::runtime_error( oss.str() );
4806 }
4807 }
4808
4809 // Row-major/row-major sparse matrix multiplication assignment (non-symmetric)
4810 {
4811 test_ = "Row-major/row-major SymmetricMatrix sparse matrix multiplication assignment (non-symmetric)";
4812
4813 blaze::CompressedMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 4UL );
4814 mat(0,1) = -2;
4815 mat(0,2) = 6;
4816 mat(1,1) = 3;
4817 mat(2,0) = 6;
4818
4819 ST sym( 3UL );
4820 sym(0,0) = 1;
4821 sym(0,1) = -4;
4822 sym(0,2) = 7;
4823 sym(1,1) = 2;
4824 sym(2,2) = 3;
4825
4826 try {
4827 sym *= mat;
4828
4829 std::ostringstream oss;
4830 oss << " Test: " << test_ << "\n"
4831 << " Error: Multiplication assignment of non-symmetric row-major matrix succeeded\n"
4832 << " Details:\n"
4833 << " Result:\n" << sym << "\n";
4834 throw std::runtime_error( oss.str() );
4835 }
4836 catch( std::invalid_argument& ) {}
4837 }
4838
4839 // Row-major/column-major sparse matrix multiplication assignment (non-symmetric)
4840 {
4841 test_ = "Row-major/column-major SymmetricMatrix sparse matrix multiplication assignment (non-symmetric)";
4842
4843 blaze::CompressedMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 4UL );
4844 mat(0,1) = -2;
4845 mat(0,2) = 6;
4846 mat(1,1) = 3;
4847 mat(2,0) = 6;
4848
4849 ST sym( 3UL );
4850 sym(0,0) = 1;
4851 sym(0,1) = -4;
4852 sym(0,2) = 7;
4853 sym(1,1) = 2;
4854 sym(2,2) = 3;
4855
4856 try {
4857 sym *= mat;
4858
4859 std::ostringstream oss;
4860 oss << " Test: " << test_ << "\n"
4861 << " Error: Multiplication assignment of non-symmetric column-major matrix succeeded\n"
4862 << " Details:\n"
4863 << " Result:\n" << sym << "\n";
4864 throw std::runtime_error( oss.str() );
4865 }
4866 catch( std::invalid_argument& ) {}
4867 }
4868
4869 // Row-major/row-major sparse matrix multiplication assignment (SymmetricMatrix)
4870 {
4871 test_ = "Row-major/row-major SymmetricMatrix sparse matrix multiplication assignment (SymmetricMatrix)";
4872
4873 blaze::SymmetricMatrix< blaze::CompressedMatrix<int,blaze::rowMajor> > sym1( 3UL, 3UL );
4874 sym1(0,0) = 2;
4875 sym1(1,1) = 2;
4876 sym1(2,2) = 2;
4877
4878 ST sym2( 3UL );
4879 sym2(0,0) = 1;
4880 sym2(0,1) = -4;
4881 sym2(0,2) = 7;
4882 sym2(1,1) = 2;
4883 sym2(2,2) = 3;
4884
4885 sym2 *= sym1;
4886
4887 checkRows ( sym2, 3UL );
4888 checkColumns ( sym2, 3UL );
4889 checkCapacity( sym2, 7UL );
4890 checkNonZeros( sym2, 7UL );
4891 checkNonZeros( sym2, 0UL, 3UL );
4892 checkNonZeros( sym2, 1UL, 2UL );
4893 checkNonZeros( sym2, 2UL, 2UL );
4894
4895 if( sym2(0,0) != 2 || sym2(0,1) != -8 || sym2(0,2) != 14 ||
4896 sym2(1,0) != -8 || sym2(1,1) != 4 || sym2(1,2) != 0 ||
4897 sym2(2,0) != 14 || sym2(2,1) != 0 || sym2(2,2) != 6 ) {
4898 std::ostringstream oss;
4899 oss << " Test: " << test_ << "\n"
4900 << " Error: Multiplication assignment failed\n"
4901 << " Details:\n"
4902 << " Result:\n" << sym2 << "\n"
4903 << " Expected result:\n( 2 -8 14 )\n( -8 4 0 )\n( 14 0 6 )\n";
4904 throw std::runtime_error( oss.str() );
4905 }
4906 }
4907
4908 // Row-major/column-major sparse matrix multiplication assignment (SymmetricMatrix)
4909 {
4910 test_ = "Row-major/column-major SymmetricMatrix sparse matrix multiplication assignment (SymmetricMatrix)";
4911
4912 blaze::SymmetricMatrix< blaze::CompressedMatrix<int,blaze::columnMajor> > sym1( 3UL, 3UL );
4913 sym1(0,0) = 2;
4914 sym1(1,1) = 2;
4915 sym1(2,2) = 2;
4916
4917 ST sym2( 3UL );
4918 sym2(0,0) = 1;
4919 sym2(0,1) = -4;
4920 sym2(0,2) = 7;
4921 sym2(1,1) = 2;
4922 sym2(2,2) = 3;
4923
4924 sym2 *= sym1;
4925
4926 checkRows ( sym2, 3UL );
4927 checkColumns ( sym2, 3UL );
4928 checkCapacity( sym2, 7UL );
4929 checkNonZeros( sym2, 7UL );
4930 checkNonZeros( sym2, 0UL, 3UL );
4931 checkNonZeros( sym2, 1UL, 2UL );
4932 checkNonZeros( sym2, 2UL, 2UL );
4933
4934 if( sym2(0,0) != 2 || sym2(0,1) != -8 || sym2(0,2) != 14 ||
4935 sym2(1,0) != -8 || sym2(1,1) != 4 || sym2(1,2) != 0 ||
4936 sym2(2,0) != 14 || sym2(2,1) != 0 || sym2(2,2) != 6 ) {
4937 std::ostringstream oss;
4938 oss << " Test: " << test_ << "\n"
4939 << " Error: Multiplication assignment failed\n"
4940 << " Details:\n"
4941 << " Result:\n" << sym2 << "\n"
4942 << " Expected result:\n( 2 -8 14 )\n( -8 4 0 )\n( 14 0 6 )\n";
4943 throw std::runtime_error( oss.str() );
4944 }
4945 }
4946
4947
4948 //=====================================================================================
4949 // Column-major dense matrix multiplication assignment
4950 //=====================================================================================
4951
4952 // Column-major/row-major dense matrix multiplication assignment (symmetric)
4953 {
4954 test_ = "Column-major/row-major SymmetricMatrix dense matrix multiplication assignment (symmetric)";
4955
4956 blaze::DynamicMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 0 );
4957 mat(0,0) = 2;
4958 mat(1,1) = 2;
4959 mat(2,2) = 2;
4960
4961 OST sym( 3UL );
4962 sym(0,0) = 1;
4963 sym(0,1) = -4;
4964 sym(0,2) = 7;
4965 sym(1,1) = 2;
4966 sym(2,2) = 3;
4967
4968 sym *= mat;
4969
4970 checkRows ( sym, 3UL );
4971 checkColumns ( sym, 3UL );
4972 checkCapacity( sym, 7UL );
4973 checkNonZeros( sym, 7UL );
4974 checkNonZeros( sym, 0UL, 3UL );
4975 checkNonZeros( sym, 1UL, 2UL );
4976 checkNonZeros( sym, 2UL, 2UL );
4977
4978 if( sym(0,0) != 2 || sym(0,1) != -8 || sym(0,2) != 14 ||
4979 sym(1,0) != -8 || sym(1,1) != 4 || sym(1,2) != 0 ||
4980 sym(2,0) != 14 || sym(2,1) != 0 || sym(2,2) != 6 ) {
4981 std::ostringstream oss;
4982 oss << " Test: " << test_ << "\n"
4983 << " Error: Multiplication assignment failed\n"
4984 << " Details:\n"
4985 << " Result:\n" << sym << "\n"
4986 << " Expected result:\n( 2 -8 14 )\n( -8 4 0 )\n( 14 0 6 )\n";
4987 throw std::runtime_error( oss.str() );
4988 }
4989 }
4990
4991 // Column-major/column-major dense matrix multiplication assignment (symmetric)
4992 {
4993 test_ = "Column-major/column-major SymmetricMatrix dense matrix multiplication assignment (symmetric)";
4994
4995 blaze::DynamicMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 0 );
4996 mat(0,0) = 2;
4997 mat(1,1) = 2;
4998 mat(2,2) = 2;
4999
5000 OST sym( 3UL );
5001 sym(0,0) = 1;
5002 sym(0,1) = -4;
5003 sym(0,2) = 7;
5004 sym(1,1) = 2;
5005 sym(2,2) = 3;
5006
5007 sym *= mat;
5008
5009 checkRows ( sym, 3UL );
5010 checkColumns ( sym, 3UL );
5011 checkCapacity( sym, 7UL );
5012 checkNonZeros( sym, 7UL );
5013 checkNonZeros( sym, 0UL, 3UL );
5014 checkNonZeros( sym, 1UL, 2UL );
5015 checkNonZeros( sym, 2UL, 2UL );
5016
5017 if( sym(0,0) != 2 || sym(0,1) != -8 || sym(0,2) != 14 ||
5018 sym(1,0) != -8 || sym(1,1) != 4 || sym(1,2) != 0 ||
5019 sym(2,0) != 14 || sym(2,1) != 0 || sym(2,2) != 6 ) {
5020 std::ostringstream oss;
5021 oss << " Test: " << test_ << "\n"
5022 << " Error: Multiplication assignment failed\n"
5023 << " Details:\n"
5024 << " Result:\n" << sym << "\n"
5025 << " Expected result:\n( 2 -8 14 )\n( -8 4 0 )\n( 14 0 6 )\n";
5026 throw std::runtime_error( oss.str() );
5027 }
5028 }
5029
5030 // Column-major/row-major dense matrix multiplication assignment (non-symmetric)
5031 {
5032 test_ = "Column-major/row-major SymmetricMatrix dense matrix multiplication assignment (non-symmetric)";
5033
5034 blaze::DynamicMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 0 );
5035 mat(0,1) = -2;
5036 mat(0,2) = 6;
5037 mat(1,1) = 3;
5038 mat(2,0) = 6;
5039
5040 OST sym( 3UL );
5041 sym(0,0) = 1;
5042 sym(0,1) = -4;
5043 sym(0,2) = 7;
5044 sym(1,1) = 2;
5045 sym(2,2) = 3;
5046
5047 try {
5048 sym *= mat;
5049
5050 std::ostringstream oss;
5051 oss << " Test: " << test_ << "\n"
5052 << " Error: Multiplication assignment of non-symmetric row-major matrix succeeded\n"
5053 << " Details:\n"
5054 << " Result:\n" << sym << "\n";
5055 throw std::runtime_error( oss.str() );
5056 }
5057 catch( std::invalid_argument& ) {}
5058 }
5059
5060 // Column-major/column-major dense matrix multiplication assignment (non-symmetric)
5061 {
5062 test_ = "Column-major/column-major SymmetricMatrix dense matrix multiplication assignment (non-symmetric)";
5063
5064 blaze::DynamicMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 0 );
5065 mat(0,1) = -2;
5066 mat(0,2) = 6;
5067 mat(1,1) = 3;
5068 mat(2,0) = 6;
5069
5070 OST sym( 3UL );
5071 sym(0,0) = 1;
5072 sym(0,1) = -4;
5073 sym(0,2) = 7;
5074 sym(1,1) = 2;
5075 sym(2,2) = 3;
5076
5077 try {
5078 sym *= mat;
5079
5080 std::ostringstream oss;
5081 oss << " Test: " << test_ << "\n"
5082 << " Error: Multiplication assignment of non-symmetric column-major matrix succeeded\n"
5083 << " Details:\n"
5084 << " Result:\n" << sym << "\n";
5085 throw std::runtime_error( oss.str() );
5086 }
5087 catch( std::invalid_argument& ) {}
5088 }
5089
5090 // Column-major/row-major dense matrix multiplication assignment (SymmetricMatrix)
5091 {
5092 test_ = "Column-major/row-major SymmetricMatrix dense matrix multiplication assignment (SymmetricMatrix)";
5093
5094 ST sym1( 3UL );
5095 sym1(0,0) = 2;
5096 sym1(1,1) = 2;
5097 sym1(2,2) = 2;
5098
5099 OST sym2( 3UL );
5100 sym2(0,0) = 1;
5101 sym2(0,1) = -4;
5102 sym2(0,2) = 7;
5103 sym2(1,1) = 2;
5104 sym2(2,2) = 3;
5105
5106 sym2 *= sym1;
5107
5108 checkRows ( sym2, 3UL );
5109 checkColumns ( sym2, 3UL );
5110 checkCapacity( sym2, 7UL );
5111 checkNonZeros( sym2, 7UL );
5112 checkNonZeros( sym2, 0UL, 3UL );
5113 checkNonZeros( sym2, 1UL, 2UL );
5114 checkNonZeros( sym2, 2UL, 2UL );
5115
5116 if( sym2(0,0) != 2 || sym2(0,1) != -8 || sym2(0,2) != 14 ||
5117 sym2(1,0) != -8 || sym2(1,1) != 4 || sym2(1,2) != 0 ||
5118 sym2(2,0) != 14 || sym2(2,1) != 0 || sym2(2,2) != 6 ) {
5119 std::ostringstream oss;
5120 oss << " Test: " << test_ << "\n"
5121 << " Error: Multiplication assignment failed\n"
5122 << " Details:\n"
5123 << " Result:\n" << sym2 << "\n"
5124 << " Expected result:\n( 2 -8 14 )\n( -8 4 0 )\n( 14 0 6 )\n";
5125 throw std::runtime_error( oss.str() );
5126 }
5127 }
5128
5129 // Column-major/column-major dense matrix multiplication assignment (SymmetricMatrix)
5130 {
5131 test_ = "Column-major/column-major SymmetricMatrix dense matrix multiplication assignment (SymmetricMatrix)";
5132
5133 OST sym1( 3UL );
5134 sym1(0,0) = 2;
5135 sym1(1,1) = 2;
5136 sym1(2,2) = 2;
5137
5138 OST sym2( 3UL );
5139 sym2(0,0) = 1;
5140 sym2(0,1) = -4;
5141 sym2(0,2) = 7;
5142 sym2(1,1) = 2;
5143 sym2(2,2) = 3;
5144
5145 sym2 *= sym1;
5146
5147 checkRows ( sym2, 3UL );
5148 checkColumns ( sym2, 3UL );
5149 checkCapacity( sym2, 7UL );
5150 checkNonZeros( sym2, 7UL );
5151 checkNonZeros( sym2, 0UL, 3UL );
5152 checkNonZeros( sym2, 1UL, 2UL );
5153 checkNonZeros( sym2, 2UL, 2UL );
5154
5155 if( sym2(0,0) != 2 || sym2(0,1) != -8 || sym2(0,2) != 14 ||
5156 sym2(1,0) != -8 || sym2(1,1) != 4 || sym2(1,2) != 0 ||
5157 sym2(2,0) != 14 || sym2(2,1) != 0 || sym2(2,2) != 6 ) {
5158 std::ostringstream oss;
5159 oss << " Test: " << test_ << "\n"
5160 << " Error: Multiplication assignment failed\n"
5161 << " Details:\n"
5162 << " Result:\n" << sym2 << "\n"
5163 << " Expected result:\n( 2 -8 14 )\n( -8 4 0 )\n( 14 0 6 )\n";
5164 throw std::runtime_error( oss.str() );
5165 }
5166 }
5167
5168
5169 //=====================================================================================
5170 // Column-major sparse matrix multiplication assignment
5171 //=====================================================================================
5172
5173 // Column-major/row-major sparse matrix multiplication assignment (symmetric)
5174 {
5175 test_ = "Column-major/row-major SymmetricMatrix sparse matrix multiplication assignment (symmetric)";
5176
5177 blaze::CompressedMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 4UL );
5178 mat(0,0) = 2;
5179 mat(1,1) = 2;
5180 mat(2,2) = 2;
5181 mat.insert( 1UL, 2UL, 0 );
5182
5183 OST sym( 3UL );
5184 sym(0,0) = 1;
5185 sym(0,1) = -4;
5186 sym(0,2) = 7;
5187 sym(1,1) = 2;
5188 sym(2,2) = 3;
5189
5190 sym *= mat;
5191
5192 checkRows ( sym, 3UL );
5193 checkColumns ( sym, 3UL );
5194 checkCapacity( sym, 7UL );
5195 checkNonZeros( sym, 7UL );
5196 checkNonZeros( sym, 0UL, 3UL );
5197 checkNonZeros( sym, 1UL, 2UL );
5198 checkNonZeros( sym, 2UL, 2UL );
5199
5200 if( sym(0,0) != 2 || sym(0,1) != -8 || sym(0,2) != 14 ||
5201 sym(1,0) != -8 || sym(1,1) != 4 || sym(1,2) != 0 ||
5202 sym(2,0) != 14 || sym(2,1) != 0 || sym(2,2) != 6 ) {
5203 std::ostringstream oss;
5204 oss << " Test: " << test_ << "\n"
5205 << " Error: Multiplication assignment failed\n"
5206 << " Details:\n"
5207 << " Result:\n" << sym << "\n"
5208 << " Expected result:\n( 2 -8 14 )\n( -8 4 0 )\n( 14 0 6 )\n";
5209 throw std::runtime_error( oss.str() );
5210 }
5211 }
5212
5213 // Column-major/column-major sparse matrix multiplication assignment (symmetric)
5214 {
5215 test_ = "Column-major/column-major SymmetricMatrix sparse matrix multiplication assignment (symmetric)";
5216
5217 blaze::CompressedMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 4UL );
5218 mat(0,0) = 2;
5219 mat(1,1) = 2;
5220 mat(2,2) = 2;
5221 mat.insert( 1UL, 2UL, 0 );
5222
5223 OST sym( 3UL );
5224 sym(0,0) = 1;
5225 sym(0,1) = -4;
5226 sym(0,2) = 7;
5227 sym(1,1) = 2;
5228 sym(2,2) = 3;
5229
5230 sym *= mat;
5231
5232 checkRows ( sym, 3UL );
5233 checkColumns ( sym, 3UL );
5234 checkCapacity( sym, 7UL );
5235 checkNonZeros( sym, 7UL );
5236 checkNonZeros( sym, 0UL, 3UL );
5237 checkNonZeros( sym, 1UL, 2UL );
5238 checkNonZeros( sym, 2UL, 2UL );
5239
5240 if( sym(0,0) != 2 || sym(0,1) != -8 || sym(0,2) != 14 ||
5241 sym(1,0) != -8 || sym(1,1) != 4 || sym(1,2) != 0 ||
5242 sym(2,0) != 14 || sym(2,1) != 0 || sym(2,2) != 6 ) {
5243 std::ostringstream oss;
5244 oss << " Test: " << test_ << "\n"
5245 << " Error: Multiplication assignment failed\n"
5246 << " Details:\n"
5247 << " Result:\n" << sym << "\n"
5248 << " Expected result:\n( 2 -8 14 )\n( -8 4 0 )\n( 14 0 6 )\n";
5249 throw std::runtime_error( oss.str() );
5250 }
5251 }
5252
5253 // Column-major/row-major sparse matrix multiplication assignment (non-symmetric)
5254 {
5255 test_ = "Column-major/row-major SymmetricMatrix sparse matrix multiplication assignment (non-symmetric)";
5256
5257 blaze::CompressedMatrix<int,blaze::rowMajor> mat( 3UL, 3UL, 4UL );
5258 mat(0,1) = -2;
5259 mat(0,2) = 6;
5260 mat(1,1) = 3;
5261 mat(2,0) = 6;
5262
5263 OST sym( 3UL );
5264 sym(0,0) = 1;
5265 sym(0,1) = -4;
5266 sym(0,2) = 7;
5267 sym(1,1) = 2;
5268 sym(2,2) = 3;
5269
5270 try {
5271 sym *= mat;
5272
5273 std::ostringstream oss;
5274 oss << " Test: " << test_ << "\n"
5275 << " Error: Multiplication assignment of non-symmetric row-major matrix succeeded\n"
5276 << " Details:\n"
5277 << " Result:\n" << sym << "\n";
5278 throw std::runtime_error( oss.str() );
5279 }
5280 catch( std::invalid_argument& ) {}
5281 }
5282
5283 // Column-major/column-major sparse matrix multiplication assignment (non-symmetric)
5284 {
5285 test_ = "Column-major/column-major SymmetricMatrix sparse matrix multiplication assignment (non-symmetric)";
5286
5287 blaze::CompressedMatrix<int,blaze::columnMajor> mat( 3UL, 3UL, 4UL );
5288 mat(0,1) = -2;
5289 mat(0,2) = 6;
5290 mat(1,1) = 3;
5291 mat(2,0) = 6;
5292
5293 OST sym( 3UL );
5294 sym(0,0) = 1;
5295 sym(0,1) = -4;
5296 sym(0,2) = 7;
5297 sym(1,1) = 2;
5298 sym(2,2) = 3;
5299
5300 try {
5301 sym *= mat;
5302
5303 std::ostringstream oss;
5304 oss << " Test: " << test_ << "\n"
5305 << " Error: Multiplication assignment of non-symmetric column-major matrix succeeded\n"
5306 << " Details:\n"
5307 << " Result:\n" << sym << "\n";
5308 throw std::runtime_error( oss.str() );
5309 }
5310 catch( std::invalid_argument& ) {}
5311 }
5312
5313 // Column-major/row-major sparse matrix multiplication assignment (SymmetricMatrix)
5314 {
5315 test_ = "Column-major/row-major SymmetricMatrix sparse matrix multiplication assignment (SymmetricMatrix)";
5316
5317 blaze::SymmetricMatrix< blaze::CompressedMatrix<int,blaze::rowMajor> > sym1( 3UL, 3UL );
5318 sym1(0,0) = 2;
5319 sym1(1,1) = 2;
5320 sym1(2,2) = 2;
5321
5322 OST sym2( 3UL );
5323 sym2(0,0) = 1;
5324 sym2(0,1) = -4;
5325 sym2(0,2) = 7;
5326 sym2(1,1) = 2;
5327 sym2(2,2) = 3;
5328
5329 sym2 *= sym1;
5330
5331 checkRows ( sym2, 3UL );
5332 checkColumns ( sym2, 3UL );
5333 checkCapacity( sym2, 7UL );
5334 checkNonZeros( sym2, 7UL );
5335 checkNonZeros( sym2, 0UL, 3UL );
5336 checkNonZeros( sym2, 1UL, 2UL );
5337 checkNonZeros( sym2, 2UL, 2UL );
5338
5339 if( sym2(0,0) != 2 || sym2(0,1) != -8 || sym2(0,2) != 14 ||
5340 sym2(1,0) != -8 || sym2(1,1) != 4 || sym2(1,2) != 0 ||
5341 sym2(2,0) != 14 || sym2(2,1) != 0 || sym2(2,2) != 6 ) {
5342 std::ostringstream oss;
5343 oss << " Test: " << test_ << "\n"
5344 << " Error: Multiplication assignment failed\n"
5345 << " Details:\n"
5346 << " Result:\n" << sym2 << "\n"
5347 << " Expected result:\n( 2 -8 14 )\n( -8 4 0 )\n( 14 0 6 )\n";
5348 throw std::runtime_error( oss.str() );
5349 }
5350 }
5351
5352 // Column-major/column-major sparse matrix multiplication assignment (SymmetricMatrix)
5353 {
5354 test_ = "Column-major/column-major SymmetricMatrix sparse matrix multiplication assignment (SymmetricMatrix)";
5355
5356 blaze::SymmetricMatrix< blaze::CompressedMatrix<int,blaze::columnMajor> > sym1( 3UL, 3UL );
5357 sym1(0,0) = 2;
5358 sym1(1,1) = 2;
5359 sym1(2,2) = 2;
5360
5361 OST sym2( 3UL );
5362 sym2(0,0) = 1;
5363 sym2(0,1) = -4;
5364 sym2(0,2) = 7;
5365 sym2(1,1) = 2;
5366 sym2(2,2) = 3;
5367
5368 sym2 *= sym1;
5369
5370 checkRows ( sym2, 3UL );
5371 checkColumns ( sym2, 3UL );
5372 checkCapacity( sym2, 7UL );
5373 checkNonZeros( sym2, 7UL );
5374 checkNonZeros( sym2, 0UL, 3UL );
5375 checkNonZeros( sym2, 1UL, 2UL );
5376 checkNonZeros( sym2, 2UL, 2UL );
5377
5378 if( sym2(0,0) != 2 || sym2(0,1) != -8 || sym2(0,2) != 14 ||
5379 sym2(1,0) != -8 || sym2(1,1) != 4 || sym2(1,2) != 0 ||
5380 sym2(2,0) != 14 || sym2(2,1) != 0 || sym2(2,2) != 6 ) {
5381 std::ostringstream oss;
5382 oss << " Test: " << test_ << "\n"
5383 << " Error: Multiplication assignment failed\n"
5384 << " Details:\n"
5385 << " Result:\n" << sym2 << "\n"
5386 << " Expected result:\n( 2 -8 14 )\n( -8 4 0 )\n( 14 0 6 )\n";
5387 throw std::runtime_error( oss.str() );
5388 }
5389 }
5390 }
5391 //*************************************************************************************************
5392
5393 } // namespace symmetricmatrix
5394
5395 } // namespace adaptors
5396
5397 } // namespace mathtest
5398
5399 } // namespace blazetest
5400
5401
5402
5403
5404 //=================================================================================================
5405 //
5406 // MAIN FUNCTION
5407 //
5408 //=================================================================================================
5409
5410 //*************************************************************************************************
main()5411 int main()
5412 {
5413 std::cout << " Running SymmetricMatrix sparse scalar test (part 1)..." << std::endl;
5414
5415 try
5416 {
5417 RUN_SYMMETRICMATRIX_SPARSESCALAR_TEST;
5418 }
5419 catch( std::exception& ex ) {
5420 std::cerr << "\n\n ERROR DETECTED during SymmetricMatrix sparse scalar test (part 1):\n"
5421 << ex.what() << "\n";
5422 return EXIT_FAILURE;
5423 }
5424
5425 return EXIT_SUCCESS;
5426 }
5427 //*************************************************************************************************
5428