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