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