1 //=================================================================================================
2 /*!
3 // \file src/mathtest/adaptors/uppermatrix/SparseTest2.cpp
4 // \brief Source file for the UpperMatrix sparse 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 <blaze/math/Column.h>
43 #include <blaze/math/Row.h>
44 #include <blaze/math/Submatrix.h>
45 #include <blaze/util/Complex.h>
46 #include <blazetest/mathtest/adaptors/uppermatrix/SparseTest.h>
47
48 #ifdef BLAZE_USE_HPX_THREADS
49 # include <hpx/hpx_main.hpp>
50 #endif
51
52
53 namespace blazetest {
54
55 namespace mathtest {
56
57 namespace adaptors {
58
59 namespace uppermatrix {
60
61 //=================================================================================================
62 //
63 // CONSTRUCTORS
64 //
65 //=================================================================================================
66
67 //*************************************************************************************************
68 /*!\brief Constructor for the UpperMatrix sparse test.
69 //
70 // \exception std::runtime_error Operation error detected.
71 */
SparseTest()72 SparseTest::SparseTest()
73 {
74 testScaling();
75 testFunctionCall();
76 testIterator();
77 testNonZeros();
78 testReset();
79 testClear();
80 testResize();
81 testReserve();
82 testTrim();
83 testShrinkToFit();
84 testSwap();
85 testSet();
86 testInsert();
87 testAppend();
88 testErase();
89 testFind();
90 testLowerBound();
91 testUpperBound();
92 testIsDefault();
93 testSubmatrix();
94 testRow();
95 testColumn();
96 }
97 //*************************************************************************************************
98
99
100
101
102 //=================================================================================================
103 //
104 // TEST FUNCTIONS
105 //
106 //=================================================================================================
107
108 //*************************************************************************************************
109 /*!\brief Test of all UpperMatrix (self-)scaling operations.
110 //
111 // \return void
112 // \exception std::runtime_error Error detected.
113 //
114 // This function performs a test of all available ways to scale an instance of the UpperMatrix
115 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
116 */
testScaling()117 void SparseTest::testScaling()
118 {
119 //=====================================================================================
120 // Row-major self-scaling (M*=s)
121 //=====================================================================================
122
123 {
124 test_ = "Row-major self-scaling (M*=s)";
125
126 UT upper( 3UL );
127 upper(0,1) = 1;
128 upper(0,2) = -2;
129 upper(1,2) = 3;
130 upper(2,2) = -4;
131
132 upper *= 2;
133
134 checkRows ( upper, 3UL );
135 checkColumns ( upper, 3UL );
136 checkCapacity( upper, 4UL );
137 checkNonZeros( upper, 4UL );
138 checkNonZeros( upper, 0UL, 2UL );
139 checkNonZeros( upper, 1UL, 1UL );
140 checkNonZeros( upper, 2UL, 1UL );
141
142 if( upper(0,0) != 0 || upper(0,1) != 2 || upper(0,2) != -4 ||
143 upper(1,0) != 0 || upper(1,1) != 0 || upper(1,2) != 6 ||
144 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != -8 ) {
145 std::ostringstream oss;
146 oss << " Test: " << test_ << "\n"
147 << " Error: Failed self-scaling operation\n"
148 << " Details:\n"
149 << " Result:\n" << upper << "\n"
150 << " Expected result:\n( 0 2 -4 )\n( 0 0 6 )\n( 0 0 -8 )\n";
151 throw std::runtime_error( oss.str() );
152 }
153 }
154
155
156 //=====================================================================================
157 // Row-major self-scaling (M=M*s)
158 //=====================================================================================
159
160 {
161 test_ = "Row-major self-scaling (M=M*s)";
162
163 UT upper( 3UL );
164 upper(0,1) = 1;
165 upper(0,2) = -2;
166 upper(1,2) = 3;
167 upper(2,2) = -4;
168
169 upper = upper * 2;
170
171 checkRows ( upper, 3UL );
172 checkColumns ( upper, 3UL );
173 checkCapacity( upper, 4UL );
174 checkNonZeros( upper, 4UL );
175 checkNonZeros( upper, 0UL, 2UL );
176 checkNonZeros( upper, 1UL, 1UL );
177 checkNonZeros( upper, 2UL, 1UL );
178
179 if( upper(0,0) != 0 || upper(0,1) != 2 || upper(0,2) != -4 ||
180 upper(1,0) != 0 || upper(1,1) != 0 || upper(1,2) != 6 ||
181 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != -8 ) {
182 std::ostringstream oss;
183 oss << " Test: " << test_ << "\n"
184 << " Error: Failed self-scaling operation\n"
185 << " Details:\n"
186 << " Result:\n" << upper << "\n"
187 << " Expected result:\n( 0 2 -4 )\n( 0 0 6 )\n( 0 0 -8 )\n";
188 throw std::runtime_error( oss.str() );
189 }
190 }
191
192
193 //=====================================================================================
194 // Row-major self-scaling (M=s*M)
195 //=====================================================================================
196
197 {
198 test_ = "Row-major self-scaling (M=s*M)";
199
200 UT upper( 3UL );
201 upper(0,1) = 1;
202 upper(0,2) = -2;
203 upper(1,2) = 3;
204 upper(2,2) = -4;
205
206 upper = 2 * upper;
207
208 checkRows ( upper, 3UL );
209 checkColumns ( upper, 3UL );
210 checkCapacity( upper, 4UL );
211 checkNonZeros( upper, 4UL );
212 checkNonZeros( upper, 0UL, 2UL );
213 checkNonZeros( upper, 1UL, 1UL );
214 checkNonZeros( upper, 2UL, 1UL );
215
216 if( upper(0,0) != 0 || upper(0,1) != 2 || upper(0,2) != -4 ||
217 upper(1,0) != 0 || upper(1,1) != 0 || upper(1,2) != 6 ||
218 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != -8 ) {
219 std::ostringstream oss;
220 oss << " Test: " << test_ << "\n"
221 << " Error: Failed self-scaling operation\n"
222 << " Details:\n"
223 << " Result:\n" << upper << "\n"
224 << " Expected result:\n( 0 2 -4 )\n( 0 0 6 )\n( 0 0 -8 )\n";
225 throw std::runtime_error( oss.str() );
226 }
227 }
228
229
230 //=====================================================================================
231 // Row-major self-scaling (M/=s)
232 //=====================================================================================
233
234 {
235 test_ = "Row-major self-scaling (M/=s)";
236
237 UT upper( 3UL );
238 upper(0,1) = 2;
239 upper(0,2) = -4;
240 upper(1,2) = 6;
241 upper(2,2) = -8;
242
243 upper /= 2;
244
245 checkRows ( upper, 3UL );
246 checkColumns ( upper, 3UL );
247 checkCapacity( upper, 4UL );
248 checkNonZeros( upper, 4UL );
249 checkNonZeros( upper, 0UL, 2UL );
250 checkNonZeros( upper, 1UL, 1UL );
251 checkNonZeros( upper, 2UL, 1UL );
252
253 if( upper(0,0) != 0 || upper(0,1) != 1 || upper(0,2) != -2 ||
254 upper(1,0) != 0 || upper(1,1) != 0 || upper(1,2) != 3 ||
255 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != -4 ) {
256 std::ostringstream oss;
257 oss << " Test: " << test_ << "\n"
258 << " Error: Failed self-scaling operation\n"
259 << " Details:\n"
260 << " Result:\n" << upper << "\n"
261 << " Expected result:\n( 0 1 -2 )\n( 0 0 3 )\n( 0 0 -4 )\n";
262 throw std::runtime_error( oss.str() );
263 }
264 }
265
266
267 //=====================================================================================
268 // Row-major self-scaling (M=M/s)
269 //=====================================================================================
270
271 {
272 test_ = "Row-major self-scaling (M=M/s)";
273
274 UT upper( 3UL );
275 upper(0,1) = 2;
276 upper(0,2) = -4;
277 upper(1,2) = 6;
278 upper(2,2) = -8;
279
280 upper = upper / 2;
281
282 checkRows ( upper, 3UL );
283 checkColumns ( upper, 3UL );
284 checkCapacity( upper, 4UL );
285 checkNonZeros( upper, 4UL );
286 checkNonZeros( upper, 0UL, 2UL );
287 checkNonZeros( upper, 1UL, 1UL );
288 checkNonZeros( upper, 2UL, 1UL );
289
290 if( upper(0,0) != 0 || upper(0,1) != 1 || upper(0,2) != -2 ||
291 upper(1,0) != 0 || upper(1,1) != 0 || upper(1,2) != 3 ||
292 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != -4 ) {
293 std::ostringstream oss;
294 oss << " Test: " << test_ << "\n"
295 << " Error: Failed self-scaling operation\n"
296 << " Details:\n"
297 << " Result:\n" << upper << "\n"
298 << " Expected result:\n( 0 1 -2 )\n( 0 0 3 )\n( 0 0 -4 )\n";
299 throw std::runtime_error( oss.str() );
300 }
301 }
302
303
304 //=====================================================================================
305 // Row-major UpperMatrix::scale()
306 //=====================================================================================
307
308 {
309 test_ = "Row-major UpperMatrix::scale()";
310
311 // Initialization check
312 UT upper( 3UL );
313 upper(0,1) = 1;
314 upper(0,2) = -2;
315 upper(1,2) = 3;
316 upper(2,2) = -4;
317
318 checkRows ( upper, 3UL );
319 checkColumns ( upper, 3UL );
320 checkCapacity( upper, 4UL );
321 checkNonZeros( upper, 4UL );
322 checkNonZeros( upper, 0UL, 2UL );
323 checkNonZeros( upper, 1UL, 1UL );
324 checkNonZeros( upper, 2UL, 1UL );
325
326 if( upper(0,0) != 0 || upper(0,1) != 1 || upper(0,2) != -2 ||
327 upper(1,0) != 0 || upper(1,1) != 0 || upper(1,2) != 3 ||
328 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != -4 ) {
329 std::ostringstream oss;
330 oss << " Test: " << test_ << "\n"
331 << " Error: Initialization failed\n"
332 << " Details:\n"
333 << " Result:\n" << upper << "\n"
334 << " Expected result:\n( 0 1 -2 )\n( 0 0 3 )\n( 0 0 -4 )\n";
335 throw std::runtime_error( oss.str() );
336 }
337
338 // Integral scaling of the matrix
339 upper.scale( 2 );
340
341 checkRows ( upper, 3UL );
342 checkColumns ( upper, 3UL );
343 checkCapacity( upper, 4UL );
344 checkNonZeros( upper, 4UL );
345 checkNonZeros( upper, 0UL, 2UL );
346 checkNonZeros( upper, 1UL, 1UL );
347 checkNonZeros( upper, 2UL, 1UL );
348
349 if( upper(0,0) != 0 || upper(0,1) != 2 || upper(0,2) != -4 ||
350 upper(1,0) != 0 || upper(1,1) != 0 || upper(1,2) != 6 ||
351 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != -8 ) {
352 std::ostringstream oss;
353 oss << " Test: " << test_ << "\n"
354 << " Error: Scale operation failed\n"
355 << " Details:\n"
356 << " Result:\n" << upper << "\n"
357 << " Expected result:\n( 0 2 -4 )\n( 0 0 6 )\n( 0 0 -8 )\n";
358 throw std::runtime_error( oss.str() );
359 }
360
361 // Floating point scaling of the matrix
362 upper.scale( 0.5 );
363
364 checkRows ( upper, 3UL );
365 checkColumns ( upper, 3UL );
366 checkCapacity( upper, 4UL );
367 checkNonZeros( upper, 4UL );
368 checkNonZeros( upper, 0UL, 2UL );
369 checkNonZeros( upper, 1UL, 1UL );
370 checkNonZeros( upper, 2UL, 1UL );
371
372 if( upper(0,0) != 0 || upper(0,1) != 1 || upper(0,2) != -2 ||
373 upper(1,0) != 0 || upper(1,1) != 0 || upper(1,2) != 3 ||
374 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != -4 ) {
375 std::ostringstream oss;
376 oss << " Test: " << test_ << "\n"
377 << " Error: Initialization failed\n"
378 << " Details:\n"
379 << " Result:\n" << upper << "\n"
380 << " Expected result:\n( 0 1 -2 )\n( 0 0 3 )\n( 0 0 -4 )\n";
381 throw std::runtime_error( oss.str() );
382 }
383 }
384
385 {
386 test_ = "Row-major UpperMatrix::scale() (complex)";
387
388 using blaze::complex;
389
390 blaze::UpperMatrix< blaze::CompressedMatrix<complex<float>,blaze::rowMajor> > upper( 2UL );
391 upper(0,0) = complex<float>( 1.0F, 0.0F );
392 upper(0,1) = complex<float>( 2.0F, 0.0F );
393 upper(1,1) = complex<float>( 4.0F, 0.0F );
394
395 upper.scale( complex<float>( 3.0F, 0.0F ) );
396
397 checkRows ( upper, 2UL );
398 checkColumns ( upper, 2UL );
399 checkCapacity( upper, 3UL );
400 checkNonZeros( upper, 3UL );
401 checkNonZeros( upper, 0UL, 2UL );
402 checkNonZeros( upper, 1UL, 1UL );
403
404 if( upper(0,0) != complex<float>( 3.0F, 0.0F ) || upper(0,1) != complex<float>( 6.0F, 0.0F ) ||
405 upper(1,0) != complex<float>( 0.0F, 0.0F ) || upper(1,1) != complex<float>( 12.0F, 0.0F ) ) {
406 std::ostringstream oss;
407 oss << " Test: " << test_ << "\n"
408 << " Error: Scale operation failed\n"
409 << " Details:\n"
410 << " Result:\n" << upper << "\n"
411 << " Expected result:\n( ( 3,0) ( 6,0)\n( 0,0) (12,0) )\n";
412 throw std::runtime_error( oss.str() );
413 }
414 }
415
416
417 //=====================================================================================
418 // Column-major self-scaling (M*=s)
419 //=====================================================================================
420
421 {
422 test_ = "Column-major self-scaling (M*=s)";
423
424 OUT upper( 3UL );
425 upper(0,1) = 1;
426 upper(0,2) = -2;
427 upper(1,2) = 3;
428 upper(2,2) = -4;
429
430 upper *= 2;
431
432 checkRows ( upper, 3UL );
433 checkColumns ( upper, 3UL );
434 checkCapacity( upper, 4UL );
435 checkNonZeros( upper, 4UL );
436 checkNonZeros( upper, 0UL, 0UL );
437 checkNonZeros( upper, 1UL, 1UL );
438 checkNonZeros( upper, 2UL, 3UL );
439
440 if( upper(0,0) != 0 || upper(0,1) != 2 || upper(0,2) != -4 ||
441 upper(1,0) != 0 || upper(1,1) != 0 || upper(1,2) != 6 ||
442 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != -8 ) {
443 std::ostringstream oss;
444 oss << " Test: " << test_ << "\n"
445 << " Error: Failed self-scaling operation\n"
446 << " Details:\n"
447 << " Result:\n" << upper << "\n"
448 << " Expected result:\n( 0 2 -4 )\n( 0 0 6 )\n( 0 0 -8 )\n";
449 throw std::runtime_error( oss.str() );
450 }
451 }
452
453
454 //=====================================================================================
455 // Column-major self-scaling (M=M*s)
456 //=====================================================================================
457
458 {
459 test_ = "Column-major self-scaling (M=M*s)";
460
461 OUT upper( 3UL );
462 upper(0,1) = 1;
463 upper(0,2) = -2;
464 upper(1,2) = 3;
465 upper(2,2) = -4;
466
467 upper = upper * 2;
468
469 checkRows ( upper, 3UL );
470 checkColumns ( upper, 3UL );
471 checkCapacity( upper, 4UL );
472 checkNonZeros( upper, 4UL );
473 checkNonZeros( upper, 0UL, 0UL );
474 checkNonZeros( upper, 1UL, 1UL );
475 checkNonZeros( upper, 2UL, 3UL );
476
477 if( upper(0,0) != 0 || upper(0,1) != 2 || upper(0,2) != -4 ||
478 upper(1,0) != 0 || upper(1,1) != 0 || upper(1,2) != 6 ||
479 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != -8 ) {
480 std::ostringstream oss;
481 oss << " Test: " << test_ << "\n"
482 << " Error: Failed self-scaling operation\n"
483 << " Details:\n"
484 << " Result:\n" << upper << "\n"
485 << " Expected result:\n( 0 2 -4 )\n( 0 0 6 )\n( 0 0 -8 )\n";
486 throw std::runtime_error( oss.str() );
487 }
488 }
489
490
491 //=====================================================================================
492 // Column-major self-scaling (M=s*M)
493 //=====================================================================================
494
495 {
496 test_ = "Column-major self-scaling (M=s*M)";
497
498 OUT upper( 3UL );
499 upper(0,1) = 1;
500 upper(0,2) = -2;
501 upper(1,2) = 3;
502 upper(2,2) = -4;
503
504 upper = 2 * upper;
505
506 checkRows ( upper, 3UL );
507 checkColumns ( upper, 3UL );
508 checkCapacity( upper, 4UL );
509 checkNonZeros( upper, 4UL );
510 checkNonZeros( upper, 0UL, 0UL );
511 checkNonZeros( upper, 1UL, 1UL );
512 checkNonZeros( upper, 2UL, 3UL );
513
514 if( upper(0,0) != 0 || upper(0,1) != 2 || upper(0,2) != -4 ||
515 upper(1,0) != 0 || upper(1,1) != 0 || upper(1,2) != 6 ||
516 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != -8 ) {
517 std::ostringstream oss;
518 oss << " Test: " << test_ << "\n"
519 << " Error: Failed self-scaling operation\n"
520 << " Details:\n"
521 << " Result:\n" << upper << "\n"
522 << " Expected result:\n( 0 2 -4 )\n( 0 0 6 )\n( 0 0 -8 )\n";
523 throw std::runtime_error( oss.str() );
524 }
525 }
526
527
528 //=====================================================================================
529 // Column-major self-scaling (M/=s)
530 //=====================================================================================
531
532 {
533 test_ = "Column-major self-scaling (M/=s)";
534
535 OUT upper( 3UL );
536 upper(0,1) = 2;
537 upper(0,2) = -4;
538 upper(1,2) = 6;
539 upper(2,2) = -8;
540
541 upper /= 2;
542
543 checkRows ( upper, 3UL );
544 checkColumns ( upper, 3UL );
545 checkCapacity( upper, 4UL );
546 checkNonZeros( upper, 4UL );
547 checkNonZeros( upper, 0UL, 0UL );
548 checkNonZeros( upper, 1UL, 1UL );
549 checkNonZeros( upper, 2UL, 3UL );
550
551 if( upper(0,0) != 0 || upper(0,1) != 1 || upper(0,2) != -2 ||
552 upper(1,0) != 0 || upper(1,1) != 0 || upper(1,2) != 3 ||
553 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != -4 ) {
554 std::ostringstream oss;
555 oss << " Test: " << test_ << "\n"
556 << " Error: Failed self-scaling operation\n"
557 << " Details:\n"
558 << " Result:\n" << upper << "\n"
559 << " Expected result:\n( 0 1 -2 )\n( 0 0 3 )\n( 0 0 -4 )\n";
560 throw std::runtime_error( oss.str() );
561 }
562 }
563
564
565 //=====================================================================================
566 // Column-major self-scaling (M=M/s)
567 //=====================================================================================
568
569 {
570 test_ = "Column-major self-scaling (M=M/s)";
571
572 OUT upper( 3UL );
573 upper(0,1) = 2;
574 upper(0,2) = -4;
575 upper(1,2) = 6;
576 upper(2,2) = -8;
577
578 upper = upper / 2;
579
580 checkRows ( upper, 3UL );
581 checkColumns ( upper, 3UL );
582 checkCapacity( upper, 4UL );
583 checkNonZeros( upper, 4UL );
584 checkNonZeros( upper, 0UL, 0UL );
585 checkNonZeros( upper, 1UL, 1UL );
586 checkNonZeros( upper, 2UL, 3UL );
587
588 if( upper(0,0) != 0 || upper(0,1) != 1 || upper(0,2) != -2 ||
589 upper(1,0) != 0 || upper(1,1) != 0 || upper(1,2) != 3 ||
590 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != -4 ) {
591 std::ostringstream oss;
592 oss << " Test: " << test_ << "\n"
593 << " Error: Failed self-scaling operation\n"
594 << " Details:\n"
595 << " Result:\n" << upper << "\n"
596 << " Expected result:\n( 0 1 -2 )\n( 0 0 3 )\n( 0 0 -4 )\n";
597 throw std::runtime_error( oss.str() );
598 }
599 }
600
601
602 //=====================================================================================
603 // Column-major UpperMatrix::scale()
604 //=====================================================================================
605
606 {
607 test_ = "Column-major UpperMatrix::scale()";
608
609 // Initialization check
610 OUT upper( 3UL );
611 upper(0,1) = 1;
612 upper(0,2) = -2;
613 upper(1,2) = 3;
614 upper(2,2) = -4;
615
616 checkRows ( upper, 3UL );
617 checkColumns ( upper, 3UL );
618 checkCapacity( upper, 4UL );
619 checkNonZeros( upper, 4UL );
620 checkNonZeros( upper, 0UL, 0UL );
621 checkNonZeros( upper, 1UL, 1UL );
622 checkNonZeros( upper, 2UL, 3UL );
623
624 if( upper(0,0) != 0 || upper(0,1) != 1 || upper(0,2) != -2 ||
625 upper(1,0) != 0 || upper(1,1) != 0 || upper(1,2) != 3 ||
626 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != -4 ) {
627 std::ostringstream oss;
628 oss << " Test: " << test_ << "\n"
629 << " Error: Initialization failed\n"
630 << " Details:\n"
631 << " Result:\n" << upper << "\n"
632 << " Expected result:\n( 0 1 -2 )\n( 0 0 3 )\n( 0 0 -4 )\n";
633 throw std::runtime_error( oss.str() );
634 }
635
636 // Integral scaling of the matrix
637 upper.scale( 2 );
638
639 checkRows ( upper, 3UL );
640 checkColumns ( upper, 3UL );
641 checkCapacity( upper, 4UL );
642 checkNonZeros( upper, 4UL );
643 checkNonZeros( upper, 0UL, 0UL );
644 checkNonZeros( upper, 1UL, 1UL );
645 checkNonZeros( upper, 2UL, 3UL );
646
647 if( upper(0,0) != 0 || upper(0,1) != 2 || upper(0,2) != -4 ||
648 upper(1,0) != 0 || upper(1,1) != 0 || upper(1,2) != 6 ||
649 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != -8 ) {
650 std::ostringstream oss;
651 oss << " Test: " << test_ << "\n"
652 << " Error: Scale operation failed\n"
653 << " Details:\n"
654 << " Result:\n" << upper << "\n"
655 << " Expected result:\n( 0 2 -4 )\n( 0 0 6 )\n( 0 0 -8 )\n";
656 throw std::runtime_error( oss.str() );
657 }
658
659 // Floating point scaling of the matrix
660 upper.scale( 0.5 );
661
662 checkRows ( upper, 3UL );
663 checkColumns ( upper, 3UL );
664 checkCapacity( upper, 4UL );
665 checkNonZeros( upper, 4UL );
666 checkNonZeros( upper, 0UL, 0UL );
667 checkNonZeros( upper, 1UL, 1UL );
668 checkNonZeros( upper, 2UL, 3UL );
669
670 if( upper(0,0) != 0 || upper(0,1) != 1 || upper(0,2) != -2 ||
671 upper(1,0) != 0 || upper(1,1) != 0 || upper(1,2) != 3 ||
672 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != -4 ) {
673 std::ostringstream oss;
674 oss << " Test: " << test_ << "\n"
675 << " Error: Initialization failed\n"
676 << " Details:\n"
677 << " Result:\n" << upper << "\n"
678 << " Expected result:\n( 0 1 -2 )\n( 0 0 3 )\n( 0 0 -4 )\n";
679 throw std::runtime_error( oss.str() );
680 }
681 }
682
683 {
684 test_ = "Column-major UpperMatrix::scale() (complex)";
685
686 using blaze::complex;
687
688 blaze::UpperMatrix< blaze::CompressedMatrix<complex<float>,blaze::columnMajor> > upper( 2UL );
689 upper(0,0) = complex<float>( 1.0F, 0.0F );
690 upper(0,1) = complex<float>( 2.0F, 0.0F );
691 upper(1,1) = complex<float>( 4.0F, 0.0F );
692
693 upper.scale( complex<float>( 3.0F, 0.0F ) );
694
695 checkRows ( upper, 2UL );
696 checkColumns ( upper, 2UL );
697 checkCapacity( upper, 3UL );
698 checkNonZeros( upper, 3UL );
699 checkNonZeros( upper, 0UL, 1UL );
700 checkNonZeros( upper, 1UL, 2UL );
701
702 if( upper(0,0) != complex<float>( 3.0F, 0.0F ) || upper(0,1) != complex<float>( 6.0F, 0.0F ) ||
703 upper(1,0) != complex<float>( 0.0F, 0.0F ) || upper(1,1) != complex<float>( 12.0F, 0.0F ) ) {
704 std::ostringstream oss;
705 oss << " Test: " << test_ << "\n"
706 << " Error: Scale operation failed\n"
707 << " Details:\n"
708 << " Result:\n" << upper << "\n"
709 << " Expected result:\n( ( 3,0) ( 6,0)\n( 0,0) (12,0) )\n";
710 throw std::runtime_error( oss.str() );
711 }
712 }
713 }
714 //*************************************************************************************************
715
716
717 //*************************************************************************************************
718 /*!\brief Test of the UpperMatrix function call operator.
719 //
720 // \return void
721 // \exception std::runtime_error Error detected.
722 //
723 // This function performs a test of adding and accessing elements via the function call operator
724 // of the UpperMatrix specialization. In case an error is detected, a \a std::runtime_error
725 // exception is thrown.
726 */
testFunctionCall()727 void SparseTest::testFunctionCall()
728 {
729 //=====================================================================================
730 // Row-major matrix tests
731 //=====================================================================================
732
733 {
734 test_ = "Row-major UpperMatrix::operator()";
735
736 // Good cases
737 {
738 UT upper( 3UL );
739
740 // Writing the diagonal element (1,1)
741 upper(1,1) = 1;
742
743 checkRows ( upper, 3UL );
744 checkColumns ( upper, 3UL );
745 checkCapacity( upper, 1UL );
746 checkNonZeros( upper, 1UL );
747 checkNonZeros( upper, 0UL, 0UL );
748 checkNonZeros( upper, 1UL, 1UL );
749 checkNonZeros( upper, 2UL, 0UL );
750
751 if( upper(0,0) != 0 || upper(0,1) != 0 || upper(0,2) != 0 ||
752 upper(1,0) != 0 || upper(1,1) != 1 || upper(1,2) != 0 ||
753 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 0 ) {
754 std::ostringstream oss;
755 oss << " Test: " << test_ << "\n"
756 << " Error: Function call operator failed\n"
757 << " Details:\n"
758 << " Result:\n" << upper << "\n"
759 << " Expected result:\n( 0 0 0 )\n( 0 1 0 )\n( 0 0 0 )\n";
760 throw std::runtime_error( oss.str() );
761 }
762
763 // Writing the upper element (1,2)
764 upper(1,2) = 2;
765
766 checkRows ( upper, 3UL );
767 checkColumns ( upper, 3UL );
768 checkCapacity( upper, 2UL );
769 checkNonZeros( upper, 2UL );
770 checkNonZeros( upper, 0UL, 0UL );
771 checkNonZeros( upper, 1UL, 2UL );
772 checkNonZeros( upper, 2UL, 0UL );
773
774 if( upper(0,0) != 0 || upper(0,1) != 0 || upper(0,2) != 0 ||
775 upper(1,0) != 0 || upper(1,1) != 1 || upper(1,2) != 2 ||
776 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 0 ) {
777 std::ostringstream oss;
778 oss << " Test: " << test_ << "\n"
779 << " Error: Function call operator failed\n"
780 << " Details:\n"
781 << " Result:\n" << upper << "\n"
782 << " Expected result:\n( 0 0 0 )\n( 0 1 2 )\n( 0 0 0 )\n";
783 throw std::runtime_error( oss.str() );
784 }
785
786 // Writing the element (0,1)
787 upper(0,1) = upper(1,2);
788
789 checkRows ( upper, 3UL );
790 checkColumns ( upper, 3UL );
791 checkCapacity( upper, 3UL );
792 checkNonZeros( upper, 3UL );
793 checkNonZeros( upper, 0UL, 1UL );
794 checkNonZeros( upper, 1UL, 2UL );
795 checkNonZeros( upper, 2UL, 0UL );
796
797 if( upper(0,0) != 0 || upper(0,1) != 2 || upper(0,2) != 0 ||
798 upper(1,0) != 0 || upper(1,1) != 1 || upper(1,2) != 2 ||
799 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 0 ) {
800 std::ostringstream oss;
801 oss << " Test: " << test_ << "\n"
802 << " Error: Function call operator failed\n"
803 << " Details:\n"
804 << " Result:\n" << upper << "\n"
805 << " Expected result:\n( 0 2 0 )\n( 0 1 2 )\n( 0 0 0 )\n";
806 throw std::runtime_error( oss.str() );
807 }
808
809 // Adding to the upper element (0,2)
810 upper(0,2) += 3;
811
812 checkRows ( upper, 3UL );
813 checkColumns ( upper, 3UL );
814 checkCapacity( upper, 4UL );
815 checkNonZeros( upper, 4UL );
816 checkNonZeros( upper, 0UL, 2UL );
817 checkNonZeros( upper, 1UL, 2UL );
818 checkNonZeros( upper, 2UL, 0UL );
819
820 if( upper(0,0) != 0 || upper(0,1) != 2 || upper(0,2) != 3 ||
821 upper(1,0) != 0 || upper(1,1) != 1 || upper(1,2) != 2 ||
822 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 0 ) {
823 std::ostringstream oss;
824 oss << " Test: " << test_ << "\n"
825 << " Error: Function call operator failed\n"
826 << " Details:\n"
827 << " Result:\n" << upper << "\n"
828 << " Expected result:\n( 0 0 0 )\n( 2 1 0 )\n( 3 2 0 )\n";
829 throw std::runtime_error( oss.str() );
830 }
831
832 // Subtracting from the upper element (0,1)
833 upper(0,1) -= 4;
834
835 checkRows ( upper, 3UL );
836 checkColumns ( upper, 3UL );
837 checkCapacity( upper, 4UL );
838 checkNonZeros( upper, 4UL );
839 checkNonZeros( upper, 0UL, 2UL );
840 checkNonZeros( upper, 1UL, 2UL );
841 checkNonZeros( upper, 2UL, 0UL );
842
843 if( upper(0,0) != 0 || upper(0,1) != -2 || upper(0,2) != 3 ||
844 upper(1,0) != 0 || upper(1,1) != 1 || upper(1,2) != 2 ||
845 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 0 ) {
846 std::ostringstream oss;
847 oss << " Test: " << test_ << "\n"
848 << " Error: Function call operator failed\n"
849 << " Details:\n"
850 << " Result:\n" << upper << "\n"
851 << " Expected result:\n( 0 -2 3 )\n( 0 1 2 )\n( 0 0 0 )\n";
852 throw std::runtime_error( oss.str() );
853 }
854
855 // Multiplying the upper element (1,2)
856 upper(1,2) *= -3;
857
858 checkRows ( upper, 3UL );
859 checkColumns ( upper, 3UL );
860 checkCapacity( upper, 4UL );
861 checkNonZeros( upper, 4UL );
862 checkNonZeros( upper, 0UL, 2UL );
863 checkNonZeros( upper, 1UL, 2UL );
864 checkNonZeros( upper, 2UL, 0UL );
865
866 if( upper(0,0) != 0 || upper(0,1) != -2 || upper(0,2) != 3 ||
867 upper(1,0) != 0 || upper(1,1) != 1 || upper(1,2) != -6 ||
868 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 0 ) {
869 std::ostringstream oss;
870 oss << " Test: " << test_ << "\n"
871 << " Error: Function call operator failed\n"
872 << " Details:\n"
873 << " Result:\n" << upper << "\n"
874 << " Expected result:\n( 0 -2 3 )\n( 0 1 -6 )\n( 0 0 0 )\n";
875 throw std::runtime_error( oss.str() );
876 }
877
878 // Dividing the upper element (1,2)
879 upper(1,2) /= 2;
880
881 checkRows ( upper, 3UL );
882 checkColumns ( upper, 3UL );
883 checkCapacity( upper, 4UL );
884 checkNonZeros( upper, 4UL );
885 checkNonZeros( upper, 0UL, 2UL );
886 checkNonZeros( upper, 1UL, 2UL );
887 checkNonZeros( upper, 2UL, 0UL );
888
889 if( upper(0,0) != 0 || upper(0,1) != -2 || upper(0,2) != 3 ||
890 upper(1,0) != 0 || upper(1,1) != 1 || upper(1,2) != -3 ||
891 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 0 ) {
892 std::ostringstream oss;
893 oss << " Test: " << test_ << "\n"
894 << " Error: Function call operator failed\n"
895 << " Details:\n"
896 << " Result:\n" << upper << "\n"
897 << " Expected result:\n( 0 -2 3 )\n( 0 1 -3 )\n( 0 0 0 )\n";
898 throw std::runtime_error( oss.str() );
899 }
900 }
901
902 // Failure cases
903 {
904 UT upper( 3UL );
905
906 // Trying to write the lower element (2,1)
907 try {
908 upper(2,1) = 2;
909
910 std::ostringstream oss;
911 oss << " Test: " << test_ << "\n"
912 << " Error: Assignment to lower matrix element succeeded\n"
913 << " Details:\n"
914 << " Result:\n" << upper << "\n";
915 throw std::runtime_error( oss.str() );
916 }
917 catch( std::invalid_argument& ) {}
918
919 // Trying to write the lower element (1,0)
920 try {
921 upper(1,0) = upper(1,2);
922
923 std::ostringstream oss;
924 oss << " Test: " << test_ << "\n"
925 << " Error: Assignment to lower matrix element succeeded\n"
926 << " Details:\n"
927 << " Result:\n" << upper << "\n";
928 throw std::runtime_error( oss.str() );
929 }
930 catch( std::invalid_argument& ) {}
931
932 // Trying to add to the lower element (2,0)
933 try {
934 upper(2,0) += 3;
935
936 std::ostringstream oss;
937 oss << " Test: " << test_ << "\n"
938 << " Error: Addition assignment to lower matrix element succeeded\n"
939 << " Details:\n"
940 << " Result:\n" << upper << "\n";
941 throw std::runtime_error( oss.str() );
942 }
943 catch( std::invalid_argument& ) {}
944
945 // Trying to subtract from the lower element (1,0)
946 try {
947 upper(1,0) -= 4;
948
949 std::ostringstream oss;
950 oss << " Test: " << test_ << "\n"
951 << " Error: Subtraction assignment to lower matrix element succeeded\n"
952 << " Details:\n"
953 << " Result:\n" << upper << "\n";
954 throw std::runtime_error( oss.str() );
955 }
956 catch( std::invalid_argument& ) {}
957
958 // Trying to multiply the lower element (2,1)
959 try {
960 upper(2,1) *= -3;
961
962 std::ostringstream oss;
963 oss << " Test: " << test_ << "\n"
964 << " Error: Multiplication assignment to lower matrix element succeeded\n"
965 << " Details:\n"
966 << " Result:\n" << upper << "\n";
967 throw std::runtime_error( oss.str() );
968 }
969 catch( std::invalid_argument& ) {}
970
971 // Trying to divide the lower element (2,1)
972 try {
973 upper(2,1) /= 2;
974
975 std::ostringstream oss;
976 oss << " Test: " << test_ << "\n"
977 << " Error: Division assignment to lower matrix element succeeded\n"
978 << " Details:\n"
979 << " Result:\n" << upper << "\n";
980 throw std::runtime_error( oss.str() );
981 }
982 catch( std::invalid_argument& ) {}
983 }
984 }
985
986
987 //=====================================================================================
988 // Column-major matrix tests
989 //=====================================================================================
990
991 {
992 test_ = "Column-major UpperMatrix::operator()";
993
994 // Good cases
995 {
996 OUT upper( 3UL );
997
998 // Writing the diagonal element (1,1)
999 upper(1,1) = 1;
1000
1001 checkRows ( upper, 3UL );
1002 checkColumns ( upper, 3UL );
1003 checkCapacity( upper, 1UL );
1004 checkNonZeros( upper, 1UL );
1005 checkNonZeros( upper, 0UL, 0UL );
1006 checkNonZeros( upper, 1UL, 1UL );
1007 checkNonZeros( upper, 2UL, 0UL );
1008
1009 if( upper(0,0) != 0 || upper(0,1) != 0 || upper(0,2) != 0 ||
1010 upper(1,0) != 0 || upper(1,1) != 1 || upper(1,2) != 0 ||
1011 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 0 ) {
1012 std::ostringstream oss;
1013 oss << " Test: " << test_ << "\n"
1014 << " Error: Function call operator failed\n"
1015 << " Details:\n"
1016 << " Result:\n" << upper << "\n"
1017 << " Expected result:\n( 0 0 0 )\n( 0 1 0 )\n( 0 0 0 )\n";
1018 throw std::runtime_error( oss.str() );
1019 }
1020
1021 // Writing the upper element (1,2)
1022 upper(1,2) = 2;
1023
1024 checkRows ( upper, 3UL );
1025 checkColumns ( upper, 3UL );
1026 checkCapacity( upper, 2UL );
1027 checkNonZeros( upper, 2UL );
1028 checkNonZeros( upper, 0UL, 0UL );
1029 checkNonZeros( upper, 1UL, 1UL );
1030 checkNonZeros( upper, 2UL, 1UL );
1031
1032 if( upper(0,0) != 0 || upper(0,1) != 0 || upper(0,2) != 0 ||
1033 upper(1,0) != 0 || upper(1,1) != 1 || upper(1,2) != 2 ||
1034 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 0 ) {
1035 std::ostringstream oss;
1036 oss << " Test: " << test_ << "\n"
1037 << " Error: Function call operator failed\n"
1038 << " Details:\n"
1039 << " Result:\n" << upper << "\n"
1040 << " Expected result:\n( 0 0 0 )\n( 0 1 2 )\n( 0 0 0 )\n";
1041 throw std::runtime_error( oss.str() );
1042 }
1043
1044 // Writing the upper element (0,1)
1045 upper(0,1) = upper(1,2);
1046
1047 checkRows ( upper, 3UL );
1048 checkColumns ( upper, 3UL );
1049 checkCapacity( upper, 3UL );
1050 checkNonZeros( upper, 3UL );
1051 checkNonZeros( upper, 0UL, 0UL );
1052 checkNonZeros( upper, 1UL, 2UL );
1053 checkNonZeros( upper, 2UL, 1UL );
1054
1055 if( upper(0,0) != 0 || upper(0,1) != 2 || upper(0,2) != 0 ||
1056 upper(1,0) != 0 || upper(1,1) != 1 || upper(1,2) != 2 ||
1057 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 0 ) {
1058 std::ostringstream oss;
1059 oss << " Test: " << test_ << "\n"
1060 << " Error: Function call operator failed\n"
1061 << " Details:\n"
1062 << " Result:\n" << upper << "\n"
1063 << " Expected result:\n( 0 2 0 )\n( 0 1 2 )\n( 0 0 0 )\n";
1064 throw std::runtime_error( oss.str() );
1065 }
1066
1067 // Adding to the upper element (0,2)
1068 upper(0,2) += 3;
1069
1070 checkRows ( upper, 3UL );
1071 checkColumns ( upper, 3UL );
1072 checkCapacity( upper, 4UL );
1073 checkNonZeros( upper, 4UL );
1074 checkNonZeros( upper, 0UL, 0UL );
1075 checkNonZeros( upper, 1UL, 2UL );
1076 checkNonZeros( upper, 2UL, 2UL );
1077
1078 if( upper(0,0) != 0 || upper(0,1) != 2 || upper(0,2) != 3 ||
1079 upper(1,0) != 0 || upper(1,1) != 1 || upper(1,2) != 2 ||
1080 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 0 ) {
1081 std::ostringstream oss;
1082 oss << " Test: " << test_ << "\n"
1083 << " Error: Function call operator failed\n"
1084 << " Details:\n"
1085 << " Result:\n" << upper << "\n"
1086 << " Expected result:\n( 0 2 3 )\n( 0 1 2 )\n( 0 0 0 )\n";
1087 throw std::runtime_error( oss.str() );
1088 }
1089
1090 // Subtracting from the upper element (0,1)
1091 upper(0,1) -= 4;
1092
1093 checkRows ( upper, 3UL );
1094 checkColumns ( upper, 3UL );
1095 checkCapacity( upper, 4UL );
1096 checkNonZeros( upper, 4UL );
1097 checkNonZeros( upper, 0UL, 0UL );
1098 checkNonZeros( upper, 1UL, 2UL );
1099 checkNonZeros( upper, 2UL, 2UL );
1100
1101 if( upper(0,0) != 0 || upper(0,1) != -2 || upper(0,2) != 3 ||
1102 upper(1,0) != 0 || upper(1,1) != 1 || upper(1,2) != 2 ||
1103 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 0 ) {
1104 std::ostringstream oss;
1105 oss << " Test: " << test_ << "\n"
1106 << " Error: Function call operator failed\n"
1107 << " Details:\n"
1108 << " Result:\n" << upper << "\n"
1109 << " Expected result:\n( 0 -2 3 )\n( 0 1 2 )\n( 0 0 0 )\n";
1110 throw std::runtime_error( oss.str() );
1111 }
1112
1113 // Multiplying the upper element (1,2)
1114 upper(1,2) *= -3;
1115
1116 checkRows ( upper, 3UL );
1117 checkColumns ( upper, 3UL );
1118 checkCapacity( upper, 4UL );
1119 checkNonZeros( upper, 4UL );
1120 checkNonZeros( upper, 0UL, 0UL );
1121 checkNonZeros( upper, 1UL, 2UL );
1122 checkNonZeros( upper, 2UL, 2UL );
1123
1124 if( upper(0,0) != 0 || upper(0,1) != -2 || upper(0,2) != 3 ||
1125 upper(1,0) != 0 || upper(1,1) != 1 || upper(1,2) != -6 ||
1126 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 0 ) {
1127 std::ostringstream oss;
1128 oss << " Test: " << test_ << "\n"
1129 << " Error: Function call operator failed\n"
1130 << " Details:\n"
1131 << " Result:\n" << upper << "\n"
1132 << " Expected result:\n( 0 -2 3 )\n( 0 1 -6 )\n( 0 0 0 )\n";
1133 throw std::runtime_error( oss.str() );
1134 }
1135
1136 // Dividing the upper element (1,2)
1137 upper(1,2) /= 2;
1138
1139 checkRows ( upper, 3UL );
1140 checkColumns ( upper, 3UL );
1141 checkCapacity( upper, 4UL );
1142 checkNonZeros( upper, 4UL );
1143 checkNonZeros( upper, 0UL, 0UL );
1144 checkNonZeros( upper, 1UL, 2UL );
1145 checkNonZeros( upper, 2UL, 2UL );
1146
1147 if( upper(0,0) != 0 || upper(0,1) != -2 || upper(0,2) != 3 ||
1148 upper(1,0) != 0 || upper(1,1) != 1 || upper(1,2) != -3 ||
1149 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 0 ) {
1150 std::ostringstream oss;
1151 oss << " Test: " << test_ << "\n"
1152 << " Error: Function call operator failed\n"
1153 << " Details:\n"
1154 << " Result:\n" << upper << "\n"
1155 << " Expected result:\n( 0 -2 3 )\n( 0 1 -3 )\n( 0 0 0 )\n";
1156 throw std::runtime_error( oss.str() );
1157 }
1158 }
1159
1160 // Failure cases
1161 {
1162 OUT upper( 3UL );
1163
1164 // Trying to write the lower element (2,1)
1165 try {
1166 upper(2,1) = 2;
1167
1168 std::ostringstream oss;
1169 oss << " Test: " << test_ << "\n"
1170 << " Error: Assignment to lower matrix element succeeded\n"
1171 << " Details:\n"
1172 << " Result:\n" << upper << "\n";
1173 throw std::runtime_error( oss.str() );
1174 }
1175 catch( std::invalid_argument& ) {}
1176
1177 // Trying to write the lower element (1,0)
1178 try {
1179 upper(1,0) = upper(1,2);
1180
1181 std::ostringstream oss;
1182 oss << " Test: " << test_ << "\n"
1183 << " Error: Assignment to lower matrix element succeeded\n"
1184 << " Details:\n"
1185 << " Result:\n" << upper << "\n";
1186 throw std::runtime_error( oss.str() );
1187 }
1188 catch( std::invalid_argument& ) {}
1189
1190 // Trying to add to the lower element (2,0)
1191 try {
1192 upper(2,0) += 3;
1193
1194 std::ostringstream oss;
1195 oss << " Test: " << test_ << "\n"
1196 << " Error: Addition assignment to lower matrix element succeeded\n"
1197 << " Details:\n"
1198 << " Result:\n" << upper << "\n";
1199 throw std::runtime_error( oss.str() );
1200 }
1201 catch( std::invalid_argument& ) {}
1202
1203 // Trying to subtract from the lower element (1,0)
1204 try {
1205 upper(1,0) -= 4;
1206
1207 std::ostringstream oss;
1208 oss << " Test: " << test_ << "\n"
1209 << " Error: Subtraction assignment to lower matrix element succeeded\n"
1210 << " Details:\n"
1211 << " Result:\n" << upper << "\n";
1212 throw std::runtime_error( oss.str() );
1213 }
1214 catch( std::invalid_argument& ) {}
1215
1216 // Trying to multiply the lower element (2,1)
1217 try {
1218 upper(2,1) *= -3;
1219
1220 std::ostringstream oss;
1221 oss << " Test: " << test_ << "\n"
1222 << " Error: Multiplication assignment to lower matrix element succeeded\n"
1223 << " Details:\n"
1224 << " Result:\n" << upper << "\n";
1225 throw std::runtime_error( oss.str() );
1226 }
1227 catch( std::invalid_argument& ) {}
1228
1229 // Trying to divide the lower element (2,1)
1230 try {
1231 upper(2,1) /= 2;
1232
1233 std::ostringstream oss;
1234 oss << " Test: " << test_ << "\n"
1235 << " Error: Division assignment to lower matrix element succeeded\n"
1236 << " Details:\n"
1237 << " Result:\n" << upper << "\n";
1238 throw std::runtime_error( oss.str() );
1239 }
1240 catch( std::invalid_argument& ) {}
1241 }
1242 }
1243 }
1244 //*************************************************************************************************
1245
1246
1247 //*************************************************************************************************
1248 /*!\brief Test of the UpperMatrix iterator implementation.
1249 //
1250 // \return void
1251 // \exception std::runtime_error Error detected.
1252 //
1253 // This function performs a test of the iterator implementation of the UpperMatrix
1254 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
1255 */
testIterator()1256 void SparseTest::testIterator()
1257 {
1258 //=====================================================================================
1259 // Row-major matrix tests
1260 //=====================================================================================
1261
1262 {
1263 using Iterator = UT::Iterator;
1264 using ConstIterator = UT::ConstIterator;
1265
1266 UT upper( 3UL );
1267 upper(0,0) = 1;
1268 upper(0,2) = 3;
1269 upper(1,1) = -2;
1270 upper(2,2) = 4;
1271
1272 // Testing the Iterator default constructor
1273 {
1274 test_ = "Row-major Iterator default constructor";
1275
1276 Iterator it{};
1277
1278 if( it != Iterator() ) {
1279 std::ostringstream oss;
1280 oss << " Test: " << test_ << "\n"
1281 << " Error: Failed iterator default constructor\n";
1282 throw std::runtime_error( oss.str() );
1283 }
1284 }
1285
1286 // Testing the ConstIterator default constructor
1287 {
1288 test_ = "Row-major ConstIterator default constructor";
1289
1290 ConstIterator it{};
1291
1292 if( it != ConstIterator() ) {
1293 std::ostringstream oss;
1294 oss << " Test: " << test_ << "\n"
1295 << " Error: Failed iterator default constructor\n";
1296 throw std::runtime_error( oss.str() );
1297 }
1298 }
1299
1300 // Testing conversion from Iterator to ConstIterator
1301 {
1302 test_ = "Row-major Iterator/ConstIterator conversion";
1303
1304 ConstIterator it( begin( upper, 1UL ) );
1305
1306 if( it == end( upper, 1UL ) || it->value() != -2 ) {
1307 std::ostringstream oss;
1308 oss << " Test: " << test_ << "\n"
1309 << " Error: Failed iterator conversion detected\n";
1310 throw std::runtime_error( oss.str() );
1311 }
1312 }
1313
1314 // Counting the number of elements in 0th row via Iterator (end-begin)
1315 {
1316 test_ = "Row-major Iterator subtraction (end-begin)";
1317
1318 const ptrdiff_t number( end( upper, 0UL ) - begin( upper, 0UL ) );
1319
1320 if( number != 2L ) {
1321 std::ostringstream oss;
1322 oss << " Test: " << test_ << "\n"
1323 << " Error: Invalid number of elements detected\n"
1324 << " Details:\n"
1325 << " Number of elements : " << number << "\n"
1326 << " Expected number of elements: 2\n";
1327 throw std::runtime_error( oss.str() );
1328 }
1329 }
1330
1331 // Counting the number of elements in 1st row via ConstIterator (end-begin)
1332 {
1333 test_ = "Row-major ConstIterator subtraction (end-begin)";
1334
1335 const ptrdiff_t number( cend( upper, 1UL ) - cbegin( upper, 1UL ) );
1336
1337 if( number != 1L ) {
1338 std::ostringstream oss;
1339 oss << " Test: " << test_ << "\n"
1340 << " Error: Invalid number of elements detected\n"
1341 << " Details:\n"
1342 << " Number of elements : " << number << "\n"
1343 << " Expected number of elements: 1\n";
1344 throw std::runtime_error( oss.str() );
1345 }
1346 }
1347
1348 // Testing read-only access via ConstIterator
1349 {
1350 test_ = "Row-major read-only access via ConstIterator";
1351
1352 ConstIterator it ( cbegin( upper, 0UL ) );
1353 ConstIterator end( cend( upper, 0UL ) );
1354
1355 if( it == end || it->value() != 1 ) {
1356 std::ostringstream oss;
1357 oss << " Test: " << test_ << "\n"
1358 << " Error: Invalid initial iterator detected\n";
1359 throw std::runtime_error( oss.str() );
1360 }
1361
1362 ++it;
1363
1364 if( it == end || it->value() != 3 ) {
1365 std::ostringstream oss;
1366 oss << " Test: " << test_ << "\n"
1367 << " Error: Iterator pre-increment failed\n";
1368 throw std::runtime_error( oss.str() );
1369 }
1370
1371 it++;
1372
1373 if( it != end ) {
1374 std::ostringstream oss;
1375 oss << " Test: " << test_ << "\n"
1376 << " Error: Iterator post-increment failed\n";
1377 throw std::runtime_error( oss.str() );
1378 }
1379 }
1380
1381 // Testing assignment to upper elements via Iterator
1382 {
1383 test_ = "Row-major assignment to upper elements via Iterator";
1384
1385 int value = 7;
1386
1387 for( Iterator it=begin( upper, 0UL ); it!=end( upper, 0UL ); ++it ) {
1388 *it = value++;
1389 }
1390
1391 if( upper(0,0) != 7 || upper(0,1) != 0 || upper(0,2) != 8 ||
1392 upper(1,0) != 0 || upper(1,1) != -2 || upper(1,2) != 0 ||
1393 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 4 ) {
1394 std::ostringstream oss;
1395 oss << " Test: " << test_ << "\n"
1396 << " Error: Assignment via iterator failed\n"
1397 << " Details:\n"
1398 << " Result:\n" << upper << "\n"
1399 << " Expected result:\n( 7 0 8 )\n( 0 -2 0 )\n( 0 0 4 )\n";
1400 throw std::runtime_error( oss.str() );
1401 }
1402 }
1403
1404 // Testing addition assignment to upper elements via Iterator
1405 {
1406 test_ = "Row-major addition assignment to upper elements via Iterator";
1407
1408 int value = 4;
1409
1410 for( Iterator it=begin( upper, 0UL ); it!=end( upper, 0UL ); ++it ) {
1411 *it += value++;
1412 }
1413
1414 if( upper(0,0) != 11 || upper(0,1) != 0 || upper(0,2) != 13 ||
1415 upper(1,0) != 0 || upper(1,1) != -2 || upper(1,2) != 0 ||
1416 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 4 ) {
1417 std::ostringstream oss;
1418 oss << " Test: " << test_ << "\n"
1419 << " Error: Assignment via iterator failed\n"
1420 << " Details:\n"
1421 << " Result:\n" << upper << "\n"
1422 << " Expected result:\n( 11 0 13 )\n( 0 -2 0 )\n( 0 0 4 )\n";
1423 throw std::runtime_error( oss.str() );
1424 }
1425 }
1426
1427 // Testing subtraction assignment to upper elements via Iterator
1428 {
1429 test_ = "Row-major subtraction assignment to upper elements via Iterator";
1430
1431 int value = 4;
1432
1433 for( Iterator it=begin( upper, 0UL ); it!=end( upper, 0UL ); ++it ) {
1434 *it -= value++;
1435 }
1436
1437 if( upper(0,0) != 7 || upper(0,1) != 0 || upper(0,2) != 8 ||
1438 upper(1,0) != 0 || upper(1,1) != -2 || upper(1,2) != 0 ||
1439 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 4 ) {
1440 std::ostringstream oss;
1441 oss << " Test: " << test_ << "\n"
1442 << " Error: Assignment via iterator failed\n"
1443 << " Details:\n"
1444 << " Result:\n" << upper << "\n"
1445 << " Expected result:\n( 7 0 8 )\n( 0 -2 0 )\n( 0 0 4 )\n";
1446 throw std::runtime_error( oss.str() );
1447 }
1448 }
1449
1450 // Testing multiplication assignment to upper elements via Iterator
1451 {
1452 test_ = "Row-major multiplication assignment to upper elements via Iterator";
1453
1454 for( Iterator it=begin( upper, 0UL ); it!=end( upper, 0UL ); ++it ) {
1455 *it *= 2;
1456 }
1457
1458 if( upper(0,0) != 14 || upper(0,1) != 0 || upper(0,2) != 16 ||
1459 upper(1,0) != 0 || upper(1,1) != -2 || upper(1,2) != 0 ||
1460 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 4 ) {
1461 std::ostringstream oss;
1462 oss << " Test: " << test_ << "\n"
1463 << " Error: Assignment via iterator failed\n"
1464 << " Details:\n"
1465 << " Result:\n" << upper << "\n"
1466 << " Expected result:\n( 14 0 16 )\n( 0 -2 0 )\n( 0 0 4 )\n";
1467 throw std::runtime_error( oss.str() );
1468 }
1469 }
1470
1471 // Testing division assignment to upper elements via Iterator
1472 {
1473 test_ = "Row-major division assignment to upper elements via Iterator";
1474
1475 for( Iterator it=begin( upper, 0UL ); it!=end( upper, 0UL ); ++it ) {
1476 *it /= 2;
1477 }
1478
1479 if( upper(0,0) != 7 || upper(0,1) != 0 || upper(0,2) != 8 ||
1480 upper(1,0) != 0 || upper(1,1) != -2 || upper(1,2) != 0 ||
1481 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 4 ) {
1482 std::ostringstream oss;
1483 oss << " Test: " << test_ << "\n"
1484 << " Error: Assignment via iterator failed\n"
1485 << " Details:\n"
1486 << " Result:\n" << upper << "\n"
1487 << " Expected result:\n( 7 0 8 )\n( 0 -2 0 )\n( 0 0 4 )\n";
1488 throw std::runtime_error( oss.str() );
1489 }
1490 }
1491 }
1492
1493
1494 //=====================================================================================
1495 // Column-major matrix tests
1496 //=====================================================================================
1497
1498 {
1499 using Iterator = OUT::Iterator;
1500 using ConstIterator = OUT::ConstIterator;
1501
1502 OUT upper( 3UL );
1503 upper(0,0) = 1;
1504 upper(0,2) = 3;
1505 upper(1,1) = -2;
1506 upper(2,2) = 4;
1507
1508 // Testing the Iterator default constructor
1509 {
1510 test_ = "Column-major Iterator default constructor";
1511
1512 Iterator it{};
1513
1514 if( it != Iterator() ) {
1515 std::ostringstream oss;
1516 oss << " Test: " << test_ << "\n"
1517 << " Error: Failed iterator default constructor\n";
1518 throw std::runtime_error( oss.str() );
1519 }
1520 }
1521
1522 // Testing the ConstIterator default constructor
1523 {
1524 test_ = "Column-major ConstIterator default constructor";
1525
1526 ConstIterator it{};
1527
1528 if( it != ConstIterator() ) {
1529 std::ostringstream oss;
1530 oss << " Test: " << test_ << "\n"
1531 << " Error: Failed iterator default constructor\n";
1532 throw std::runtime_error( oss.str() );
1533 }
1534 }
1535
1536 // Testing conversion from Iterator to ConstIterator
1537 {
1538 test_ = "Column-major Iterator/ConstIterator conversion";
1539
1540 ConstIterator it( begin( upper, 1UL ) );
1541
1542 if( it == end( upper, 1UL ) || it->value() != -2 ) {
1543 std::ostringstream oss;
1544 oss << " Test: " << test_ << "\n"
1545 << " Error: Failed iterator conversion detected\n";
1546 throw std::runtime_error( oss.str() );
1547 }
1548 }
1549
1550 // Counting the number of elements in 0th column via Iterator (end-begin)
1551 {
1552 test_ = "Column-major Iterator subtraction (end-begin)";
1553
1554 const ptrdiff_t number( end( upper, 0UL ) - begin( upper, 0UL ) );
1555
1556 if( number != 1L ) {
1557 std::ostringstream oss;
1558 oss << " Test: " << test_ << "\n"
1559 << " Error: Invalid number of elements detected\n"
1560 << " Details:\n"
1561 << " Number of elements : " << number << "\n"
1562 << " Expected number of elements: 1\n";
1563 throw std::runtime_error( oss.str() );
1564 }
1565 }
1566
1567 // Counting the number of elements in 1st column via ConstIterator (end-begin)
1568 {
1569 test_ = "Column-major ConstIterator subtraction (end-begin)";
1570
1571 const ptrdiff_t number( cend( upper, 1UL ) - cbegin( upper, 1UL ) );
1572
1573 if( number != 1L ) {
1574 std::ostringstream oss;
1575 oss << " Test: " << test_ << "\n"
1576 << " Error: Invalid number of elements detected\n"
1577 << " Details:\n"
1578 << " Number of elements : " << number << "\n"
1579 << " Expected number of elements: 1\n";
1580 throw std::runtime_error( oss.str() );
1581 }
1582 }
1583
1584 // Testing read-only access via ConstIterator
1585 {
1586 test_ = "Column-major read-only access via ConstIterator";
1587
1588 ConstIterator it ( cbegin( upper, 2UL ) );
1589 ConstIterator end( cend( upper, 2UL ) );
1590
1591 if( it == end || it->value() != 3 ) {
1592 std::ostringstream oss;
1593 oss << " Test: " << test_ << "\n"
1594 << " Error: Invalid initial iterator detected\n";
1595 throw std::runtime_error( oss.str() );
1596 }
1597
1598 ++it;
1599
1600 if( it == end || it->value() != 4 ) {
1601 std::ostringstream oss;
1602 oss << " Test: " << test_ << "\n"
1603 << " Error: Iterator pre-increment failed\n";
1604 throw std::runtime_error( oss.str() );
1605 }
1606
1607 it++;
1608
1609 if( it != end ) {
1610 std::ostringstream oss;
1611 oss << " Test: " << test_ << "\n"
1612 << " Error: Iterator post-increment failed\n";
1613 throw std::runtime_error( oss.str() );
1614 }
1615 }
1616
1617 // Testing assignment to upper elements via Iterator
1618 {
1619 test_ = "Column-major assignment to upper elements via Iterator";
1620
1621 int value = 7;
1622
1623 for( Iterator it=begin( upper, 2UL ); it!=end( upper, 2UL ); ++it ) {
1624 *it = value++;
1625 }
1626
1627 if( upper(0,0) != 1 || upper(0,1) != 0 || upper(0,2) != 7 ||
1628 upper(1,0) != 0 || upper(1,1) != -2 || upper(1,2) != 0 ||
1629 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 8 ) {
1630 std::ostringstream oss;
1631 oss << " Test: " << test_ << "\n"
1632 << " Error: Assignment via iterator failed\n"
1633 << " Details:\n"
1634 << " Result:\n" << upper << "\n"
1635 << " Expected result:\n( 1 0 7 )\n( 0 -2 0 )\n( 0 0 8 )\n";
1636 throw std::runtime_error( oss.str() );
1637 }
1638 }
1639
1640 // Testing addition assignment to upper elements via Iterator
1641 {
1642 test_ = "Column-major addition assignment to upper elements via Iterator";
1643
1644 int value = 4;
1645
1646 for( Iterator it=begin( upper, 2UL ); it!=end( upper, 2UL ); ++it ) {
1647 *it += value++;
1648 }
1649
1650 if( upper(0,0) != 1 || upper(0,1) != 0 || upper(0,2) != 11 ||
1651 upper(1,0) != 0 || upper(1,1) != -2 || upper(1,2) != 0 ||
1652 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 13 ) {
1653 std::ostringstream oss;
1654 oss << " Test: " << test_ << "\n"
1655 << " Error: Assignment via iterator failed\n"
1656 << " Details:\n"
1657 << " Result:\n" << upper << "\n"
1658 << " Expected result:\n( 1 0 11 )\n( 0 -2 0 )\n( 0 0 13 )\n";
1659 throw std::runtime_error( oss.str() );
1660 }
1661 }
1662
1663 // Testing subtraction assignment to upper elements via Iterator
1664 {
1665 test_ = "Column-major subtraction assignment to upper elements via Iterator";
1666
1667 int value = 4;
1668
1669 for( Iterator it=begin( upper, 2UL ); it!=end( upper, 2UL ); ++it ) {
1670 *it -= value++;
1671 }
1672
1673 if( upper(0,0) != 1 || upper(0,1) != 0 || upper(0,2) != 7 ||
1674 upper(1,0) != 0 || upper(1,1) != -2 || upper(1,2) != 0 ||
1675 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 8 ) {
1676 std::ostringstream oss;
1677 oss << " Test: " << test_ << "\n"
1678 << " Error: Assignment via iterator failed\n"
1679 << " Details:\n"
1680 << " Result:\n" << upper << "\n"
1681 << " Expected result:\n( 1 0 7 )\n( 0 -2 0 )\n( 0 0 8 )\n";
1682 throw std::runtime_error( oss.str() );
1683 }
1684 }
1685
1686 // Testing multiplication assignment to upper elements via Iterator
1687 {
1688 test_ = "Column-major multiplication assignment to upper elements via Iterator";
1689
1690 for( Iterator it=begin( upper, 2UL ); it!=end( upper, 2UL ); ++it ) {
1691 *it *= 2;
1692 }
1693
1694 if( upper(0,0) != 1 || upper(0,1) != 0 || upper(0,2) != 14 ||
1695 upper(1,0) != 0 || upper(1,1) != -2 || upper(1,2) != 0 ||
1696 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 16 ) {
1697 std::ostringstream oss;
1698 oss << " Test: " << test_ << "\n"
1699 << " Error: Assignment via iterator failed\n"
1700 << " Details:\n"
1701 << " Result:\n" << upper << "\n"
1702 << " Expected result:\n( 1 0 14 )\n( 0 -2 0 )\n( 0 0 16 )\n";
1703 throw std::runtime_error( oss.str() );
1704 }
1705 }
1706
1707 // Testing division assignment to upper elements via Iterator
1708 {
1709 test_ = "Column-major division assignment to upper elements via Iterator";
1710
1711 for( Iterator it=begin( upper, 2UL ); it!=end( upper, 2UL ); ++it ) {
1712 *it /= 2;
1713 }
1714
1715 if( upper(0,0) != 1 || upper(0,1) != 0 || upper(0,2) != 7 ||
1716 upper(1,0) != 0 || upper(1,1) != -2 || upper(1,2) != 0 ||
1717 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 8 ) {
1718 std::ostringstream oss;
1719 oss << " Test: " << test_ << "\n"
1720 << " Error: Assignment via iterator failed\n"
1721 << " Details:\n"
1722 << " Result:\n" << upper << "\n"
1723 << " Expected result:\n( 1 0 7 )\n( 0 -2 0 )\n( 0 0 8 )\n";
1724 throw std::runtime_error( oss.str() );
1725 }
1726 }
1727 }
1728 }
1729 //*************************************************************************************************
1730
1731
1732 //*************************************************************************************************
1733 /*!\brief Test of the \c nonZeros() member function of the UpperMatrix specialization.
1734 //
1735 // \return void
1736 // \exception std::runtime_error Error detected.
1737 //
1738 // This function performs a test of the \c nonZeros() member function of the UpperMatrix
1739 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
1740 */
testNonZeros()1741 void SparseTest::testNonZeros()
1742 {
1743 //=====================================================================================
1744 // Row-major matrix tests
1745 //=====================================================================================
1746
1747 {
1748 test_ = "Row-major UpperMatrix::nonZeros()";
1749
1750 // Empty matrix
1751 {
1752 UT upper( 3UL );
1753
1754 checkRows ( upper, 3UL );
1755 checkColumns ( upper, 3UL );
1756 checkNonZeros( upper, 0UL );
1757 checkNonZeros( upper, 0UL, 0UL );
1758 checkNonZeros( upper, 1UL, 0UL );
1759 checkNonZeros( upper, 2UL, 0UL );
1760
1761 if( upper(0,0) != 0 || upper(0,1) != 0 || upper(0,2) != 0 ||
1762 upper(1,0) != 0 || upper(1,1) != 0 || upper(1,2) != 0 ||
1763 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 0 ) {
1764 std::ostringstream oss;
1765 oss << " Test: " << test_ << "\n"
1766 << " Error: Initialization failed\n"
1767 << " Details:\n"
1768 << " Result:\n" << upper << "\n"
1769 << " Expected result:\n( 0 0 0 )\n( 0 0 0 )\n( 0 0 0 )\n";
1770 throw std::runtime_error( oss.str() );
1771 }
1772 }
1773
1774 // Partially filled matrix
1775 {
1776 UT upper( 3UL );
1777 upper(0,0) = 1;
1778 upper(1,1) = -2;
1779 upper(1,2) = 3;
1780 upper(2,2) = -4;
1781
1782 checkRows ( upper, 3UL );
1783 checkColumns ( upper, 3UL );
1784 checkCapacity( upper, 4UL );
1785 checkNonZeros( upper, 4UL );
1786 checkNonZeros( upper, 0UL, 1UL );
1787 checkNonZeros( upper, 1UL, 2UL );
1788 checkNonZeros( upper, 2UL, 1UL );
1789
1790 if( upper(0,0) != 1 || upper(0,1) != 0 || upper(0,2) != 0 ||
1791 upper(1,0) != 0 || upper(1,1) != -2 || upper(1,2) != 3 ||
1792 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != -4 ) {
1793 std::ostringstream oss;
1794 oss << " Test: " << test_ << "\n"
1795 << " Error: Initialization failed\n"
1796 << " Details:\n"
1797 << " Result:\n" << upper << "\n"
1798 << " Expected result:\n( 1 0 0 )\n( 0 -2 3 )\n( 0 0 -4 )\n";
1799 throw std::runtime_error( oss.str() );
1800 }
1801 }
1802
1803 // Fully filled matrix
1804 {
1805 UT upper( 3UL );
1806 upper(0,0) = -1;
1807 upper(0,1) = 2;
1808 upper(0,2) = 3;
1809 upper(1,1) = -4;
1810 upper(1,2) = -5;
1811 upper(2,2) = 6;
1812
1813 checkRows ( upper, 3UL );
1814 checkColumns ( upper, 3UL );
1815 checkCapacity( upper, 6UL );
1816 checkNonZeros( upper, 6UL );
1817 checkNonZeros( upper, 0UL, 3UL );
1818 checkNonZeros( upper, 1UL, 2UL );
1819 checkNonZeros( upper, 2UL, 1UL );
1820
1821 if( upper(0,0) != -1 || upper(0,1) != 2 || upper(0,2) != 3 ||
1822 upper(1,0) != 0 || upper(1,1) != -4 || upper(1,2) != -5 ||
1823 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 6 ) {
1824 std::ostringstream oss;
1825 oss << " Test: " << test_ << "\n"
1826 << " Error: Initialization failed\n"
1827 << " Details:\n"
1828 << " Result:\n" << upper << "\n"
1829 << " Expected result:\n( -1 2 3 )\n( 0 -4 -5 )\n( 0 0 6 )\n";
1830 throw std::runtime_error( oss.str() );
1831 }
1832 }
1833 }
1834
1835
1836 //=====================================================================================
1837 // Column-major matrix tests
1838 //=====================================================================================
1839
1840 {
1841 test_ = "Column-major UpperMatrix::nonZeros()";
1842
1843 // Empty matrix
1844 {
1845 OUT upper( 3UL );
1846
1847 checkRows ( upper, 3UL );
1848 checkColumns ( upper, 3UL );
1849 checkNonZeros( upper, 0UL );
1850 checkNonZeros( upper, 0UL, 0UL );
1851 checkNonZeros( upper, 1UL, 0UL );
1852 checkNonZeros( upper, 2UL, 0UL );
1853
1854 if( upper(0,0) != 0 || upper(0,1) != 0 || upper(0,2) != 0 ||
1855 upper(1,0) != 0 || upper(1,1) != 0 || upper(1,2) != 0 ||
1856 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 0 ) {
1857 std::ostringstream oss;
1858 oss << " Test: " << test_ << "\n"
1859 << " Error: Initialization failed\n"
1860 << " Details:\n"
1861 << " Result:\n" << upper << "\n"
1862 << " Expected result:\n( 0 0 0 )\n( 0 0 0 )\n( 0 0 0 )\n";
1863 throw std::runtime_error( oss.str() );
1864 }
1865 }
1866
1867 // Partially filled matrix
1868 {
1869 OUT upper( 3UL );
1870 upper(0,0) = 1;
1871 upper(1,1) = -2;
1872 upper(1,2) = 3;
1873 upper(2,2) = -4;
1874
1875 checkRows ( upper, 3UL );
1876 checkColumns ( upper, 3UL );
1877 checkCapacity( upper, 4UL );
1878 checkNonZeros( upper, 4UL );
1879 checkNonZeros( upper, 0UL, 1UL );
1880 checkNonZeros( upper, 1UL, 1UL );
1881 checkNonZeros( upper, 2UL, 2UL );
1882
1883 if( upper(0,0) != 1 || upper(0,1) != 0 || upper(0,2) != 0 ||
1884 upper(1,0) != 0 || upper(1,1) != -2 || upper(1,2) != 3 ||
1885 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != -4 ) {
1886 std::ostringstream oss;
1887 oss << " Test: " << test_ << "\n"
1888 << " Error: Initialization failed\n"
1889 << " Details:\n"
1890 << " Result:\n" << upper << "\n"
1891 << " Expected result:\n( 1 0 0 )\n( 0 -2 3 )\n( 0 0 -4 )\n";
1892 throw std::runtime_error( oss.str() );
1893 }
1894 }
1895
1896 // Fully filled matrix
1897 {
1898 OUT upper( 3UL );
1899 upper(0,0) = -1;
1900 upper(0,1) = 2;
1901 upper(0,2) = 3;
1902 upper(1,1) = -4;
1903 upper(1,2) = -5;
1904 upper(2,2) = 6;
1905
1906 checkRows ( upper, 3UL );
1907 checkColumns ( upper, 3UL );
1908 checkCapacity( upper, 6UL );
1909 checkNonZeros( upper, 6UL );
1910 checkNonZeros( upper, 0UL, 1UL );
1911 checkNonZeros( upper, 1UL, 2UL );
1912 checkNonZeros( upper, 2UL, 3UL );
1913
1914 if( upper(0,0) != -1 || upper(0,1) != 2 || upper(0,2) != 3 ||
1915 upper(1,0) != 0 || upper(1,1) != -4 || upper(1,2) != -5 ||
1916 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 6 ) {
1917 std::ostringstream oss;
1918 oss << " Test: " << test_ << "\n"
1919 << " Error: Initialization failed\n"
1920 << " Details:\n"
1921 << " Result:\n" << upper << "\n"
1922 << " Expected result:\n( -1 2 3 )\n( 0 -4 -5 )\n( 0 0 6 )\n";
1923 throw std::runtime_error( oss.str() );
1924 }
1925 }
1926 }
1927 }
1928 //*************************************************************************************************
1929
1930
1931 //*************************************************************************************************
1932 /*!\brief Test of the \c reset() member function of the UpperMatrix specialization.
1933 //
1934 // \return void
1935 // \exception std::runtime_error Error detected.
1936 //
1937 // This function performs a test of the \c reset() member function of the UpperMatrix
1938 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
1939 */
testReset()1940 void SparseTest::testReset()
1941 {
1942 //=====================================================================================
1943 // Row-major matrix tests
1944 //=====================================================================================
1945
1946 {
1947 test_ = "Row-major UpperMatrix::reset()";
1948
1949 // Initialization check
1950 UT upper( 3UL );
1951 upper(0,0) = 1;
1952 upper(0,1) = 2;
1953 upper(0,2) = 3;
1954 upper(1,1) = 4;
1955 upper(1,2) = 5;
1956 upper(2,2) = 6;
1957
1958 checkRows ( upper, 3UL );
1959 checkColumns ( upper, 3UL );
1960 checkCapacity( upper, 6UL );
1961 checkNonZeros( upper, 6UL );
1962 checkNonZeros( upper, 0UL, 3UL );
1963 checkNonZeros( upper, 1UL, 2UL );
1964 checkNonZeros( upper, 2UL, 1UL );
1965
1966 if( upper(0,0) != 1 || upper(0,1) != 2 || upper(0,2) != 3 ||
1967 upper(1,0) != 0 || upper(1,1) != 4 || upper(1,2) != 5 ||
1968 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 6 ) {
1969 std::ostringstream oss;
1970 oss << " Test: " << test_ << "\n"
1971 << " Error: Initialization failed\n"
1972 << " Details:\n"
1973 << " Result:\n" << upper << "\n"
1974 << " Expected result:\n( 1 2 3 )\n( 0 4 5 )\n( 0 0 6 )\n";
1975 throw std::runtime_error( oss.str() );
1976 }
1977
1978 // Resetting an upper element
1979 reset( upper(0,1) );
1980
1981 checkRows ( upper, 3UL );
1982 checkColumns ( upper, 3UL );
1983 checkCapacity( upper, 6UL );
1984 checkNonZeros( upper, 5UL );
1985 checkNonZeros( upper, 0UL, 2UL );
1986 checkNonZeros( upper, 1UL, 2UL );
1987 checkNonZeros( upper, 2UL, 1UL );
1988
1989 if( upper(0,0) != 1 || upper(0,1) != 0 || upper(0,2) != 3 ||
1990 upper(1,0) != 0 || upper(1,1) != 4 || upper(1,2) != 5 ||
1991 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 6 ) {
1992 std::ostringstream oss;
1993 oss << " Test: " << test_ << "\n"
1994 << " Error: Reset operation failed\n"
1995 << " Details:\n"
1996 << " Result:\n" << upper << "\n"
1997 << " Expected result:\n( 1 0 3 )\n( 0 4 5 )\n( 0 0 6 )\n";
1998 throw std::runtime_error( oss.str() );
1999 }
2000
2001 // Resetting a lower element
2002 reset( upper(1,0) );
2003
2004 checkRows ( upper, 3UL );
2005 checkColumns ( upper, 3UL );
2006 checkCapacity( upper, 6UL );
2007 checkNonZeros( upper, 5UL );
2008 checkNonZeros( upper, 0UL, 2UL );
2009 checkNonZeros( upper, 1UL, 2UL );
2010 checkNonZeros( upper, 2UL, 1UL );
2011
2012 if( upper(0,0) != 1 || upper(0,1) != 0 || upper(0,2) != 3 ||
2013 upper(1,0) != 0 || upper(1,1) != 4 || upper(1,2) != 5 ||
2014 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 6 ) {
2015 std::ostringstream oss;
2016 oss << " Test: " << test_ << "\n"
2017 << " Error: Reset operation failed\n"
2018 << " Details:\n"
2019 << " Result:\n" << upper << "\n"
2020 << " Expected result:\n( 1 0 3 )\n( 0 4 5 )\n( 0 0 6 )\n";
2021 throw std::runtime_error( oss.str() );
2022 }
2023
2024 // Resetting row 1
2025 reset( upper, 1UL );
2026
2027 checkRows ( upper, 3UL );
2028 checkColumns ( upper, 3UL );
2029 checkCapacity( upper, 6UL );
2030 checkNonZeros( upper, 3UL );
2031 checkNonZeros( upper, 0UL, 2UL );
2032 checkNonZeros( upper, 1UL, 0UL );
2033 checkNonZeros( upper, 2UL, 1UL );
2034
2035 if( upper(0,0) != 1 || upper(0,1) != 0 || upper(0,2) != 3 ||
2036 upper(1,0) != 0 || upper(1,1) != 0 || upper(1,2) != 0 ||
2037 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 6 ) {
2038 std::ostringstream oss;
2039 oss << " Test: " << test_ << "\n"
2040 << " Error: Reset operation failed\n"
2041 << " Details:\n"
2042 << " Result:\n" << upper << "\n"
2043 << " Expected result:\n( 1 0 3 )\n( 0 0 0 )\n( 0 0 6 )\n";
2044 throw std::runtime_error( oss.str() );
2045 }
2046
2047 // Resetting the entire matrix
2048 reset( upper );
2049
2050 checkRows ( upper, 3UL );
2051 checkColumns ( upper, 3UL );
2052 checkCapacity( upper, 6UL );
2053 checkNonZeros( upper, 0UL );
2054 checkNonZeros( upper, 0UL, 0UL );
2055 checkNonZeros( upper, 1UL, 0UL );
2056 checkNonZeros( upper, 2UL, 0UL );
2057
2058 if( upper(0,0) != 0 || upper(0,1) != 0 || upper(0,2) != 0 ||
2059 upper(1,0) != 0 || upper(1,1) != 0 || upper(1,2) != 0 ||
2060 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 0 ) {
2061 std::ostringstream oss;
2062 oss << " Test: " << test_ << "\n"
2063 << " Error: Reset operation failed\n"
2064 << " Details:\n"
2065 << " Result:\n" << upper << "\n"
2066 << " Expected result:\n( 0 0 0 )\n( 0 0 0 )\n( 0 0 0 )\n";
2067 throw std::runtime_error( oss.str() );
2068 }
2069 }
2070
2071
2072 //=====================================================================================
2073 // Column-major matrix tests
2074 //=====================================================================================
2075
2076 {
2077 test_ = "Column-major UpperMatrix::reset()";
2078
2079 // Initialization check
2080 OUT upper( 3UL );
2081 upper(0,0) = 1;
2082 upper(0,1) = 2;
2083 upper(0,2) = 3;
2084 upper(1,1) = 4;
2085 upper(1,2) = 5;
2086 upper(2,2) = 6;
2087
2088 checkRows ( upper, 3UL );
2089 checkColumns ( upper, 3UL );
2090 checkCapacity( upper, 6UL );
2091 checkNonZeros( upper, 6UL );
2092 checkNonZeros( upper, 0UL, 1UL );
2093 checkNonZeros( upper, 1UL, 2UL );
2094 checkNonZeros( upper, 2UL, 3UL );
2095
2096 if( upper(0,0) != 1 || upper(0,1) != 2 || upper(0,2) != 3 ||
2097 upper(1,0) != 0 || upper(1,1) != 4 || upper(1,2) != 5 ||
2098 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 6 ) {
2099 std::ostringstream oss;
2100 oss << " Test: " << test_ << "\n"
2101 << " Error: Initialization failed\n"
2102 << " Details:\n"
2103 << " Result:\n" << upper << "\n"
2104 << " Expected result:\n( 1 2 3 )\n( 0 4 5 )\n( 0 0 6 )\n";
2105 throw std::runtime_error( oss.str() );
2106 }
2107
2108 // Resetting an upper element
2109 reset( upper(0,1) );
2110
2111 checkRows ( upper, 3UL );
2112 checkColumns ( upper, 3UL );
2113 checkCapacity( upper, 6UL );
2114 checkNonZeros( upper, 5UL );
2115 checkNonZeros( upper, 0UL, 1UL );
2116 checkNonZeros( upper, 1UL, 1UL );
2117 checkNonZeros( upper, 2UL, 3UL );
2118
2119 if( upper(0,0) != 1 || upper(0,1) != 0 || upper(0,2) != 3 ||
2120 upper(1,0) != 0 || upper(1,1) != 4 || upper(1,2) != 5 ||
2121 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 6 ) {
2122 std::ostringstream oss;
2123 oss << " Test: " << test_ << "\n"
2124 << " Error: Reset operation failed\n"
2125 << " Details:\n"
2126 << " Result:\n" << upper << "\n"
2127 << " Expected result:\n( 1 0 3 )\n( 0 4 5 )\n( 0 0 6 )\n";
2128 throw std::runtime_error( oss.str() );
2129 }
2130
2131 // Resetting a lower element
2132 reset( upper(1,0) );
2133
2134 checkRows ( upper, 3UL );
2135 checkColumns ( upper, 3UL );
2136 checkCapacity( upper, 6UL );
2137 checkNonZeros( upper, 5UL );
2138 checkNonZeros( upper, 0UL, 1UL );
2139 checkNonZeros( upper, 1UL, 1UL );
2140 checkNonZeros( upper, 2UL, 3UL );
2141
2142 if( upper(0,0) != 1 || upper(0,1) != 0 || upper(0,2) != 3 ||
2143 upper(1,0) != 0 || upper(1,1) != 4 || upper(1,2) != 5 ||
2144 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 6 ) {
2145 std::ostringstream oss;
2146 oss << " Test: " << test_ << "\n"
2147 << " Error: Reset operation failed\n"
2148 << " Details:\n"
2149 << " Result:\n" << upper << "\n"
2150 << " Expected result:\n( 1 0 3 )\n( 0 4 5 )\n( 0 0 6 )\n";
2151 throw std::runtime_error( oss.str() );
2152 }
2153
2154 // Resetting column 1
2155 reset( upper, 1UL );
2156
2157 checkRows ( upper, 3UL );
2158 checkColumns ( upper, 3UL );
2159 checkCapacity( upper, 6UL );
2160 checkNonZeros( upper, 4UL );
2161 checkNonZeros( upper, 0UL, 1UL );
2162 checkNonZeros( upper, 1UL, 0UL );
2163 checkNonZeros( upper, 2UL, 3UL );
2164
2165 if( upper(0,0) != 1 || upper(0,1) != 0 || upper(0,2) != 3 ||
2166 upper(1,0) != 0 || upper(1,1) != 0 || upper(1,2) != 5 ||
2167 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 6 ) {
2168 std::ostringstream oss;
2169 oss << " Test: " << test_ << "\n"
2170 << " Error: Reset operation failed\n"
2171 << " Details:\n"
2172 << " Result:\n" << upper << "\n"
2173 << " Expected result:\n( 1 0 3 )\n( 0 0 5 )\n( 0 0 6 )\n";
2174 throw std::runtime_error( oss.str() );
2175 }
2176
2177 // Resetting the entire matrix
2178 reset( upper );
2179
2180 checkRows ( upper, 3UL );
2181 checkColumns ( upper, 3UL );
2182 checkCapacity( upper, 6UL );
2183 checkNonZeros( upper, 0UL );
2184 checkNonZeros( upper, 0UL, 0UL );
2185 checkNonZeros( upper, 1UL, 0UL );
2186 checkNonZeros( upper, 2UL, 0UL );
2187
2188 if( upper(0,0) != 0 || upper(0,1) != 0 || upper(0,2) != 0 ||
2189 upper(1,0) != 0 || upper(1,1) != 0 || upper(1,2) != 0 ||
2190 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 0 ) {
2191 std::ostringstream oss;
2192 oss << " Test: " << test_ << "\n"
2193 << " Error: Reset operation failed\n"
2194 << " Details:\n"
2195 << " Result:\n" << upper << "\n"
2196 << " Expected result:\n( 0 0 0 )\n( 0 0 0 )\n( 0 0 0 )\n";
2197 throw std::runtime_error( oss.str() );
2198 }
2199 }
2200 }
2201 //*************************************************************************************************
2202
2203
2204 //*************************************************************************************************
2205 /*!\brief Test of the \c clear() member function of the UpperMatrix specialization.
2206 //
2207 // \return void
2208 // \exception std::runtime_error Error detected.
2209 //
2210 // This function performs a test of the \c clear() member function of the UpperMatrix
2211 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
2212 */
testClear()2213 void SparseTest::testClear()
2214 {
2215 //=====================================================================================
2216 // Row-major matrix tests
2217 //=====================================================================================
2218
2219 {
2220 test_ = "Row-major UpperMatrix::clear()";
2221
2222 // Initialization check
2223 UT upper( 3UL );
2224 upper(0,0) = 1;
2225 upper(0,1) = 2;
2226 upper(0,2) = 3;
2227 upper(1,1) = 4;
2228 upper(1,2) = 5;
2229 upper(2,2) = 6;
2230
2231 checkRows ( upper, 3UL );
2232 checkColumns ( upper, 3UL );
2233 checkCapacity( upper, 6UL );
2234 checkNonZeros( upper, 6UL );
2235 checkNonZeros( upper, 0UL, 3UL );
2236 checkNonZeros( upper, 1UL, 2UL );
2237 checkNonZeros( upper, 2UL, 1UL );
2238
2239 if( upper(0,0) != 1 || upper(0,1) != 2 || upper(0,2) != 3 ||
2240 upper(1,0) != 0 || upper(1,1) != 4 || upper(1,2) != 5 ||
2241 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 6 ) {
2242 std::ostringstream oss;
2243 oss << " Test: " << test_ << "\n"
2244 << " Error: Initialization failed\n"
2245 << " Details:\n"
2246 << " Result:\n" << upper << "\n"
2247 << " Expected result:\n( 1 2 3 )\n( 0 4 5 )\n( 0 0 6 )\n";
2248 throw std::runtime_error( oss.str() );
2249 }
2250
2251 // Clearing an upper element
2252 clear( upper(0,1) );
2253
2254 checkRows ( upper, 3UL );
2255 checkColumns ( upper, 3UL );
2256 checkCapacity( upper, 6UL );
2257 checkNonZeros( upper, 5UL );
2258 checkNonZeros( upper, 0UL, 2UL );
2259 checkNonZeros( upper, 1UL, 2UL );
2260 checkNonZeros( upper, 2UL, 1UL );
2261
2262 if( upper(0,0) != 1 || upper(0,1) != 0 || upper(0,2) != 3 ||
2263 upper(1,0) != 0 || upper(1,1) != 4 || upper(1,2) != 5 ||
2264 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 6 ) {
2265 std::ostringstream oss;
2266 oss << " Test: " << test_ << "\n"
2267 << " Error: Clear operation failed\n"
2268 << " Details:\n"
2269 << " Result:\n" << upper << "\n"
2270 << " Expected result:\n( 1 0 3 )\n( 0 4 5 )\n( 0 0 6 )\n";
2271 throw std::runtime_error( oss.str() );
2272 }
2273
2274 // Clearing a lower element
2275 clear( upper(1,0) );
2276
2277 checkRows ( upper, 3UL );
2278 checkColumns ( upper, 3UL );
2279 checkCapacity( upper, 6UL );
2280 checkNonZeros( upper, 5UL );
2281 checkNonZeros( upper, 0UL, 2UL );
2282 checkNonZeros( upper, 1UL, 2UL );
2283 checkNonZeros( upper, 2UL, 1UL );
2284
2285 if( upper(0,0) != 1 || upper(0,1) != 0 || upper(0,2) != 3 ||
2286 upper(1,0) != 0 || upper(1,1) != 4 || upper(1,2) != 5 ||
2287 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 6 ) {
2288 std::ostringstream oss;
2289 oss << " Test: " << test_ << "\n"
2290 << " Error: Clear operation failed\n"
2291 << " Details:\n"
2292 << " Result:\n" << upper << "\n"
2293 << " Expected result:\n( 1 0 3 )\n( 0 4 5 )\n( 0 0 6 )\n";
2294 throw std::runtime_error( oss.str() );
2295 }
2296
2297 // Clearing the matrix
2298 clear( upper );
2299
2300 checkRows ( upper, 0UL );
2301 checkColumns ( upper, 0UL );
2302 checkNonZeros( upper, 0UL );
2303 }
2304
2305
2306 //=====================================================================================
2307 // Column-major matrix tests
2308 //=====================================================================================
2309
2310 {
2311 test_ = "Column-major UpperMatrix::clear()";
2312
2313 // Initialization check
2314 OUT upper( 3UL );
2315 upper(0,0) = 1;
2316 upper(0,1) = 2;
2317 upper(0,2) = 3;
2318 upper(1,1) = 4;
2319 upper(1,2) = 5;
2320 upper(2,2) = 6;
2321
2322 checkRows ( upper, 3UL );
2323 checkColumns ( upper, 3UL );
2324 checkCapacity( upper, 6UL );
2325 checkNonZeros( upper, 6UL );
2326 checkNonZeros( upper, 0UL, 1UL );
2327 checkNonZeros( upper, 1UL, 2UL );
2328 checkNonZeros( upper, 2UL, 3UL );
2329
2330 if( upper(0,0) != 1 || upper(0,1) != 2 || upper(0,2) != 3 ||
2331 upper(1,0) != 0 || upper(1,1) != 4 || upper(1,2) != 5 ||
2332 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 6 ) {
2333 std::ostringstream oss;
2334 oss << " Test: " << test_ << "\n"
2335 << " Error: Initialization failed\n"
2336 << " Details:\n"
2337 << " Result:\n" << upper << "\n"
2338 << " Expected result:\n( 1 2 3 )\n( 0 4 5 )\n( 0 0 6 )\n";
2339 throw std::runtime_error( oss.str() );
2340 }
2341
2342 // Clearing an upper element
2343 clear( upper(0,1) );
2344
2345 checkRows ( upper, 3UL );
2346 checkColumns ( upper, 3UL );
2347 checkCapacity( upper, 6UL );
2348 checkNonZeros( upper, 5UL );
2349 checkNonZeros( upper, 0UL, 1UL );
2350 checkNonZeros( upper, 1UL, 1UL );
2351 checkNonZeros( upper, 2UL, 3UL );
2352
2353 if( upper(0,0) != 1 || upper(0,1) != 0 || upper(0,2) != 3 ||
2354 upper(1,0) != 0 || upper(1,1) != 4 || upper(1,2) != 5 ||
2355 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 6 ) {
2356 std::ostringstream oss;
2357 oss << " Test: " << test_ << "\n"
2358 << " Error: Clear operation failed\n"
2359 << " Details:\n"
2360 << " Result:\n" << upper << "\n"
2361 << " Expected result:\n( 1 0 3 )\n( 0 4 5 )\n( 0 0 6 )\n";
2362 throw std::runtime_error( oss.str() );
2363 }
2364
2365 // Clearing a lower element
2366 clear( upper(1,0) );
2367
2368 checkRows ( upper, 3UL );
2369 checkColumns ( upper, 3UL );
2370 checkCapacity( upper, 6UL );
2371 checkNonZeros( upper, 5UL );
2372 checkNonZeros( upper, 0UL, 1UL );
2373 checkNonZeros( upper, 1UL, 1UL );
2374 checkNonZeros( upper, 2UL, 3UL );
2375
2376 if( upper(0,0) != 1 || upper(0,1) != 0 || upper(0,2) != 3 ||
2377 upper(1,0) != 0 || upper(1,1) != 4 || upper(1,2) != 5 ||
2378 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 6 ) {
2379 std::ostringstream oss;
2380 oss << " Test: " << test_ << "\n"
2381 << " Error: Clear operation failed\n"
2382 << " Details:\n"
2383 << " Result:\n" << upper << "\n"
2384 << " Expected result:\n( 1 0 3 )\n( 0 4 5 )\n( 0 0 6 )\n";
2385 throw std::runtime_error( oss.str() );
2386 }
2387
2388 // Clearing the matrix
2389 clear( upper );
2390
2391 checkRows ( upper, 0UL );
2392 checkColumns ( upper, 0UL );
2393 checkNonZeros( upper, 0UL );
2394 }
2395 }
2396 //*************************************************************************************************
2397
2398
2399 //*************************************************************************************************
2400 /*!\brief Test of the \c resize() member function of the UpperMatrix specialization.
2401 //
2402 // \return void
2403 // \exception std::runtime_error Error detected.
2404 //
2405 // This function performs a test of the \c resize() member function of the UpperMatrix
2406 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
2407 */
testResize()2408 void SparseTest::testResize()
2409 {
2410 //=====================================================================================
2411 // Row-major matrix tests
2412 //=====================================================================================
2413
2414 {
2415 test_ = "Row-major UpperMatrix::resize()";
2416
2417 // Initialization check
2418 UT upper;
2419
2420 checkRows ( upper, 0UL );
2421 checkColumns ( upper, 0UL );
2422 checkNonZeros( upper, 0UL );
2423
2424 // Resizing to 2x2
2425 upper.resize( 2UL );
2426
2427 checkRows ( upper, 2UL );
2428 checkColumns ( upper, 2UL );
2429 checkNonZeros( upper, 0UL );
2430 checkNonZeros( upper, 0UL, 0UL );
2431 checkNonZeros( upper, 1UL, 0UL );
2432
2433 // Resizing to 4x4 and preserving the elements
2434 upper(0,0) = 1;
2435 upper(0,1) = 2;
2436 upper(1,1) = 3;
2437 upper.resize( 4UL, true );
2438
2439 checkRows ( upper, 4UL );
2440 checkColumns ( upper, 4UL );
2441 checkCapacity( upper, 3UL );
2442 checkNonZeros( upper, 3UL );
2443 checkNonZeros( upper, 0UL, 2UL );
2444 checkNonZeros( upper, 1UL, 1UL );
2445 checkNonZeros( upper, 2UL, 0UL );
2446 checkNonZeros( upper, 3UL, 0UL );
2447
2448 // Resizing to 2x2
2449 upper(2,2) = 4;
2450 upper.resize( 2UL );
2451
2452 checkRows ( upper, 2UL );
2453 checkColumns ( upper, 2UL );
2454 checkCapacity( upper, 3UL );
2455 checkNonZeros( upper, 3UL );
2456 checkNonZeros( upper, 0UL, 2UL );
2457 checkNonZeros( upper, 1UL, 1UL );
2458
2459 // Resizing to 0x0
2460 upper.resize( 0UL );
2461
2462 checkRows ( upper, 0UL );
2463 checkColumns ( upper, 0UL );
2464 checkNonZeros( upper, 0UL );
2465 }
2466
2467
2468 //=====================================================================================
2469 // Column-major matrix tests
2470 //=====================================================================================
2471
2472 {
2473 test_ = "Column-major UpperMatrix::resize()";
2474
2475 // Initialization check
2476 OUT upper;
2477
2478 checkRows ( upper, 0UL );
2479 checkColumns ( upper, 0UL );
2480 checkNonZeros( upper, 0UL );
2481
2482 // Resizing to 2x2
2483 upper.resize( 2UL );
2484
2485 checkRows ( upper, 2UL );
2486 checkColumns ( upper, 2UL );
2487 checkNonZeros( upper, 0UL );
2488 checkNonZeros( upper, 0UL, 0UL );
2489 checkNonZeros( upper, 1UL, 0UL );
2490
2491 // Resizing to 4x4 and preserving the elements
2492 upper(0,0) = 1;
2493 upper(0,1) = 2;
2494 upper(1,1) = 3;
2495 upper.resize( 4UL, true );
2496
2497 checkRows ( upper, 4UL );
2498 checkColumns ( upper, 4UL );
2499 checkCapacity( upper, 3UL );
2500 checkNonZeros( upper, 3UL );
2501 checkNonZeros( upper, 0UL, 1UL );
2502 checkNonZeros( upper, 1UL, 2UL );
2503 checkNonZeros( upper, 2UL, 0UL );
2504 checkNonZeros( upper, 3UL, 0UL );
2505
2506 // Resizing to 2x2
2507 upper(2,2) = 4;
2508 upper.resize( 2UL );
2509
2510 checkRows ( upper, 2UL );
2511 checkColumns ( upper, 2UL );
2512 checkCapacity( upper, 4UL );
2513 checkNonZeros( upper, 3UL );
2514 checkNonZeros( upper, 0UL, 1UL );
2515 checkNonZeros( upper, 1UL, 2UL );
2516
2517 // Resizing to 0x0
2518 upper.resize( 0UL );
2519
2520 checkRows ( upper, 0UL );
2521 checkColumns ( upper, 0UL );
2522 checkNonZeros( upper, 0UL );
2523 }
2524 }
2525 //*************************************************************************************************
2526
2527
2528 //*************************************************************************************************
2529 /*!\brief Test of the \c reserve() member function of the UpperMatrix specialization.
2530 //
2531 // \return void
2532 // \exception std::runtime_error Error detected.
2533 //
2534 // This function performs a test of the \c reserve() member function of the UpperMatrix
2535 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
2536 */
testReserve()2537 void SparseTest::testReserve()
2538 {
2539 //=====================================================================================
2540 // Row-major matrix tests
2541 //=====================================================================================
2542
2543 {
2544 test_ = "Row-major UpperMatrix::reserve()";
2545
2546 // Initialization check
2547 UT upper;
2548
2549 checkRows ( upper, 0UL );
2550 checkColumns ( upper, 0UL );
2551 checkNonZeros( upper, 0UL );
2552
2553 // Increasing the capacity of the matrix
2554 upper.reserve( 10UL );
2555
2556 checkRows ( upper, 0UL );
2557 checkColumns ( upper, 0UL );
2558 checkCapacity( upper, 10UL );
2559 checkNonZeros( upper, 0UL );
2560
2561 // Further increasing the capacity of the matrix
2562 upper.reserve( 20UL );
2563
2564 checkRows ( upper, 0UL );
2565 checkColumns ( upper, 0UL );
2566 checkCapacity( upper, 20UL );
2567 checkNonZeros( upper, 0UL );
2568 }
2569
2570
2571 //=====================================================================================
2572 // Column-major matrix tests
2573 //=====================================================================================
2574
2575 {
2576 test_ = "Column-major UpperMatrix::reserve()";
2577
2578 // Initialization check
2579 OUT upper;
2580
2581 checkRows ( upper, 0UL );
2582 checkColumns ( upper, 0UL );
2583 checkNonZeros( upper, 0UL );
2584
2585 // Increasing the capacity of the matrix
2586 upper.reserve( 10UL );
2587
2588 checkRows ( upper, 0UL );
2589 checkColumns ( upper, 0UL );
2590 checkCapacity( upper, 10UL );
2591 checkNonZeros( upper, 0UL );
2592
2593 // Further increasing the capacity of the matrix
2594 upper.reserve( 20UL );
2595
2596 checkRows ( upper, 0UL );
2597 checkColumns ( upper, 0UL );
2598 checkCapacity( upper, 20UL );
2599 checkNonZeros( upper, 0UL );
2600 }
2601 }
2602 //*************************************************************************************************
2603
2604
2605 //*************************************************************************************************
2606 /*!\brief Test of the \c trim() member function of the UpperMatrix specialization.
2607 //
2608 // \return void
2609 // \exception std::runtime_error Error detected.
2610 //
2611 // This function performs a test of the \c trim() member function of the UpperMatrix
2612 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
2613 */
testTrim()2614 void SparseTest::testTrim()
2615 {
2616 //=====================================================================================
2617 // Row-major matrix tests
2618 //=====================================================================================
2619
2620 {
2621 test_ = "Row-major UpperMatrix::trim()";
2622
2623 // Initialization check
2624 UT upper( 3UL );
2625
2626 checkRows ( upper, 3UL );
2627 checkColumns ( upper, 3UL );
2628 checkNonZeros( upper, 0UL );
2629
2630 // Increasing the row capacity of the matrix
2631 upper.reserve( 0UL, 10UL );
2632 upper.reserve( 1UL, 15UL );
2633 upper.reserve( 2UL, 20UL );
2634
2635 checkRows ( upper, 3UL );
2636 checkColumns ( upper, 3UL );
2637 checkCapacity( upper, 45UL );
2638 checkCapacity( upper, 0UL, 10UL );
2639 checkCapacity( upper, 1UL, 15UL );
2640 checkCapacity( upper, 2UL, 20UL );
2641
2642 // Trimming the matrix
2643 upper.trim();
2644
2645 checkRows ( upper, 3UL );
2646 checkColumns ( upper, 3UL );
2647 checkCapacity( upper, 45UL );
2648 checkCapacity( upper, 0UL, 0UL );
2649 checkCapacity( upper, 1UL, 0UL );
2650 checkCapacity( upper, 2UL, 0UL );
2651 }
2652
2653 {
2654 test_ = "Row-major UpperMatrix::trim( size_t )";
2655
2656 // Initialization check
2657 UT upper( 3UL, 3UL );
2658
2659 checkRows ( upper, 3UL );
2660 checkColumns ( upper, 3UL );
2661 checkNonZeros( upper, 0UL );
2662
2663 // Increasing the row capacity of the matrix
2664 upper.reserve( 0UL, 10UL );
2665 upper.reserve( 1UL, 15UL );
2666 upper.reserve( 2UL, 20UL );
2667
2668 checkRows ( upper, 3UL );
2669 checkColumns ( upper, 3UL );
2670 checkCapacity( upper, 45UL );
2671 checkCapacity( upper, 0UL, 10UL );
2672 checkCapacity( upper, 1UL, 15UL );
2673 checkCapacity( upper, 2UL, 20UL );
2674
2675 // Trimming the 0th row
2676 upper.trim( 0UL );
2677
2678 checkRows ( upper, 3UL );
2679 checkColumns ( upper, 3UL );
2680 checkCapacity( upper, 45UL );
2681 checkCapacity( upper, 0UL, 0UL );
2682 checkCapacity( upper, 1UL, 25UL );
2683 checkCapacity( upper, 2UL, 20UL );
2684
2685 // Trimming the 1st row
2686 upper.trim( 1UL );
2687
2688 checkRows ( upper, 3UL );
2689 checkColumns ( upper, 3UL );
2690 checkCapacity( upper, 45UL );
2691 checkCapacity( upper, 0UL, 0UL );
2692 checkCapacity( upper, 1UL, 0UL );
2693 checkCapacity( upper, 2UL, 45UL );
2694
2695 // Trimming the 2nd row
2696 upper.trim( 2UL );
2697
2698 checkRows ( upper, 3UL );
2699 checkColumns ( upper, 3UL );
2700 checkCapacity( upper, 45UL );
2701 checkCapacity( upper, 0UL, 0UL );
2702 checkCapacity( upper, 1UL, 0UL );
2703 checkCapacity( upper, 2UL, 0UL );
2704 }
2705
2706
2707 //=====================================================================================
2708 // Column-major matrix tests
2709 //=====================================================================================
2710
2711 {
2712 test_ = "Column-major UpperMatrix::trim()";
2713
2714 // Initialization check
2715 OUT upper( 3UL );
2716
2717 checkRows ( upper, 3UL );
2718 checkColumns ( upper, 3UL );
2719 checkNonZeros( upper, 0UL );
2720
2721 // Increasing the row capacity of the matrix
2722 upper.reserve( 0UL, 10UL );
2723 upper.reserve( 1UL, 15UL );
2724 upper.reserve( 2UL, 20UL );
2725
2726 checkRows ( upper, 3UL );
2727 checkColumns ( upper, 3UL );
2728 checkCapacity( upper, 45UL );
2729 checkCapacity( upper, 0UL, 10UL );
2730 checkCapacity( upper, 1UL, 15UL );
2731 checkCapacity( upper, 2UL, 20UL );
2732
2733 // Trimming the matrix
2734 upper.trim();
2735
2736 checkRows ( upper, 3UL );
2737 checkColumns ( upper, 3UL );
2738 checkCapacity( upper, 45UL );
2739 checkCapacity( upper, 0UL, 0UL );
2740 checkCapacity( upper, 1UL, 0UL );
2741 checkCapacity( upper, 2UL, 0UL );
2742 }
2743
2744 {
2745 test_ = "Column-major UpperMatrix::trim( size_t )";
2746
2747 // Initialization check
2748 OUT upper( 3UL, 3UL );
2749
2750 checkRows ( upper, 3UL );
2751 checkColumns ( upper, 3UL );
2752 checkNonZeros( upper, 0UL );
2753
2754 // Increasing the column capacity of the matrix
2755 upper.reserve( 0UL, 10UL );
2756 upper.reserve( 1UL, 15UL );
2757 upper.reserve( 2UL, 20UL );
2758
2759 checkRows ( upper, 3UL );
2760 checkColumns ( upper, 3UL );
2761 checkCapacity( upper, 45UL );
2762 checkCapacity( upper, 0UL, 10UL );
2763 checkCapacity( upper, 1UL, 15UL );
2764 checkCapacity( upper, 2UL, 20UL );
2765
2766 // Trimming the 0th column
2767 upper.trim( 0UL );
2768
2769 checkRows ( upper, 3UL );
2770 checkColumns ( upper, 3UL );
2771 checkCapacity( upper, 45UL );
2772 checkCapacity( upper, 0UL, 0UL );
2773 checkCapacity( upper, 1UL, 25UL );
2774 checkCapacity( upper, 2UL, 20UL );
2775
2776 // Trimming the 1st column
2777 upper.trim( 1UL );
2778
2779 checkRows ( upper, 3UL );
2780 checkColumns ( upper, 3UL );
2781 checkCapacity( upper, 45UL );
2782 checkCapacity( upper, 0UL, 0UL );
2783 checkCapacity( upper, 1UL, 0UL );
2784 checkCapacity( upper, 2UL, 45UL );
2785
2786 // Trimming the 2nd column
2787 upper.trim( 2UL );
2788
2789 checkRows ( upper, 3UL );
2790 checkColumns ( upper, 3UL );
2791 checkCapacity( upper, 45UL );
2792 checkCapacity( upper, 0UL, 0UL );
2793 checkCapacity( upper, 1UL, 0UL );
2794 checkCapacity( upper, 2UL, 0UL );
2795 }
2796 }
2797 //*************************************************************************************************
2798
2799
2800 //*************************************************************************************************
2801 /*!\brief Test of the \c shrinkToFit() member function of the UpperMatrix specialization.
2802 //
2803 // \return void
2804 // \exception std::runtime_error Error detected.
2805 //
2806 // This function performs a test of the \c shrinkToFit() member function of the UpperMatrix
2807 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
2808 */
testShrinkToFit()2809 void SparseTest::testShrinkToFit()
2810 {
2811 //=====================================================================================
2812 // Row-major matrix tests
2813 //=====================================================================================
2814
2815 {
2816 test_ = "Row-major UpperMatrix::shrinkToFit()";
2817
2818 // Shrinking a matrix without excessive capacity
2819 {
2820 UT upper( 3UL, 6UL );
2821 upper(0,0) = 1;
2822 upper(0,1) = 2;
2823 upper(0,2) = 3;
2824 upper(1,1) = 4;
2825 upper(1,2) = 5;
2826 upper(2,2) = 6;
2827
2828 upper.shrinkToFit();
2829
2830 checkRows ( upper, 3UL );
2831 checkColumns ( upper, 3UL );
2832 checkCapacity( upper, 6UL );
2833 checkNonZeros( upper, 6UL );
2834 checkNonZeros( upper, 0UL, 3UL );
2835 checkNonZeros( upper, 1UL, 2UL );
2836 checkNonZeros( upper, 2UL, 1UL );
2837
2838 if( upper.capacity() != upper.nonZeros() ) {
2839 std::ostringstream oss;
2840 oss << " Test: " << test_ << "\n"
2841 << " Error: Shrinking the matrix failed\n"
2842 << " Details:\n"
2843 << " Capacity : " << upper.capacity() << "\n"
2844 << " Expected capacity: " << upper.nonZeros() << "\n";
2845 throw std::runtime_error( oss.str() );
2846 }
2847
2848 if( upper(0,0) != 1 || upper(0,1) != 2 || upper(0,2) != 3 ||
2849 upper(1,0) != 0 || upper(1,1) != 4 || upper(1,2) != 5 ||
2850 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 6 ) {
2851 std::ostringstream oss;
2852 oss << " Test: " << test_ << "\n"
2853 << " Error: Shrinking the matrix failed\n"
2854 << " Details:\n"
2855 << " Result:\n" << upper << "\n"
2856 << " Expected result:\n( 1 2 3 )\n( 0 4 5 )\n( 0 0 6 )\n";
2857 throw std::runtime_error( oss.str() );
2858 }
2859 }
2860
2861 // Shrinking a matrix with excessive capacity
2862 {
2863 UT upper( 3UL, 100UL );
2864 upper(0,0) = 1;
2865 upper(0,1) = 2;
2866 upper(0,2) = 3;
2867 upper(1,1) = 4;
2868 upper(1,2) = 5;
2869 upper(2,2) = 6;
2870
2871 upper.shrinkToFit();
2872
2873 checkRows ( upper, 3UL );
2874 checkColumns ( upper, 3UL );
2875 checkCapacity( upper, 6UL );
2876 checkNonZeros( upper, 6UL );
2877 checkNonZeros( upper, 0UL, 3UL );
2878 checkNonZeros( upper, 1UL, 2UL );
2879 checkNonZeros( upper, 2UL, 1UL );
2880
2881 if( upper.capacity() != upper.nonZeros() ) {
2882 std::ostringstream oss;
2883 oss << " Test: " << test_ << "\n"
2884 << " Error: Shrinking the matrix failed\n"
2885 << " Details:\n"
2886 << " Capacity : " << upper.capacity() << "\n"
2887 << " Expected capacity: " << upper.nonZeros() << "\n";
2888 throw std::runtime_error( oss.str() );
2889 }
2890
2891 if( upper(0,0) != 1 || upper(0,1) != 2 || upper(0,2) != 3 ||
2892 upper(1,0) != 0 || upper(1,1) != 4 || upper(1,2) != 5 ||
2893 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 6 ) {
2894 std::ostringstream oss;
2895 oss << " Test: " << test_ << "\n"
2896 << " Error: Shrinking the matrix failed\n"
2897 << " Details:\n"
2898 << " Result:\n" << upper << "\n"
2899 << " Expected result:\n( 1 2 3 )\n( 0 4 5 )\n( 0 0 6 )\n";
2900 throw std::runtime_error( oss.str() );
2901 }
2902 }
2903 }
2904
2905
2906 //=====================================================================================
2907 // Column-major matrix tests
2908 //=====================================================================================
2909
2910 {
2911 test_ = "Column-major UpperMatrix::shrinkToFit()";
2912
2913 // Shrinking a matrix without excessive capacity
2914 {
2915 OUT upper( 3UL, 6UL );
2916 upper(0,0) = 1;
2917 upper(0,1) = 2;
2918 upper(0,2) = 3;
2919 upper(1,1) = 4;
2920 upper(1,2) = 5;
2921 upper(2,2) = 6;
2922
2923 upper.shrinkToFit();
2924
2925 checkRows ( upper, 3UL );
2926 checkColumns ( upper, 3UL );
2927 checkCapacity( upper, 6UL );
2928 checkNonZeros( upper, 6UL );
2929 checkNonZeros( upper, 0UL, 1UL );
2930 checkNonZeros( upper, 1UL, 2UL );
2931 checkNonZeros( upper, 2UL, 3UL );
2932
2933 if( upper.capacity() != upper.nonZeros() ) {
2934 std::ostringstream oss;
2935 oss << " Test: " << test_ << "\n"
2936 << " Error: Shrinking the matrix failed\n"
2937 << " Details:\n"
2938 << " Capacity : " << upper.capacity() << "\n"
2939 << " Expected capacity: " << upper.nonZeros() << "\n";
2940 throw std::runtime_error( oss.str() );
2941 }
2942
2943 if( upper(0,0) != 1 || upper(0,1) != 2 || upper(0,2) != 3 ||
2944 upper(1,0) != 0 || upper(1,1) != 4 || upper(1,2) != 5 ||
2945 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 6 ) {
2946 std::ostringstream oss;
2947 oss << " Test: " << test_ << "\n"
2948 << " Error: Shrinking the matrix failed\n"
2949 << " Details:\n"
2950 << " Result:\n" << upper << "\n"
2951 << " Expected result:\n( 1 2 3 )\n( 0 4 5 )\n( 0 0 6 )\n";
2952 throw std::runtime_error( oss.str() );
2953 }
2954 }
2955
2956 // Shrinking a matrix with excessive capacity
2957 {
2958 OUT upper( 3UL, 100UL );
2959 upper(0,0) = 1;
2960 upper(0,1) = 2;
2961 upper(0,2) = 3;
2962 upper(1,1) = 4;
2963 upper(1,2) = 5;
2964 upper(2,2) = 6;
2965
2966 upper.shrinkToFit();
2967
2968 checkRows ( upper, 3UL );
2969 checkColumns ( upper, 3UL );
2970 checkCapacity( upper, 6UL );
2971 checkNonZeros( upper, 6UL );
2972 checkNonZeros( upper, 0UL, 1UL );
2973 checkNonZeros( upper, 1UL, 2UL );
2974 checkNonZeros( upper, 2UL, 3UL );
2975
2976 if( upper.capacity() != upper.nonZeros() ) {
2977 std::ostringstream oss;
2978 oss << " Test: " << test_ << "\n"
2979 << " Error: Shrinking the matrix failed\n"
2980 << " Details:\n"
2981 << " Capacity : " << upper.capacity() << "\n"
2982 << " Expected capacity: " << upper.nonZeros() << "\n";
2983 throw std::runtime_error( oss.str() );
2984 }
2985
2986 if( upper(0,0) != 1 || upper(0,1) != 2 || upper(0,2) != 3 ||
2987 upper(1,0) != 0 || upper(1,1) != 4 || upper(1,2) != 5 ||
2988 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 6 ) {
2989 std::ostringstream oss;
2990 oss << " Test: " << test_ << "\n"
2991 << " Error: Shrinking the matrix failed\n"
2992 << " Details:\n"
2993 << " Result:\n" << upper << "\n"
2994 << " Expected result:\n( 1 2 3 )\n( 0 4 5 )\n( 0 0 6 )\n";
2995 throw std::runtime_error( oss.str() );
2996 }
2997 }
2998 }
2999 }
3000 //*************************************************************************************************
3001
3002
3003 //*************************************************************************************************
3004 /*!\brief Test of the \c swap() functionality of the UpperMatrix specialization.
3005 //
3006 // \return void
3007 // \exception std::runtime_error Error detected.
3008 //
3009 // This function performs a test of the \c swap() function of the UpperMatrix specialization.
3010 // In case an error is detected, a \a std::runtime_error exception is thrown.
3011 */
testSwap()3012 void SparseTest::testSwap()
3013 {
3014 //=====================================================================================
3015 // Row-major matrix tests
3016 //=====================================================================================
3017
3018 {
3019 test_ = "Row-major UpperMatrix swap";
3020
3021 UT upper1( 2UL );
3022 upper1(0,0) = 1;
3023 upper1(0,1) = 2;
3024 upper1(1,1) = 3;
3025
3026 UT upper2( 2UL );
3027 upper2(0,0) = 4;
3028 upper2(0,1) = 5;
3029 upper2(1,1) = 0;
3030
3031 swap( upper1, upper2 );
3032
3033 checkRows ( upper1, 2UL );
3034 checkColumns ( upper1, 2UL );
3035 checkCapacity( upper1, 2UL );
3036 checkNonZeros( upper1, 2UL );
3037 checkNonZeros( upper1, 0UL, 2UL );
3038 checkNonZeros( upper1, 1UL, 0UL );
3039
3040 if( upper1(0,0) != 4 || upper1(0,1) != 5 || upper1(1,0) != 0 || upper1(1,1) != 0 ) {
3041 std::ostringstream oss;
3042 oss << " Test: " << test_ << "\n"
3043 << " Error: Swapping the first matrix failed\n"
3044 << " Details:\n"
3045 << " Result:\n" << upper1 << "\n"
3046 << " Expected result:\n( 4 5 )\n( 0 0 )\n";
3047 throw std::runtime_error( oss.str() );
3048 }
3049
3050 checkRows ( upper2, 2UL );
3051 checkColumns ( upper2, 2UL );
3052 checkCapacity( upper2, 4UL );
3053 checkNonZeros( upper2, 3UL );
3054 checkNonZeros( upper2, 0UL, 2UL );
3055 checkNonZeros( upper2, 1UL, 1UL );
3056
3057 if( upper2(0,0) != 1 || upper2(0,1) != 2 || upper2(1,0) != 0 || upper2(1,1) != 3 ) {
3058 std::ostringstream oss;
3059 oss << " Test: " << test_ << "\n"
3060 << " Error: Swapping the second matrix failed\n"
3061 << " Details:\n"
3062 << " Result:\n" << upper2 << "\n"
3063 << " Expected result:\n( 1 2 )\n( 0 3 )\n";
3064 throw std::runtime_error( oss.str() );
3065 }
3066 }
3067
3068
3069 //=====================================================================================
3070 // Column-major matrix tests
3071 //=====================================================================================
3072
3073 {
3074 test_ = "Column-major UpperMatrix swap";
3075
3076 OUT upper1( 2UL );
3077 upper1(0,0) = 1;
3078 upper1(0,1) = 2;
3079 upper1(1,1) = 3;
3080
3081 OUT upper2( 2UL );
3082 upper2(0,0) = 4;
3083 upper2(0,1) = 5;
3084 upper2(1,1) = 0;
3085
3086 swap( upper1, upper2 );
3087
3088 checkRows ( upper1, 2UL );
3089 checkColumns ( upper1, 2UL );
3090 checkCapacity( upper1, 2UL );
3091 checkNonZeros( upper1, 2UL );
3092 checkNonZeros( upper1, 0UL, 1UL );
3093 checkNonZeros( upper1, 1UL, 1UL );
3094
3095 if( upper1(0,0) != 4 || upper1(0,1) != 5 || upper1(1,0) != 0 || upper1(1,1) != 0 ) {
3096 std::ostringstream oss;
3097 oss << " Test: " << test_ << "\n"
3098 << " Error: Swapping the first matrix failed\n"
3099 << " Details:\n"
3100 << " Result:\n" << upper1 << "\n"
3101 << " Expected result:\n( 4 5 )\n( 0 0 )\n";
3102 throw std::runtime_error( oss.str() );
3103 }
3104
3105 checkRows ( upper2, 2UL );
3106 checkColumns ( upper2, 2UL );
3107 checkCapacity( upper2, 4UL );
3108 checkNonZeros( upper2, 3UL );
3109 checkNonZeros( upper2, 0UL, 1UL );
3110 checkNonZeros( upper2, 1UL, 2UL );
3111
3112 if( upper2(0,0) != 1 || upper2(0,1) != 2 || upper2(1,0) != 0 || upper2(1,1) != 3 ) {
3113 std::ostringstream oss;
3114 oss << " Test: " << test_ << "\n"
3115 << " Error: Swapping the second matrix failed\n"
3116 << " Details:\n"
3117 << " Result:\n" << upper2 << "\n"
3118 << " Expected result:\n( 1 2 )\n( 0 3 )\n";
3119 throw std::runtime_error( oss.str() );
3120 }
3121 }
3122 }
3123 //*************************************************************************************************
3124
3125
3126 //*************************************************************************************************
3127 /*!\brief Test of the \c set() member function of the UpperMatrix specialization.
3128 //
3129 // \return void
3130 // \exception std::runtime_error Error detected.
3131 //
3132 // This function performs a test of the \c set() member function of the UpperMatrix
3133 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
3134 */
testSet()3135 void SparseTest::testSet()
3136 {
3137 //=====================================================================================
3138 // Row-major matrix tests
3139 //=====================================================================================
3140
3141 {
3142 test_ = "Row-major UpperMatrix::set()";
3143
3144 using Iterator = UT::Iterator;
3145
3146 // Initialization check
3147 UT upper( 4UL );
3148
3149 checkRows ( upper, 4UL );
3150 checkColumns ( upper, 4UL );
3151 checkNonZeros( upper, 0UL );
3152 checkNonZeros( upper, 0UL, 0UL );
3153 checkNonZeros( upper, 1UL, 0UL );
3154 checkNonZeros( upper, 2UL, 0UL );
3155 checkNonZeros( upper, 3UL, 0UL );
3156
3157 // Setting a non-zero element
3158 {
3159 Iterator pos = upper.set( 1UL, 2UL, 1 );
3160
3161 checkRows ( upper, 4UL );
3162 checkColumns ( upper, 4UL );
3163 checkCapacity( upper, 1UL );
3164 checkNonZeros( upper, 1UL );
3165 checkNonZeros( upper, 0UL, 0UL );
3166 checkNonZeros( upper, 1UL, 1UL );
3167 checkNonZeros( upper, 2UL, 0UL );
3168 checkNonZeros( upper, 3UL, 0UL );
3169
3170 if( pos->value() != 1 || pos->index() != 2UL ) {
3171 std::ostringstream oss;
3172 oss << " Test: " << test_ << "\n"
3173 << " Error: Invalid iterator returned\n"
3174 << " Details:\n"
3175 << " Value: " << pos->value() << "\n"
3176 << " Index: " << pos->index() << "\n"
3177 << " Expected value: 1\n"
3178 << " Expected index: 2\n";
3179 throw std::runtime_error( oss.str() );
3180 }
3181
3182 if( upper(1,2) != 1 ) {
3183 std::ostringstream oss;
3184 oss << " Test: " << test_ << "\n"
3185 << " Error: Setting an element failed\n"
3186 << " Details:\n"
3187 << " Result:\n" << upper << "\n"
3188 << " Expected result:\n( 0 0 0 0 )\n( 0 0 1 0 )\n( 0 0 0 0 )\n( 0 0 0 0 )\n";
3189 throw std::runtime_error( oss.str() );
3190 }
3191 }
3192
3193 // Setting a second non-zero element
3194 {
3195 Iterator pos = upper.set( 1UL, 1UL, 2 );
3196
3197 checkRows ( upper, 4UL );
3198 checkColumns ( upper, 4UL );
3199 checkCapacity( upper, 2UL );
3200 checkNonZeros( upper, 2UL );
3201 checkNonZeros( upper, 0UL, 0UL );
3202 checkNonZeros( upper, 1UL, 2UL );
3203 checkNonZeros( upper, 2UL, 0UL );
3204 checkNonZeros( upper, 3UL, 0UL );
3205
3206 if( pos->value() != 2 || pos->index() != 1UL ) {
3207 std::ostringstream oss;
3208 oss << " Test: " << test_ << "\n"
3209 << " Error: Invalid iterator returned\n"
3210 << " Details:\n"
3211 << " Value: " << pos->value() << "\n"
3212 << " Index: " << pos->index() << "\n"
3213 << " Expected value: 2\n"
3214 << " Expected index: 1\n";
3215 throw std::runtime_error( oss.str() );
3216 }
3217
3218 if( upper(1,1) != 2 || upper(1,2) != 1 ) {
3219 std::ostringstream oss;
3220 oss << " Test: " << test_ << "\n"
3221 << " Error: Setting an element failed\n"
3222 << " Details:\n"
3223 << " Result:\n" << upper << "\n"
3224 << " Expected result:\n( 0 0 0 0 )\n( 0 2 1 0 )\n( 0 0 0 0 )\n( 0 0 0 0 )\n";
3225 throw std::runtime_error( oss.str() );
3226 }
3227 }
3228
3229 // Setting a third non-zero element
3230 {
3231 Iterator pos = upper.set( 1UL, 3UL, 3 );
3232
3233 checkRows ( upper, 4UL );
3234 checkColumns ( upper, 4UL );
3235 checkCapacity( upper, 3UL );
3236 checkNonZeros( upper, 3UL );
3237 checkNonZeros( upper, 0UL, 0UL );
3238 checkNonZeros( upper, 1UL, 3UL );
3239 checkNonZeros( upper, 2UL, 0UL );
3240 checkNonZeros( upper, 3UL, 0UL );
3241
3242 if( pos->value() != 3 || pos->index() != 3UL ) {
3243 std::ostringstream oss;
3244 oss << " Test: " << test_ << "\n"
3245 << " Error: Invalid iterator returned\n"
3246 << " Details:\n"
3247 << " Value: " << pos->value() << "\n"
3248 << " Index: " << pos->index() << "\n"
3249 << " Expected value: 3\n"
3250 << " Expected index: 3\n";
3251 throw std::runtime_error( oss.str() );
3252 }
3253
3254 if( upper(1,1) != 2 || upper(1,2) != 1 || upper(1,3) != 3 ) {
3255 std::ostringstream oss;
3256 oss << " Test: " << test_ << "\n"
3257 << " Error: Setting an element failed\n"
3258 << " Details:\n"
3259 << " Result:\n" << upper << "\n"
3260 << " Expected result:\n( 0 0 0 0 )\n( 0 2 1 3 )\n( 0 0 0 0 )\n( 0 0 0 0 )\n";
3261 throw std::runtime_error( oss.str() );
3262 }
3263 }
3264
3265 // Setting an already existing element
3266 {
3267 Iterator pos = upper.set( 1UL, 2UL, 4 );
3268
3269 checkRows ( upper, 4UL );
3270 checkColumns ( upper, 4UL );
3271 checkCapacity( upper, 3UL );
3272 checkNonZeros( upper, 3UL );
3273 checkNonZeros( upper, 0UL, 0UL );
3274 checkNonZeros( upper, 1UL, 3UL );
3275 checkNonZeros( upper, 2UL, 0UL );
3276 checkNonZeros( upper, 3UL, 0UL );
3277
3278 if( pos->value() != 4 || pos->index() != 2UL ) {
3279 std::ostringstream oss;
3280 oss << " Test: " << test_ << "\n"
3281 << " Error: Invalid iterator returned\n"
3282 << " Details:\n"
3283 << " Value: " << pos->value() << "\n"
3284 << " Index: " << pos->index() << "\n"
3285 << " Expected value: 4\n"
3286 << " Expected index: 2\n";
3287 throw std::runtime_error( oss.str() );
3288 }
3289
3290 if( upper(1,1) != 2 || upper(1,2) != 4 || upper(1,3) != 3 ) {
3291 std::ostringstream oss;
3292 oss << " Test: " << test_ << "\n"
3293 << " Error: Setting an element failed\n"
3294 << " Details:\n"
3295 << " Result:\n" << upper << "\n"
3296 << " Expected result:\n( 0 0 0 0 )\n( 0 2 4 3 )\n( 0 0 0 0 )\n( 0 0 0 0 )\n";
3297 throw std::runtime_error( oss.str() );
3298 }
3299 }
3300 }
3301
3302
3303 //=====================================================================================
3304 // Column-major matrix tests
3305 //=====================================================================================
3306
3307 {
3308 test_ = "Column-major UpperMatrix::set()";
3309
3310 using Iterator = OUT::Iterator;
3311
3312 // Initialization check
3313 OUT upper( 4UL );
3314
3315 checkRows ( upper, 4UL );
3316 checkColumns ( upper, 4UL );
3317 checkNonZeros( upper, 0UL );
3318 checkNonZeros( upper, 0UL, 0UL );
3319 checkNonZeros( upper, 1UL, 0UL );
3320 checkNonZeros( upper, 2UL, 0UL );
3321 checkNonZeros( upper, 3UL, 0UL );
3322
3323 // Setting a non-zero element
3324 {
3325 Iterator pos = upper.set( 1UL, 2UL, 1 );
3326
3327 checkRows ( upper, 4UL );
3328 checkColumns ( upper, 4UL );
3329 checkCapacity( upper, 1UL );
3330 checkNonZeros( upper, 1UL );
3331 checkNonZeros( upper, 0UL, 0UL );
3332 checkNonZeros( upper, 1UL, 0UL );
3333 checkNonZeros( upper, 2UL, 1UL );
3334 checkNonZeros( upper, 3UL, 0UL );
3335
3336 if( pos->value() != 1 || pos->index() != 1UL ) {
3337 std::ostringstream oss;
3338 oss << " Test: " << test_ << "\n"
3339 << " Error: Invalid iterator returned\n"
3340 << " Details:\n"
3341 << " Value: " << pos->value() << "\n"
3342 << " Index: " << pos->index() << "\n"
3343 << " Expected value: 1\n"
3344 << " Expected index: 1\n";
3345 throw std::runtime_error( oss.str() );
3346 }
3347
3348 if( upper(1,2) != 1 ) {
3349 std::ostringstream oss;
3350 oss << " Test: " << test_ << "\n"
3351 << " Error: Setting an element failed\n"
3352 << " Details:\n"
3353 << " Result:\n" << upper << "\n"
3354 << " Expected result:\n( 0 0 0 0 )\n( 0 0 1 0 )\n( 0 0 0 0 )\n( 0 0 0 0 )\n";
3355 throw std::runtime_error( oss.str() );
3356 }
3357 }
3358
3359 // Setting a second non-zero element
3360 {
3361 Iterator pos = upper.set( 2UL, 2UL, 2 );
3362
3363 checkRows ( upper, 4UL );
3364 checkColumns ( upper, 4UL );
3365 checkCapacity( upper, 2UL );
3366 checkNonZeros( upper, 2UL );
3367 checkNonZeros( upper, 0UL, 0UL );
3368 checkNonZeros( upper, 1UL, 0UL );
3369 checkNonZeros( upper, 2UL, 2UL );
3370 checkNonZeros( upper, 3UL, 0UL );
3371
3372 if( pos->value() != 2 || pos->index() != 2UL ) {
3373 std::ostringstream oss;
3374 oss << " Test: " << test_ << "\n"
3375 << " Error: Invalid iterator returned\n"
3376 << " Details:\n"
3377 << " Value: " << pos->value() << "\n"
3378 << " Index: " << pos->index() << "\n"
3379 << " Expected value: 2\n"
3380 << " Expected index: 2\n";
3381 throw std::runtime_error( oss.str() );
3382 }
3383
3384 if( upper(1,2) != 1 || upper(2,2) != 2 ) {
3385 std::ostringstream oss;
3386 oss << " Test: " << test_ << "\n"
3387 << " Error: Setting an element failed\n"
3388 << " Details:\n"
3389 << " Result:\n" << upper << "\n"
3390 << " Expected result:\n( 0 0 0 0 )\n( 0 0 1 0 )\n( 0 0 2 0 )\n( 0 0 0 0 )\n";
3391 throw std::runtime_error( oss.str() );
3392 }
3393 }
3394
3395 // Setting a third non-zero element
3396 {
3397 Iterator pos = upper.set( 0UL, 2UL, 3 );
3398
3399 checkRows ( upper, 4UL );
3400 checkColumns ( upper, 4UL );
3401 checkCapacity( upper, 3UL );
3402 checkNonZeros( upper, 3UL );
3403 checkNonZeros( upper, 0UL, 0UL );
3404 checkNonZeros( upper, 1UL, 0UL );
3405 checkNonZeros( upper, 2UL, 3UL );
3406 checkNonZeros( upper, 3UL, 0UL );
3407
3408 if( pos->value() != 3 || pos->index() != 0UL ) {
3409 std::ostringstream oss;
3410 oss << " Test: " << test_ << "\n"
3411 << " Error: Invalid iterator returned\n"
3412 << " Details:\n"
3413 << " Value: " << pos->value() << "\n"
3414 << " Index: " << pos->index() << "\n"
3415 << " Expected value: 3\n"
3416 << " Expected index: 0\n";
3417 throw std::runtime_error( oss.str() );
3418 }
3419
3420 if( upper(0,2) != 3 || upper(1,2) != 1 || upper(2,2) != 2 ) {
3421 std::ostringstream oss;
3422 oss << " Test: " << test_ << "\n"
3423 << " Error: Setting an element failed\n"
3424 << " Details:\n"
3425 << " Result:\n" << upper << "\n"
3426 << " Expected result:\n( 0 0 3 0 )\n( 0 0 1 0 )\n( 0 0 2 0 )\n( 0 0 0 0 )\n";
3427 throw std::runtime_error( oss.str() );
3428 }
3429 }
3430
3431 // Setting an already existing element
3432 {
3433 Iterator pos = upper.set( 1UL, 2UL, 4 );
3434
3435 checkRows ( upper, 4UL );
3436 checkColumns ( upper, 4UL );
3437 checkCapacity( upper, 3UL );
3438 checkNonZeros( upper, 3UL );
3439 checkNonZeros( upper, 0UL, 0UL );
3440 checkNonZeros( upper, 1UL, 0UL );
3441 checkNonZeros( upper, 2UL, 3UL );
3442 checkNonZeros( upper, 3UL, 0UL );
3443
3444 if( pos->value() != 4 || pos->index() != 1UL ) {
3445 std::ostringstream oss;
3446 oss << " Test: " << test_ << "\n"
3447 << " Error: Invalid iterator returned\n"
3448 << " Details:\n"
3449 << " Value: " << pos->value() << "\n"
3450 << " Index: " << pos->index() << "\n"
3451 << " Expected value: 4\n"
3452 << " Expected index: 1\n";
3453 throw std::runtime_error( oss.str() );
3454 }
3455
3456 if( upper(0,2) != 3 || upper(1,2) != 4 || upper(2,2) != 2 ) {
3457 std::ostringstream oss;
3458 oss << " Test: " << test_ << "\n"
3459 << " Error: Setting an element failed\n"
3460 << " Details:\n"
3461 << " Result:\n" << upper << "\n"
3462 << " Expected result:\n( 0 0 3 0 )\n( 0 0 4 0 )\n( 0 0 2 0 )\n( 0 0 0 0 )\n";
3463 throw std::runtime_error( oss.str() );
3464 }
3465 }
3466 }
3467 }
3468 //*************************************************************************************************
3469
3470
3471 //*************************************************************************************************
3472 /*!\brief Test of the \c insert() member function of the UpperMatrix specialization.
3473 //
3474 // \return void
3475 // \exception std::runtime_error Error detected.
3476 //
3477 // This function performs a test of the \c insert() member function of the UpperMatrix
3478 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
3479 */
testInsert()3480 void SparseTest::testInsert()
3481 {
3482 //=====================================================================================
3483 // Row-major matrix tests
3484 //=====================================================================================
3485
3486 {
3487 test_ = "Row-major UpperMatrix::insert()";
3488
3489 using Iterator = UT::Iterator;
3490
3491 // Initialization check
3492 UT upper( 4UL );
3493
3494 checkRows ( upper, 4UL );
3495 checkColumns ( upper, 4UL );
3496 checkNonZeros( upper, 0UL );
3497 checkNonZeros( upper, 0UL, 0UL );
3498 checkNonZeros( upper, 1UL, 0UL );
3499 checkNonZeros( upper, 2UL, 0UL );
3500 checkNonZeros( upper, 3UL, 0UL );
3501
3502 // Inserting a non-zero element
3503 {
3504 Iterator pos = upper.insert( 1UL, 2UL, 1 );
3505
3506 checkRows ( upper, 4UL );
3507 checkColumns ( upper, 4UL );
3508 checkCapacity( upper, 1UL );
3509 checkNonZeros( upper, 1UL );
3510 checkNonZeros( upper, 0UL, 0UL );
3511 checkNonZeros( upper, 1UL, 1UL );
3512 checkNonZeros( upper, 2UL, 0UL );
3513 checkNonZeros( upper, 3UL, 0UL );
3514
3515 if( pos->value() != 1 || pos->index() != 2UL ) {
3516 std::ostringstream oss;
3517 oss << " Test: " << test_ << "\n"
3518 << " Error: Invalid iterator returned\n"
3519 << " Details:\n"
3520 << " Value: " << pos->value() << "\n"
3521 << " Index: " << pos->index() << "\n"
3522 << " Expected value: 1\n"
3523 << " Expected index: 2\n";
3524 throw std::runtime_error( oss.str() );
3525 }
3526
3527 if( upper(1,2) != 1 ) {
3528 std::ostringstream oss;
3529 oss << " Test: " << test_ << "\n"
3530 << " Error: Inserting an element failed\n"
3531 << " Details:\n"
3532 << " Result:\n" << upper << "\n"
3533 << " Expected result:\n( 0 0 0 0 )\n( 0 0 1 0 )\n( 0 0 0 0 )\n( 0 0 0 0 )\n";
3534 throw std::runtime_error( oss.str() );
3535 }
3536 }
3537
3538 // Inserting a second non-zero element
3539 {
3540 Iterator pos = upper.insert( 1UL, 1UL, 2 );
3541
3542 checkRows ( upper, 4UL );
3543 checkColumns ( upper, 4UL );
3544 checkCapacity( upper, 2UL );
3545 checkNonZeros( upper, 2UL );
3546 checkNonZeros( upper, 0UL, 0UL );
3547 checkNonZeros( upper, 1UL, 2UL );
3548 checkNonZeros( upper, 2UL, 0UL );
3549 checkNonZeros( upper, 3UL, 0UL );
3550
3551 if( pos->value() != 2 || pos->index() != 1UL ) {
3552 std::ostringstream oss;
3553 oss << " Test: " << test_ << "\n"
3554 << " Error: Invalid iterator returned\n"
3555 << " Details:\n"
3556 << " Value: " << pos->value() << "\n"
3557 << " Index: " << pos->index() << "\n"
3558 << " Expected value: 2\n"
3559 << " Expected index: 1\n";
3560 throw std::runtime_error( oss.str() );
3561 }
3562
3563 if( upper(1,1) != 2 || upper(1,2) != 1 ) {
3564 std::ostringstream oss;
3565 oss << " Test: " << test_ << "\n"
3566 << " Error: Inserting an element failed\n"
3567 << " Details:\n"
3568 << " Result:\n" << upper << "\n"
3569 << " Expected result:\n( 0 0 0 0 )\n( 0 2 1 0 )\n( 0 0 0 0 )\n( 0 0 0 0 )\n";
3570 throw std::runtime_error( oss.str() );
3571 }
3572 }
3573
3574 // Inserting a third non-zero element
3575 {
3576 Iterator pos = upper.insert( 1UL, 3UL, 3 );
3577
3578 checkRows ( upper, 4UL );
3579 checkColumns ( upper, 4UL );
3580 checkCapacity( upper, 3UL );
3581 checkNonZeros( upper, 3UL );
3582 checkNonZeros( upper, 0UL, 0UL );
3583 checkNonZeros( upper, 1UL, 3UL );
3584 checkNonZeros( upper, 2UL, 0UL );
3585 checkNonZeros( upper, 3UL, 0UL );
3586
3587 if( pos->value() != 3 || pos->index() != 3UL ) {
3588 std::ostringstream oss;
3589 oss << " Test: " << test_ << "\n"
3590 << " Error: Invalid iterator returned\n"
3591 << " Details:\n"
3592 << " Value: " << pos->value() << "\n"
3593 << " Index: " << pos->index() << "\n"
3594 << " Expected value: 3\n"
3595 << " Expected index: 3\n";
3596 throw std::runtime_error( oss.str() );
3597 }
3598
3599 if( upper(1,1) != 2 || upper(1,2) != 1 || upper(1,3) != 3 ) {
3600 std::ostringstream oss;
3601 oss << " Test: " << test_ << "\n"
3602 << " Error: Inserting an element failed\n"
3603 << " Details:\n"
3604 << " Result:\n" << upper << "\n"
3605 << " Expected result:\n( 0 0 0 0 )\n( 0 2 1 3 )\n( 0 0 0 0 )\n( 0 0 0 0 )\n";
3606 throw std::runtime_error( oss.str() );
3607 }
3608 }
3609
3610 // Trying to insert an already existing element
3611 try {
3612 upper.insert( 2UL, 1UL, 4 );
3613
3614 std::ostringstream oss;
3615 oss << " Test: " << test_ << "\n"
3616 << " Error: Inserting an existing element succeeded\n"
3617 << " Details:\n"
3618 << " Result:\n" << upper << "\n"
3619 << " Expected result:\n( 0 0 0 0 )\n( 0 2 1 3 )\n( 0 0 0 0 )\n( 0 0 0 0 )\n";
3620 throw std::runtime_error( oss.str() );
3621 }
3622 catch( std::invalid_argument& ) {}
3623 }
3624
3625
3626 //=====================================================================================
3627 // Column-major matrix tests
3628 //=====================================================================================
3629
3630 {
3631 test_ = "Column-major UpperMatrix::insert()";
3632
3633 using Iterator = OUT::Iterator;
3634
3635 // Initialization check
3636 OUT upper( 4UL );
3637
3638 checkRows ( upper, 4UL );
3639 checkColumns ( upper, 4UL );
3640 checkNonZeros( upper, 0UL );
3641 checkNonZeros( upper, 0UL, 0UL );
3642 checkNonZeros( upper, 1UL, 0UL );
3643 checkNonZeros( upper, 2UL, 0UL );
3644 checkNonZeros( upper, 3UL, 0UL );
3645
3646 // Inserting a non-zero element
3647 {
3648 Iterator pos = upper.insert( 1UL, 2UL, 1 );
3649
3650 checkRows ( upper, 4UL );
3651 checkColumns ( upper, 4UL );
3652 checkCapacity( upper, 1UL );
3653 checkNonZeros( upper, 1UL );
3654 checkNonZeros( upper, 0UL, 0UL );
3655 checkNonZeros( upper, 1UL, 0UL );
3656 checkNonZeros( upper, 2UL, 1UL );
3657 checkNonZeros( upper, 3UL, 0UL );
3658
3659 if( pos->value() != 1 || pos->index() != 1UL ) {
3660 std::ostringstream oss;
3661 oss << " Test: " << test_ << "\n"
3662 << " Error: Invalid iterator returned\n"
3663 << " Details:\n"
3664 << " Value: " << pos->value() << "\n"
3665 << " Index: " << pos->index() << "\n"
3666 << " Expected value: 1\n"
3667 << " Expected index: 1\n";
3668 throw std::runtime_error( oss.str() );
3669 }
3670
3671 if( upper(1,2) != 1 ) {
3672 std::ostringstream oss;
3673 oss << " Test: " << test_ << "\n"
3674 << " Error: Inserting an element failed\n"
3675 << " Details:\n"
3676 << " Result:\n" << upper << "\n"
3677 << " Expected result:\n( 0 0 0 0 )\n( 0 0 1 0 )\n( 0 0 0 0 )\n( 0 0 0 0 )\n";
3678 throw std::runtime_error( oss.str() );
3679 }
3680 }
3681
3682 // Inserting a second non-zero element
3683 {
3684 Iterator pos = upper.insert( 2UL, 2UL, 2 );
3685
3686 checkRows ( upper, 4UL );
3687 checkColumns ( upper, 4UL );
3688 checkCapacity( upper, 2UL );
3689 checkNonZeros( upper, 2UL );
3690 checkNonZeros( upper, 0UL, 0UL );
3691 checkNonZeros( upper, 1UL, 0UL );
3692 checkNonZeros( upper, 2UL, 2UL );
3693 checkNonZeros( upper, 3UL, 0UL );
3694
3695 if( pos->value() != 2 || pos->index() != 2UL ) {
3696 std::ostringstream oss;
3697 oss << " Test: " << test_ << "\n"
3698 << " Error: Invalid iterator returned\n"
3699 << " Details:\n"
3700 << " Value: " << pos->value() << "\n"
3701 << " Index: " << pos->index() << "\n"
3702 << " Expected value: 2\n"
3703 << " Expected index: 2\n";
3704 throw std::runtime_error( oss.str() );
3705 }
3706
3707 if( upper(1,2) != 1 || upper(2,2) != 2 ) {
3708 std::ostringstream oss;
3709 oss << " Test: " << test_ << "\n"
3710 << " Error: Inserting an element failed\n"
3711 << " Details:\n"
3712 << " Result:\n" << upper << "\n"
3713 << " Expected result:\n( 0 0 0 0 )\n( 0 0 1 0 )\n( 0 0 2 0 )\n( 0 0 0 0 )\n";
3714 throw std::runtime_error( oss.str() );
3715 }
3716 }
3717
3718 // Inserting a third non-zero element
3719 {
3720 Iterator pos = upper.insert( 0UL, 2UL, 3 );
3721
3722 checkRows ( upper, 4UL );
3723 checkColumns ( upper, 4UL );
3724 checkCapacity( upper, 3UL );
3725 checkNonZeros( upper, 3UL );
3726 checkNonZeros( upper, 0UL, 0UL );
3727 checkNonZeros( upper, 1UL, 0UL );
3728 checkNonZeros( upper, 2UL, 3UL );
3729 checkNonZeros( upper, 3UL, 0UL );
3730
3731 if( pos->value() != 3 || pos->index() != 0UL ) {
3732 std::ostringstream oss;
3733 oss << " Test: " << test_ << "\n"
3734 << " Error: Invalid iterator returned\n"
3735 << " Details:\n"
3736 << " Value: " << pos->value() << "\n"
3737 << " Index: " << pos->index() << "\n"
3738 << " Expected value: 3\n"
3739 << " Expected index: 0\n";
3740 throw std::runtime_error( oss.str() );
3741 }
3742
3743 if( upper(0,2) != 3 || upper(1,2) != 1 || upper(2,2) != 2 ) {
3744 std::ostringstream oss;
3745 oss << " Test: " << test_ << "\n"
3746 << " Error: Inserting an element failed\n"
3747 << " Details:\n"
3748 << " Result:\n" << upper << "\n"
3749 << " Expected result:\n( 0 0 3 0 )\n( 0 0 1 0 )\n( 0 0 2 0 )\n( 0 0 0 0 )\n";
3750 throw std::runtime_error( oss.str() );
3751 }
3752 }
3753
3754 // Trying to insert an already existing element
3755 try {
3756 upper.insert( 1UL, 2UL, 4 );
3757
3758 std::ostringstream oss;
3759 oss << " Test: " << test_ << "\n"
3760 << " Error: Inserting an existing element succeeded\n"
3761 << " Details:\n"
3762 << " Result:\n" << upper << "\n"
3763 << " Expected result:\n( 0 0 3 0 )\n( 0 0 1 0 )\n( 0 0 2 0 )\n( 0 0 0 0 )\n";
3764 throw std::runtime_error( oss.str() );
3765 }
3766 catch( std::invalid_argument& ) {}
3767 }
3768 }
3769 //*************************************************************************************************
3770
3771
3772 //*************************************************************************************************
3773 /*!\brief Test of the \c append() member function of the UpperMatrix specialization.
3774 //
3775 // \return void
3776 // \exception std::runtime_error Error detected.
3777 //
3778 // This function performs a test of the \c append() member function of the UpperMatrix
3779 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
3780 */
testAppend()3781 void SparseTest::testAppend()
3782 {
3783 //=====================================================================================
3784 // Row-major matrix tests
3785 //=====================================================================================
3786
3787 {
3788 test_ = "Row-major UpperMatrix::append()";
3789
3790 // Appending with pre-allocation in each row
3791 {
3792 // Initialization check
3793 UT upper( 4UL, 5UL );
3794 upper.reserve( 0UL, 2UL );
3795 upper.reserve( 1UL, 1UL );
3796 upper.reserve( 2UL, 2UL );
3797
3798 checkRows ( upper, 4UL );
3799 checkColumns ( upper, 4UL );
3800 checkNonZeros( upper, 0UL );
3801 checkNonZeros( upper, 0UL, 0UL );
3802 checkNonZeros( upper, 1UL, 0UL );
3803 checkNonZeros( upper, 2UL, 0UL );
3804 checkNonZeros( upper, 3UL, 0UL );
3805
3806 // Appending one non-zero element
3807 upper.append( 1UL, 2UL, 1 );
3808
3809 checkRows ( upper, 4UL );
3810 checkColumns ( upper, 4UL );
3811 checkCapacity( upper, 1UL );
3812 checkNonZeros( upper, 1UL );
3813 checkNonZeros( upper, 0UL, 0UL );
3814 checkNonZeros( upper, 1UL, 1UL );
3815 checkNonZeros( upper, 2UL, 0UL );
3816 checkNonZeros( upper, 3UL, 0UL );
3817
3818 if( upper(1,2) != 1 ) {
3819 std::ostringstream oss;
3820 oss << " Test: " << test_ << "\n"
3821 << " Error: Appending operation failed\n"
3822 << " Details:\n"
3823 << " Result:\n" << upper << "\n"
3824 << " Expected result:\n( 0 0 0 0 )\n( 0 0 1 0 )\n( 0 0 0 0 )\n( 0 0 0 0 )\n";
3825 throw std::runtime_error( oss.str() );
3826 }
3827
3828 // Appending two more non-zero elements
3829 upper.append( 0UL, 0UL, 2 );
3830 upper.append( 2UL, 2UL, 3 );
3831
3832 checkRows ( upper, 4UL );
3833 checkColumns ( upper, 4UL );
3834 checkCapacity( upper, 3UL );
3835 checkNonZeros( upper, 3UL );
3836 checkNonZeros( upper, 0UL, 1UL );
3837 checkNonZeros( upper, 1UL, 1UL );
3838 checkNonZeros( upper, 2UL, 1UL );
3839 checkNonZeros( upper, 3UL, 0UL );
3840
3841 if( upper(0,0) != 2 || upper(1,2) != 1 || upper(2,2) != 3 ) {
3842 std::ostringstream oss;
3843 oss << " Test: " << test_ << "\n"
3844 << " Error: Append operation failed\n"
3845 << " Details:\n"
3846 << " Result:\n" << upper << "\n"
3847 << " Expected result:\n( 2 0 0 0 )\n( 0 0 1 0 )\n( 0 0 3 0 )\n( 0 0 0 0 )\n";
3848 throw std::runtime_error( oss.str() );
3849 }
3850
3851 // Appending two more non-zero elements
3852 upper.append( 0UL, 3UL, 4 );
3853 upper.append( 2UL, 3UL, 5 );
3854
3855 checkRows ( upper, 4UL );
3856 checkColumns ( upper, 4UL );
3857 checkCapacity( upper, 5UL );
3858 checkNonZeros( upper, 5UL );
3859 checkNonZeros( upper, 0UL, 2UL );
3860 checkNonZeros( upper, 1UL, 1UL );
3861 checkNonZeros( upper, 2UL, 2UL );
3862 checkNonZeros( upper, 3UL, 0UL );
3863
3864 if( upper(0,0) != 2 || upper(0,3) != 4 || upper(1,2) != 1 || upper(2,2) != 3 || upper(2,3) != 5 ) {
3865 std::ostringstream oss;
3866 oss << " Test: " << test_ << "\n"
3867 << " Error: Append operation failed\n"
3868 << " Details:\n"
3869 << " Result:\n" << upper << "\n"
3870 << " Expected result:\n( 2 0 0 4 )\n( 0 0 1 0 )\n( 0 0 3 5 )\n( 0 0 0 0 )\n";
3871 throw std::runtime_error( oss.str() );
3872 }
3873 }
3874
3875 // Appending with row finalization
3876 {
3877 // Initialization check
3878 UT upper( 4UL, 5UL );
3879 upper.reserve( 0UL, 1UL );
3880 upper.reserve( 1UL, 2UL );
3881 upper.reserve( 2UL, 2UL );
3882
3883 // Appending one non-zero element
3884 upper.append( 0UL, 0UL, 1 );
3885 upper.finalize( 0UL );
3886
3887 checkRows ( upper, 4UL );
3888 checkColumns ( upper, 4UL );
3889 checkCapacity( upper, 1UL );
3890 checkNonZeros( upper, 1UL );
3891 checkNonZeros( upper, 0UL, 1UL );
3892 checkNonZeros( upper, 1UL, 0UL );
3893 checkNonZeros( upper, 2UL, 0UL );
3894 checkNonZeros( upper, 3UL, 0UL );
3895
3896 if( upper(0,0) != 1 ) {
3897 std::ostringstream oss;
3898 oss << " Test: " << test_ << "\n"
3899 << " Error: Append operation failed\n"
3900 << " Details:\n"
3901 << " Result:\n" << upper << "\n"
3902 << " Expected result:\n( 1 0 0 0 )\n( 0 0 0 0 )\n( 0 0 0 0 )\n( 0 0 0 0 )\n";
3903 throw std::runtime_error( oss.str() );
3904 }
3905
3906 // Appending two more non-zero elements
3907 upper.append( 1UL, 1UL, 2 );
3908 upper.append( 1UL, 3UL, 3 );
3909 upper.finalize( 1UL );
3910
3911 checkRows ( upper, 4UL );
3912 checkColumns ( upper, 4UL );
3913 checkCapacity( upper, 3UL );
3914 checkNonZeros( upper, 3UL );
3915 checkNonZeros( upper, 0UL, 1UL );
3916 checkNonZeros( upper, 1UL, 2UL );
3917 checkNonZeros( upper, 2UL, 0UL );
3918 checkNonZeros( upper, 3UL, 0UL );
3919
3920 if( upper(0,0) != 1 || upper(1,1) != 2 || upper(1,3) != 3 ) {
3921 std::ostringstream oss;
3922 oss << " Test: " << test_ << "\n"
3923 << " Error: Append operation failed\n"
3924 << " Details:\n"
3925 << " Result:\n" << upper << "\n"
3926 << " Expected result:\n( 1 0 0 0 )\n( 0 2 0 3 )\n( 0 0 0 0 )\n( 0 0 0 0 )\n";
3927 throw std::runtime_error( oss.str() );
3928 }
3929
3930 // Appending two more non-zero elements
3931 upper.append( 2UL, 2UL, 4 );
3932 upper.append( 2UL, 3UL, 5 );
3933 upper.finalize( 2UL );
3934
3935 checkRows ( upper, 4UL );
3936 checkColumns ( upper, 4UL );
3937 checkCapacity( upper, 5UL );
3938 checkNonZeros( upper, 5UL );
3939 checkNonZeros( upper, 0UL, 1UL );
3940 checkNonZeros( upper, 1UL, 2UL );
3941 checkNonZeros( upper, 2UL, 2UL );
3942 checkNonZeros( upper, 3UL, 0UL );
3943
3944 if( upper(0,0) != 1 || upper(1,1) != 2 || upper(1,3) != 3 || upper(2,2) != 4 || upper(2,3) != 5 ) {
3945 std::ostringstream oss;
3946 oss << " Test: " << test_ << "\n"
3947 << " Error: Append operation failed\n"
3948 << " Details:\n"
3949 << " Result:\n" << upper << "\n"
3950 << " Expected result:\n( 1 0 0 0 )\n( 0 2 0 3 )\n( 0 0 4 5 )\n( 0 0 0 0 )\n";
3951 throw std::runtime_error( oss.str() );
3952 }
3953 }
3954 }
3955
3956
3957 //=====================================================================================
3958 // Column-major matrix tests
3959 //=====================================================================================
3960
3961 {
3962 test_ = "Column-major UpperMatrix::append()";
3963
3964 // Appending with pre-allocation in each column
3965 {
3966 // Initialization check
3967 OUT upper( 4UL, 5UL );
3968 upper.reserve( 0UL, 1UL );
3969 upper.reserve( 2UL, 2UL );
3970 upper.reserve( 3UL, 2UL );
3971
3972 checkRows ( upper, 4UL );
3973 checkColumns ( upper, 4UL );
3974 checkNonZeros( upper, 0UL );
3975 checkNonZeros( upper, 0UL, 0UL );
3976 checkNonZeros( upper, 1UL, 0UL );
3977 checkNonZeros( upper, 2UL, 0UL );
3978 checkNonZeros( upper, 3UL, 0UL );
3979
3980 // Appending one non-zero element
3981 upper.append( 1UL, 2UL, 1 );
3982
3983 checkRows ( upper, 4UL );
3984 checkColumns ( upper, 4UL );
3985 checkCapacity( upper, 1UL );
3986 checkNonZeros( upper, 1UL );
3987 checkNonZeros( upper, 0UL, 0UL );
3988 checkNonZeros( upper, 1UL, 0UL );
3989 checkNonZeros( upper, 2UL, 1UL );
3990 checkNonZeros( upper, 3UL, 0UL );
3991
3992 if( upper(1,2) != 1 ) {
3993 std::ostringstream oss;
3994 oss << " Test: " << test_ << "\n"
3995 << " Error: Append operation failed\n"
3996 << " Details:\n"
3997 << " Result:\n" << upper << "\n"
3998 << " Expected result:\n( 0 0 0 0 )\n( 0 0 1 0 )\n( 0 0 0 0 )\n( 0 0 0 0 )\n";
3999 throw std::runtime_error( oss.str() );
4000 }
4001
4002 // Appending two more non-zero elements
4003 upper.append( 0UL, 0UL, 2 );
4004 upper.append( 0UL, 3UL, 3 );
4005
4006 checkRows ( upper, 4UL );
4007 checkColumns ( upper, 4UL );
4008 checkCapacity( upper, 3UL );
4009 checkNonZeros( upper, 3UL );
4010 checkNonZeros( upper, 0UL, 1UL );
4011 checkNonZeros( upper, 1UL, 0UL );
4012 checkNonZeros( upper, 2UL, 1UL );
4013 checkNonZeros( upper, 3UL, 1UL );
4014
4015 if( upper(0,0) != 2 || upper(0,3) != 3 || upper(1,2) != 1 ) {
4016 std::ostringstream oss;
4017 oss << " Test: " << test_ << "\n"
4018 << " Error: Append operation failed\n"
4019 << " Details:\n"
4020 << " Result:\n" << upper << "\n"
4021 << " Expected result:\n( 2 0 0 3 )\n( 0 0 1 0 )\n( 0 0 0 0 )\n( 0 0 0 0 )\n";
4022 throw std::runtime_error( oss.str() );
4023 }
4024
4025 // Appending two more non-zero elements
4026 upper.append( 2UL, 2UL, 4 );
4027 upper.append( 2UL, 3UL, 5 );
4028
4029 checkRows ( upper, 4UL );
4030 checkColumns ( upper, 4UL );
4031 checkCapacity( upper, 5UL );
4032 checkNonZeros( upper, 5UL );
4033 checkNonZeros( upper, 0UL, 1UL );
4034 checkNonZeros( upper, 1UL, 0UL );
4035 checkNonZeros( upper, 2UL, 2UL );
4036 checkNonZeros( upper, 3UL, 2UL );
4037
4038 if( upper(0,0) != 2 || upper(0,3) != 3 || upper(1,2) != 1 || upper(2,2) != 4 || upper(2,3) != 5 ) {
4039 std::ostringstream oss;
4040 oss << " Test: " << test_ << "\n"
4041 << " Error: Append operation failed\n"
4042 << " Details:\n"
4043 << " Result:\n" << upper << "\n"
4044 << " Expected result:\n( 2 0 0 3 )\n( 0 0 1 0 )\n( 0 0 4 5 )\n( 0 0 0 0 )\n";
4045 throw std::runtime_error( oss.str() );
4046 }
4047 }
4048
4049 // Appending with column finalization
4050 {
4051 // Initialization check
4052 OUT upper( 4UL, 5UL );
4053 upper.reserve( 0UL, 1UL );
4054 upper.reserve( 2UL, 2UL );
4055 upper.reserve( 3UL, 2UL );
4056
4057 // Appending one non-zero element
4058 upper.append( 0UL, 0UL, 1 );
4059 upper.finalize( 0UL );
4060
4061 checkRows ( upper, 4UL );
4062 checkColumns ( upper, 4UL );
4063 checkCapacity( upper, 1UL );
4064 checkNonZeros( upper, 1UL );
4065 checkNonZeros( upper, 0UL, 1UL );
4066 checkNonZeros( upper, 1UL, 0UL );
4067 checkNonZeros( upper, 2UL, 0UL );
4068 checkNonZeros( upper, 3UL, 0UL );
4069
4070 if( upper(0,0) != 1 ) {
4071 std::ostringstream oss;
4072 oss << " Test: " << test_ << "\n"
4073 << " Error: Append operation failed\n"
4074 << " Details:\n"
4075 << " Result:\n" << upper << "\n"
4076 << " Expected result:\n( 1 0 0 0 )\n( 0 0 0 0 )\n( 0 0 0 0 )\n( 0 0 0 0 )\n";
4077 throw std::runtime_error( oss.str() );
4078 }
4079
4080 // Appending two more non-zero elements
4081 upper.append( 0UL, 2UL, 2 );
4082 upper.append( 1UL, 2UL, 3 );
4083 upper.finalize( 2UL );
4084
4085 checkRows ( upper, 4UL );
4086 checkColumns ( upper, 4UL );
4087 checkCapacity( upper, 3UL );
4088 checkNonZeros( upper, 3UL );
4089 checkNonZeros( upper, 0UL, 1UL );
4090 checkNonZeros( upper, 1UL, 0UL );
4091 checkNonZeros( upper, 2UL, 2UL );
4092 checkNonZeros( upper, 3UL, 0UL );
4093
4094 if( upper(0,0) != 1 || upper(0,2) != 2 || upper(1,2) != 3 ) {
4095 std::ostringstream oss;
4096 oss << " Test: " << test_ << "\n"
4097 << " Error: Append operation failed\n"
4098 << " Details:\n"
4099 << " Result:\n" << upper << "\n"
4100 << " Expected result:\n( 1 0 2 0 )\n( 0 0 3 0 )\n( 0 0 0 0 )\n( 0 0 0 0 )\n";
4101 throw std::runtime_error( oss.str() );
4102 }
4103
4104 // Appending two more non-zero elements
4105 upper.append( 0UL, 3UL, 4 );
4106 upper.append( 2UL, 3UL, 5 );
4107 upper.finalize( 3UL );
4108
4109 checkRows ( upper, 4UL );
4110 checkColumns ( upper, 4UL );
4111 checkCapacity( upper, 5UL );
4112 checkNonZeros( upper, 5UL );
4113 checkNonZeros( upper, 0UL, 1UL );
4114 checkNonZeros( upper, 1UL, 0UL );
4115 checkNonZeros( upper, 2UL, 2UL );
4116 checkNonZeros( upper, 3UL, 2UL );
4117
4118 if( upper(0,0) != 1 || upper(0,2) != 2 || upper(0,3) != 4 || upper(1,2) != 3 || upper(2,3) != 5 ) {
4119 std::ostringstream oss;
4120 oss << " Test: " << test_ << "\n"
4121 << " Error: Append operation failed\n"
4122 << " Details:\n"
4123 << " Result:\n" << upper << "\n"
4124 << " Expected result:\n( 1 0 2 4 )\n( 0 0 3 0 )\n( 0 0 0 5 )\n( 0 0 0 0 )\n";
4125 throw std::runtime_error( oss.str() );
4126 }
4127 }
4128 }
4129 }
4130 //*************************************************************************************************
4131
4132
4133 //*************************************************************************************************
4134 /*!\brief Test of the \c erase() member function of the UpperMatrix specialization.
4135 //
4136 // \return void
4137 // \exception std::runtime_error Error detected.
4138 //
4139 // This function performs a test of the \c erase() member function of the UpperMatrix
4140 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
4141 */
testErase()4142 void SparseTest::testErase()
4143 {
4144 //=====================================================================================
4145 // Row-major index-based erase function
4146 //=====================================================================================
4147
4148 {
4149 test_ = "Row-major UpperMatrix::erase( size_t, size_t )";
4150
4151 // Initialization check
4152 UT upper( 4UL, 8UL );
4153 upper(0,0) = 1;
4154 upper(0,2) = 2;
4155 upper(0,3) = 3;
4156 upper(1,2) = 4;
4157 upper(1,3) = 5;
4158 upper(2,2) = 6;
4159 upper(2,3) = 7;
4160 upper(3,3) = 8;
4161
4162 checkRows ( upper, 4UL );
4163 checkColumns ( upper, 4UL );
4164 checkCapacity( upper, 8UL );
4165 checkNonZeros( upper, 8UL );
4166 checkNonZeros( upper, 0UL, 3UL );
4167 checkNonZeros( upper, 1UL, 2UL );
4168 checkNonZeros( upper, 2UL, 2UL );
4169 checkNonZeros( upper, 3UL, 1UL );
4170
4171 if( upper(0,0) != 1 || upper(0,2) != 2 || upper(0,3) != 3 ||
4172 upper(1,2) != 4 || upper(1,3) != 5 ||
4173 upper(2,2) != 6 || upper(2,3) != 7 ||
4174 upper(3,3) != 8 ) {
4175 std::ostringstream oss;
4176 oss << " Test: " << test_ << "\n"
4177 << " Error: Initialization failed\n"
4178 << " Details:\n"
4179 << " Result:\n" << upper << "\n"
4180 << " Expected result:\n( 1 0 2 3 )\n( 0 0 4 5 )\n( 0 0 6 7 )\n( 0 0 0 8 )\n";
4181 throw std::runtime_error( oss.str() );
4182 }
4183
4184 // Erasing the element at (1,2)
4185 upper.erase( 1UL, 2UL );
4186
4187 checkRows ( upper, 4UL );
4188 checkColumns ( upper, 4UL );
4189 checkCapacity( upper, 8UL );
4190 checkNonZeros( upper, 7UL );
4191 checkNonZeros( upper, 0UL, 3UL );
4192 checkNonZeros( upper, 1UL, 1UL );
4193 checkNonZeros( upper, 2UL, 2UL );
4194 checkNonZeros( upper, 3UL, 1UL );
4195
4196 if( upper(0,0) != 1 || upper(0,2) != 2 || upper(0,3) != 3 ||
4197 upper(1,3) != 5 ||
4198 upper(2,2) != 6 || upper(2,3) != 7 ||
4199 upper(3,3) != 8 ) {
4200 std::ostringstream oss;
4201 oss << " Test: " << test_ << "\n"
4202 << " Error: Erasing a non-zero element failed\n"
4203 << " Details:\n"
4204 << " Result:\n" << upper << "\n"
4205 << " Expected result:\n( 1 0 2 3 )\n( 0 0 0 5 )\n( 0 0 6 7 )\n( 0 0 0 8 )\n";
4206 throw std::runtime_error( oss.str() );
4207 }
4208
4209 // Erasing the element at (2,3)
4210 upper.erase( 2UL, 3UL );
4211
4212 checkRows ( upper, 4UL );
4213 checkColumns ( upper, 4UL );
4214 checkCapacity( upper, 8UL );
4215 checkNonZeros( upper, 6UL );
4216 checkNonZeros( upper, 0UL, 3UL );
4217 checkNonZeros( upper, 1UL, 1UL );
4218 checkNonZeros( upper, 2UL, 1UL );
4219 checkNonZeros( upper, 3UL, 1UL );
4220
4221 if( upper(0,0) != 1 || upper(0,2) != 2 || upper(0,3) != 3 ||
4222 upper(1,3) != 5 ||
4223 upper(2,2) != 6 ||
4224 upper(3,3) != 8 ) {
4225 std::ostringstream oss;
4226 oss << " Test: " << test_ << "\n"
4227 << " Error: Erasing a non-zero element failed\n"
4228 << " Details:\n"
4229 << " Result:\n" << upper << "\n"
4230 << " Expected result:\n( 1 0 2 3 )\n( 0 0 0 5 )\n( 0 0 6 0 )\n( 0 0 0 8 )\n";
4231 throw std::runtime_error( oss.str() );
4232 }
4233
4234 // Erasing the element at (0,2)
4235 upper.erase( 0UL, 2UL );
4236
4237 checkRows ( upper, 4UL );
4238 checkColumns ( upper, 4UL );
4239 checkCapacity( upper, 8UL );
4240 checkNonZeros( upper, 5UL );
4241 checkNonZeros( upper, 0UL, 2UL );
4242 checkNonZeros( upper, 1UL, 1UL );
4243 checkNonZeros( upper, 2UL, 1UL );
4244 checkNonZeros( upper, 3UL, 1UL );
4245
4246 if( upper(0,0) != 1 || upper(0,3) != 3 ||
4247 upper(1,3) != 5 ||
4248 upper(2,2) != 6 ||
4249 upper(3,3) != 8 ) {
4250 std::ostringstream oss;
4251 oss << " Test: " << test_ << "\n"
4252 << " Error: Erasing a non-zero element failed\n"
4253 << " Details:\n"
4254 << " Result:\n" << upper << "\n"
4255 << " Expected result:\n( 1 0 0 3 )\n( 0 0 0 5 )\n( 0 0 6 0 )\n( 0 0 0 8 )\n";
4256 throw std::runtime_error( oss.str() );
4257 }
4258
4259 // Trying to erase a zero element
4260 upper.erase( 0UL, 1UL );
4261
4262 checkRows ( upper, 4UL );
4263 checkColumns ( upper, 4UL );
4264 checkCapacity( upper, 8UL );
4265 checkNonZeros( upper, 5UL );
4266 checkNonZeros( upper, 0UL, 2UL );
4267 checkNonZeros( upper, 1UL, 1UL );
4268 checkNonZeros( upper, 2UL, 1UL );
4269 checkNonZeros( upper, 3UL, 1UL );
4270
4271 if( upper(0,0) != 1 || upper(0,3) != 3 ||
4272 upper(1,3) != 5 ||
4273 upper(2,2) != 6 ||
4274 upper(3,3) != 8 ) {
4275 std::ostringstream oss;
4276 oss << " Test: " << test_ << "\n"
4277 << " Error: Erasing a zero element failed\n"
4278 << " Details:\n"
4279 << " Result:\n" << upper << "\n"
4280 << " Expected result:\n( 1 0 0 3 )\n( 0 0 0 5 )\n( 0 0 6 0 )\n( 0 0 0 8 )\n";
4281 throw std::runtime_error( oss.str() );
4282 }
4283 }
4284
4285
4286 //=====================================================================================
4287 // Row-major iterator-based erase function
4288 //=====================================================================================
4289
4290 {
4291 test_ = "Row-major UpperMatrix::erase( size_t, Iterator )";
4292
4293 using Iterator = UT::Iterator;
4294
4295 // Initialization check
4296 UT upper( 4UL, 8UL );
4297 upper(0,0) = 1;
4298 upper(0,2) = 2;
4299 upper(0,3) = 3;
4300 upper(1,2) = 4;
4301 upper(1,3) = 5;
4302 upper(2,2) = 6;
4303 upper(2,3) = 7;
4304 upper(3,3) = 8;
4305
4306 checkRows ( upper, 4UL );
4307 checkColumns ( upper, 4UL );
4308 checkCapacity( upper, 8UL );
4309 checkNonZeros( upper, 8UL );
4310 checkNonZeros( upper, 0UL, 3UL );
4311 checkNonZeros( upper, 1UL, 2UL );
4312 checkNonZeros( upper, 2UL, 2UL );
4313 checkNonZeros( upper, 3UL, 1UL );
4314
4315 if( upper(0,0) != 1 || upper(0,2) != 2 || upper(0,3) != 3 ||
4316 upper(1,2) != 4 || upper(1,3) != 5 ||
4317 upper(2,2) != 6 || upper(2,3) != 7 ||
4318 upper(3,3) != 8 ) {
4319 std::ostringstream oss;
4320 oss << " Test: " << test_ << "\n"
4321 << " Error: Initialization failed\n"
4322 << " Details:\n"
4323 << " Result:\n" << upper << "\n"
4324 << " Expected result:\n( 1 0 2 3 )\n( 0 0 4 5 )\n( 0 0 6 7 )\n( 0 0 0 8 )\n";
4325 throw std::runtime_error( oss.str() );
4326 }
4327
4328 // Erasing the element at (1,2)
4329 {
4330 Iterator pos = upper.erase( 1UL, upper.find( 1UL, 2UL ) );
4331
4332 checkRows ( upper, 4UL );
4333 checkColumns ( upper, 4UL );
4334 checkCapacity( upper, 8UL );
4335 checkNonZeros( upper, 7UL );
4336 checkNonZeros( upper, 0UL, 3UL );
4337 checkNonZeros( upper, 1UL, 1UL );
4338 checkNonZeros( upper, 2UL, 2UL );
4339 checkNonZeros( upper, 3UL, 1UL );
4340
4341 if( upper(0,0) != 1 || upper(0,2) != 2 || upper(0,3) != 3 ||
4342 upper(1,3) != 5 ||
4343 upper(2,2) != 6 || upper(2,3) != 7 ||
4344 upper(3,3) != 8 ) {
4345 std::ostringstream oss;
4346 oss << " Test: " << test_ << "\n"
4347 << " Error: Erasing a non-zero element failed\n"
4348 << " Details:\n"
4349 << " Result:\n" << upper << "\n"
4350 << " Expected result:\n( 1 0 2 3 )\n( 0 0 0 5 )\n( 0 0 6 7 )\n( 0 0 0 8 )\n";
4351 throw std::runtime_error( oss.str() );
4352 }
4353
4354 if( pos->value() != 5 || pos->index() != 3 ) {
4355 std::ostringstream oss;
4356 oss << " Test: " << test_ << "\n"
4357 << " Error: Invalid iterator returned\n"
4358 << " Details:\n"
4359 << " Value: " << pos->value() << "\n"
4360 << " Index: " << pos->index() << "\n"
4361 << " Expected value: 5\n"
4362 << " Expected index: 3\n";
4363 throw std::runtime_error( oss.str() );
4364 }
4365 }
4366
4367 // Erasing the element at (2,3)
4368 {
4369 Iterator pos = upper.erase( 2UL, upper.find( 2UL, 3UL ) );
4370
4371 checkRows ( upper, 4UL );
4372 checkColumns ( upper, 4UL );
4373 checkCapacity( upper, 8UL );
4374 checkNonZeros( upper, 6UL );
4375 checkNonZeros( upper, 0UL, 3UL );
4376 checkNonZeros( upper, 1UL, 1UL );
4377 checkNonZeros( upper, 2UL, 1UL );
4378 checkNonZeros( upper, 3UL, 1UL );
4379
4380 if( upper(0,0) != 1 || upper(0,2) != 2 || upper(0,3) != 3 ||
4381 upper(1,3) != 5 ||
4382 upper(2,2) != 6 ||
4383 upper(3,3) != 8 ) {
4384 std::ostringstream oss;
4385 oss << " Test: " << test_ << "\n"
4386 << " Error: Erasing a non-zero element failed\n"
4387 << " Details:\n"
4388 << " Result:\n" << upper << "\n"
4389 << " Expected result:\n( 1 0 2 3 )\n( 0 0 0 5 )\n( 0 0 6 0 )\n( 0 0 0 8 )\n";
4390 throw std::runtime_error( oss.str() );
4391 }
4392
4393 if( pos != upper.end( 2UL ) ) {
4394 std::ostringstream oss;
4395 oss << " Test: " << test_ << "\n"
4396 << " Error: Invalid iterator returned\n"
4397 << " Details:\n"
4398 << " Expected result: the end() iterator\n";
4399 throw std::runtime_error( oss.str() );
4400 }
4401 }
4402
4403 // Erasing the element at (0,2)
4404 {
4405 Iterator pos = upper.erase( 0UL, upper.find( 0UL, 2UL ) );
4406
4407 checkRows ( upper, 4UL );
4408 checkColumns ( upper, 4UL );
4409 checkCapacity( upper, 8UL );
4410 checkNonZeros( upper, 5UL );
4411 checkNonZeros( upper, 0UL, 2UL );
4412 checkNonZeros( upper, 1UL, 1UL );
4413 checkNonZeros( upper, 2UL, 1UL );
4414 checkNonZeros( upper, 3UL, 1UL );
4415
4416 if( upper(0,0) != 1 || upper(0,3) != 3 ||
4417 upper(1,3) != 5 ||
4418 upper(2,2) != 6 ||
4419 upper(3,3) != 8 ) {
4420 std::ostringstream oss;
4421 oss << " Test: " << test_ << "\n"
4422 << " Error: Erasing a non-zero element failed\n"
4423 << " Details:\n"
4424 << " Result:\n" << upper << "\n"
4425 << " Expected result:\n( 1 0 0 3 )\n( 0 0 0 5 )\n( 0 0 6 0 )\n( 0 0 0 8 )\n";
4426 throw std::runtime_error( oss.str() );
4427 }
4428
4429 if( pos->value() != 3 || pos->index() != 3 ) {
4430 std::ostringstream oss;
4431 oss << " Test: " << test_ << "\n"
4432 << " Error: Invalid iterator returned\n"
4433 << " Details:\n"
4434 << " Value: " << pos->value() << "\n"
4435 << " Index: " << pos->index() << "\n"
4436 << " Expected value: 3\n"
4437 << " Expected index: 3\n";
4438 throw std::runtime_error( oss.str() );
4439 }
4440 }
4441
4442 // Trying to erase a zero element
4443 {
4444 Iterator pos = upper.erase( 0UL, upper.find( 0UL, 1UL ) );
4445
4446 checkRows ( upper, 4UL );
4447 checkColumns ( upper, 4UL );
4448 checkCapacity( upper, 8UL );
4449 checkNonZeros( upper, 5UL );
4450 checkNonZeros( upper, 0UL, 2UL );
4451 checkNonZeros( upper, 1UL, 1UL );
4452 checkNonZeros( upper, 2UL, 1UL );
4453 checkNonZeros( upper, 3UL, 1UL );
4454
4455 if( upper(0,0) != 1 || upper(0,3) != 3 ||
4456 upper(1,3) != 5 ||
4457 upper(2,2) != 6 ||
4458 upper(3,3) != 8 ) {
4459 std::ostringstream oss;
4460 oss << " Test: " << test_ << "\n"
4461 << " Error: Erasing a zero element failed\n"
4462 << " Details:\n"
4463 << " Result:\n" << upper << "\n"
4464 << " Expected result:\n( 1 0 0 3 )\n( 0 0 0 5 )\n( 0 0 6 0 )\n( 0 0 0 8 )\n";
4465 throw std::runtime_error( oss.str() );
4466 }
4467
4468 if( pos != upper.end( 0UL ) ) {
4469 std::ostringstream oss;
4470 oss << " Test: " << test_ << "\n"
4471 << " Error: Invalid iterator returned\n"
4472 << " Details:\n"
4473 << " Expected result: the end() iterator\n";
4474 throw std::runtime_error( oss.str() );
4475 }
4476 }
4477 }
4478
4479
4480 //=====================================================================================
4481 // Row-major iterator-range-based erase function
4482 //=====================================================================================
4483
4484 {
4485 test_ = "Row-major UpperMatrix::erase( size_t, Iterator, Iterator )";
4486
4487 using Iterator = UT::Iterator;
4488
4489 // Initialization check
4490 UT upper( 4UL, 8UL );
4491 upper(0,0) = 1;
4492 upper(0,2) = 2;
4493 upper(0,3) = 3;
4494 upper(1,2) = 4;
4495 upper(1,3) = 5;
4496 upper(2,2) = 6;
4497 upper(2,3) = 7;
4498 upper(3,3) = 8;
4499
4500 checkRows ( upper, 4UL );
4501 checkColumns ( upper, 4UL );
4502 checkCapacity( upper, 8UL );
4503 checkNonZeros( upper, 8UL );
4504 checkNonZeros( upper, 0UL, 3UL );
4505 checkNonZeros( upper, 1UL, 2UL );
4506 checkNonZeros( upper, 2UL, 2UL );
4507 checkNonZeros( upper, 3UL, 1UL );
4508
4509 if( upper(0,0) != 1 || upper(0,2) != 2 || upper(0,3) != 3 ||
4510 upper(1,2) != 4 || upper(1,3) != 5 ||
4511 upper(2,2) != 6 || upper(2,3) != 7 ||
4512 upper(3,3) != 8 ) {
4513 std::ostringstream oss;
4514 oss << " Test: " << test_ << "\n"
4515 << " Error: Initialization failed\n"
4516 << " Details:\n"
4517 << " Result:\n" << upper << "\n"
4518 << " Expected result:\n( 1 0 2 3 )\n( 0 0 4 5 )\n( 0 0 6 7 )\n( 0 0 0 8 )\n";
4519 throw std::runtime_error( oss.str() );
4520 }
4521
4522 // Erasing the elements from the beginning of row 1 to (1,3)
4523 {
4524 Iterator pos = upper.erase( 1UL, upper.begin( 1UL ), upper.find( 1UL, 3UL ) );
4525
4526 checkRows ( upper, 4UL );
4527 checkColumns ( upper, 4UL );
4528 checkCapacity( upper, 8UL );
4529 checkNonZeros( upper, 7UL );
4530 checkNonZeros( upper, 0UL, 3UL );
4531 checkNonZeros( upper, 1UL, 1UL );
4532 checkNonZeros( upper, 2UL, 2UL );
4533 checkNonZeros( upper, 3UL, 1UL );
4534
4535 if( upper(0,0) != 1 || upper(0,2) != 2 || upper(0,3) != 3 ||
4536 upper(1,3) != 5 ||
4537 upper(2,2) != 6 || upper(2,3) != 7 ||
4538 upper(3,3) != 8 ) {
4539 std::ostringstream oss;
4540 oss << " Test: " << test_ << "\n"
4541 << " Error: Erasing a single-element range failed\n"
4542 << " Details:\n"
4543 << " Result:\n" << upper << "\n"
4544 << " Expected result:\n( 1 0 2 3 )\n( 0 0 0 5 )\n( 0 0 6 7 )\n( 0 0 0 8 )\n";
4545 throw std::runtime_error( oss.str() );
4546 }
4547
4548 if( pos->value() != 5 || pos->index() != 3 ) {
4549 std::ostringstream oss;
4550 oss << " Test: " << test_ << "\n"
4551 << " Error: Invalid iterator returned\n"
4552 << " Details:\n"
4553 << " Value: " << pos->value() << "\n"
4554 << " Index: " << pos->index() << "\n"
4555 << " Expected value: 5\n"
4556 << " Expected index: 3\n";
4557 throw std::runtime_error( oss.str() );
4558 }
4559 }
4560
4561 // Erasing the elements from (2,3) to the row end
4562 {
4563 Iterator pos = upper.erase( 2UL, upper.find( 2UL, 3UL ), upper.end( 2UL ) );
4564
4565 checkRows ( upper, 4UL );
4566 checkColumns ( upper, 4UL );
4567 checkCapacity( upper, 8UL );
4568 checkNonZeros( upper, 6UL );
4569 checkNonZeros( upper, 0UL, 3UL );
4570 checkNonZeros( upper, 1UL, 1UL );
4571 checkNonZeros( upper, 2UL, 1UL );
4572 checkNonZeros( upper, 3UL, 1UL );
4573
4574 if( upper(0,0) != 1 || upper(0,2) != 2 || upper(0,3) != 3 ||
4575 upper(1,3) != 5 ||
4576 upper(2,2) != 6 ||
4577 upper(3,3) != 8 ) {
4578 std::ostringstream oss;
4579 oss << " Test: " << test_ << "\n"
4580 << " Error: Erasing a single-element range failed\n"
4581 << " Details:\n"
4582 << " Result:\n" << upper << "\n"
4583 << " Expected result:\n( 1 0 2 3 )\n( 0 0 0 5 )\n( 0 0 6 0 )\n( 0 0 0 8 )\n";
4584 throw std::runtime_error( oss.str() );
4585 }
4586
4587 if( pos != upper.end( 2UL ) ) {
4588 std::ostringstream oss;
4589 oss << " Test: " << test_ << "\n"
4590 << " Error: Invalid iterator returned\n"
4591 << " Details:\n"
4592 << " Expected result: the end() iterator\n";
4593 throw std::runtime_error( oss.str() );
4594 }
4595 }
4596
4597 // Erasing the elements from (0,0) to (0,3)
4598 {
4599 Iterator pos = upper.erase( 0UL, upper.find( 0UL, 0UL ), upper.find( 0UL, 3UL ) );
4600
4601 checkRows ( upper, 4UL );
4602 checkColumns ( upper, 4UL );
4603 checkCapacity( upper, 8UL );
4604 checkNonZeros( upper, 4UL );
4605 checkNonZeros( upper, 0UL, 1UL );
4606 checkNonZeros( upper, 1UL, 1UL );
4607 checkNonZeros( upper, 2UL, 1UL );
4608 checkNonZeros( upper, 3UL, 1UL );
4609
4610 if( upper(0,3) != 3 ||
4611 upper(1,3) != 5 ||
4612 upper(2,2) != 6 ||
4613 upper(3,3) != 8 ) {
4614 std::ostringstream oss;
4615 oss << " Test: " << test_ << "\n"
4616 << " Error: Erasing a multi-element range failed\n"
4617 << " Details:\n"
4618 << " Result:\n" << upper << "\n"
4619 << " Expected result:\n( 0 0 0 3 )\n( 0 0 0 5 )\n( 0 0 6 0 )\n( 0 0 0 8 )\n";
4620 throw std::runtime_error( oss.str() );
4621 }
4622
4623 if( pos->value() != 3 || pos->index() != 3 ) {
4624 std::ostringstream oss;
4625 oss << " Test: " << test_ << "\n"
4626 << " Error: Invalid iterator returned\n"
4627 << " Details:\n"
4628 << " Value: " << pos->value() << "\n"
4629 << " Index: " << pos->index() << "\n"
4630 << " Expected value: 3\n"
4631 << " Expected index: 3\n";
4632 throw std::runtime_error( oss.str() );
4633 }
4634 }
4635
4636 // Trying to erase an empty range
4637 {
4638 Iterator pos = upper.erase( 0UL, upper.find( 0UL, 3UL ), upper.find( 0UL, 3UL ) );
4639
4640 checkRows ( upper, 4UL );
4641 checkColumns ( upper, 4UL );
4642 checkCapacity( upper, 8UL );
4643 checkNonZeros( upper, 4UL );
4644 checkNonZeros( upper, 0UL, 1UL );
4645 checkNonZeros( upper, 1UL, 1UL );
4646 checkNonZeros( upper, 2UL, 1UL );
4647 checkNonZeros( upper, 3UL, 1UL );
4648
4649 if( upper(0,3) != 3 ||
4650 upper(1,3) != 5 ||
4651 upper(2,2) != 6 ||
4652 upper(3,3) != 8 ) {
4653 std::ostringstream oss;
4654 oss << " Test: " << test_ << "\n"
4655 << " Error: Erasing an empty range failed\n"
4656 << " Details:\n"
4657 << " Result:\n" << upper << "\n"
4658 << " Expected result:\n( 0 0 0 3 )\n( 0 0 0 5 )\n( 0 0 6 0 )\n( 0 0 0 8 )\n";
4659 throw std::runtime_error( oss.str() );
4660 }
4661
4662 if( pos->value() != 3 || pos->index() != 3 ) {
4663 std::ostringstream oss;
4664 oss << " Test: " << test_ << "\n"
4665 << " Error: Invalid iterator returned\n"
4666 << " Details:\n"
4667 << " Value: " << pos->value() << "\n"
4668 << " Index: " << pos->index() << "\n"
4669 << " Expected value: 3\n"
4670 << " Expected index: 3\n";
4671 throw std::runtime_error( oss.str() );
4672 }
4673 }
4674 }
4675
4676
4677 //=====================================================================================
4678 // Row-major erase function with predicate
4679 //=====================================================================================
4680
4681 {
4682 test_ = "Row-major UpperMatrix::erase( Predicate )";
4683
4684 // Initialization check
4685 UT upper( 4UL, 8UL );
4686 upper(0,0) = 1;
4687 upper(0,2) = 2;
4688 upper(0,3) = 3;
4689 upper(1,2) = 4;
4690 upper(1,3) = 5;
4691 upper(2,2) = 6;
4692 upper(2,3) = 7;
4693 upper(3,3) = 8;
4694
4695 checkRows ( upper, 4UL );
4696 checkColumns ( upper, 4UL );
4697 checkCapacity( upper, 8UL );
4698 checkNonZeros( upper, 8UL );
4699 checkNonZeros( upper, 0UL, 3UL );
4700 checkNonZeros( upper, 1UL, 2UL );
4701 checkNonZeros( upper, 2UL, 2UL );
4702 checkNonZeros( upper, 3UL, 1UL );
4703
4704 if( upper(0,0) != 1 || upper(0,2) != 2 || upper(0,3) != 3 ||
4705 upper(1,2) != 4 || upper(1,3) != 5 ||
4706 upper(2,2) != 6 || upper(2,3) != 7 ||
4707 upper(3,3) != 8 ) {
4708 std::ostringstream oss;
4709 oss << " Test: " << test_ << "\n"
4710 << " Error: Initialization failed\n"
4711 << " Details:\n"
4712 << " Result:\n" << upper << "\n"
4713 << " Expected result:\n( 1 0 2 3 )\n( 0 0 4 5 )\n( 0 0 6 7 )\n( 0 0 0 8 )\n";
4714 throw std::runtime_error( oss.str() );
4715 }
4716
4717 // Erasing a selection of elements
4718 upper.erase( []( int value ){ return value == 1 || value == 4 || value == 7; } );
4719
4720 checkRows ( upper, 4UL );
4721 checkColumns ( upper, 4UL );
4722 checkCapacity( upper, 8UL );
4723 checkNonZeros( upper, 5UL );
4724 checkNonZeros( upper, 0UL, 2UL );
4725 checkNonZeros( upper, 1UL, 1UL );
4726 checkNonZeros( upper, 2UL, 1UL );
4727 checkNonZeros( upper, 3UL, 1UL );
4728
4729 if( upper(0,2) != 2 || upper(0,3) != 3 ||
4730 upper(1,3) != 5 ||
4731 upper(2,2) != 6 ||
4732 upper(3,3) != 8 ) {
4733 std::ostringstream oss;
4734 oss << " Test: " << test_ << "\n"
4735 << " Error: Erasing a selection of elements failed\n"
4736 << " Details:\n"
4737 << " Result:\n" << upper << "\n"
4738 << " Expected result:\n( 0 0 2 3 )\n( 0 0 0 5 )\n( 0 0 6 0 )\n( 0 0 0 8 )\n";
4739 throw std::runtime_error( oss.str() );
4740 }
4741
4742 // Trying to erase all elements with value 1
4743 upper.erase( []( int value ){ return value == 1; } );
4744
4745 checkRows ( upper, 4UL );
4746 checkColumns ( upper, 4UL );
4747 checkCapacity( upper, 8UL );
4748 checkNonZeros( upper, 5UL );
4749 checkNonZeros( upper, 0UL, 2UL );
4750 checkNonZeros( upper, 1UL, 1UL );
4751 checkNonZeros( upper, 2UL, 1UL );
4752 checkNonZeros( upper, 3UL, 1UL );
4753
4754 if( upper(0,2) != 2 || upper(0,3) != 3 ||
4755 upper(1,3) != 5 ||
4756 upper(2,2) != 6 ||
4757 upper(3,3) != 8 ) {
4758 std::ostringstream oss;
4759 oss << " Test: " << test_ << "\n"
4760 << " Error: Erasing all element with value 1 failed\n"
4761 << " Details:\n"
4762 << " Result:\n" << upper << "\n"
4763 << " Expected result:\n( 0 0 2 3 )\n( 0 0 0 5 )\n( 0 0 6 0 )\n( 0 0 0 8 )\n";
4764 throw std::runtime_error( oss.str() );
4765 }
4766 }
4767
4768
4769 //=====================================================================================
4770 // Row-major iterator-range-based erase function with predicate
4771 //=====================================================================================
4772
4773 {
4774 test_ = "Row-major UpperMatrix::erase( size_t, Iterator, Iterator, Predicate )";
4775
4776 // Initialization check
4777 UT upper( 4UL, 8UL );
4778 upper(0,0) = 1;
4779 upper(0,2) = 2;
4780 upper(0,3) = 3;
4781 upper(1,2) = 4;
4782 upper(1,3) = 5;
4783 upper(2,2) = 6;
4784 upper(2,3) = 7;
4785 upper(3,3) = 8;
4786
4787 checkRows ( upper, 4UL );
4788 checkColumns ( upper, 4UL );
4789 checkCapacity( upper, 8UL );
4790 checkNonZeros( upper, 8UL );
4791 checkNonZeros( upper, 0UL, 3UL );
4792 checkNonZeros( upper, 1UL, 2UL );
4793 checkNonZeros( upper, 2UL, 2UL );
4794 checkNonZeros( upper, 3UL, 1UL );
4795
4796 if( upper(0,0) != 1 || upper(0,2) != 2 || upper(0,3) != 3 ||
4797 upper(1,2) != 4 || upper(1,3) != 5 ||
4798 upper(2,2) != 6 || upper(2,3) != 7 ||
4799 upper(3,3) != 8 ) {
4800 std::ostringstream oss;
4801 oss << " Test: " << test_ << "\n"
4802 << " Error: Initialization failed\n"
4803 << " Details:\n"
4804 << " Result:\n" << upper << "\n"
4805 << " Expected result:\n( 1 0 2 3 )\n( 0 0 4 5 )\n( 0 0 6 7 )\n( 0 0 0 8 )\n";
4806 throw std::runtime_error( oss.str() );
4807 }
4808
4809 // Erasing a selection of elements
4810 upper.erase( 0UL, upper.begin( 0UL ), upper.find( 0UL, 3UL ),
4811 []( int value ){ return value == 1 || value == 2; } );
4812
4813 checkRows ( upper, 4UL );
4814 checkColumns ( upper, 4UL );
4815 checkCapacity( upper, 8UL );
4816 checkNonZeros( upper, 6UL );
4817 checkNonZeros( upper, 0UL, 1UL );
4818 checkNonZeros( upper, 1UL, 2UL );
4819 checkNonZeros( upper, 2UL, 2UL );
4820 checkNonZeros( upper, 3UL, 1UL );
4821
4822 if( upper(0,3) != 3 ||
4823 upper(1,2) != 4 || upper(1,3) != 5 ||
4824 upper(2,2) != 6 || upper(2,3) != 7 ||
4825 upper(3,3) != 8 ) {
4826 std::ostringstream oss;
4827 oss << " Test: " << test_ << "\n"
4828 << " Error: Erasing a selection of elements failed\n"
4829 << " Details:\n"
4830 << " Result:\n" << upper << "\n"
4831 << " Expected result:\n( 0 0 0 3 )\n( 0 0 4 5 )\n( 0 0 6 7 )\n( 0 0 0 8 )\n";
4832 throw std::runtime_error( oss.str() );
4833 }
4834
4835 // Trying to erase from an empty range
4836 upper.erase( 0UL, upper.begin( 0UL ), upper.begin( 0UL ), []( int ){ return true; } );
4837
4838 checkRows ( upper, 4UL );
4839 checkColumns ( upper, 4UL );
4840 checkCapacity( upper, 8UL );
4841 checkNonZeros( upper, 6UL );
4842 checkNonZeros( upper, 0UL, 1UL );
4843 checkNonZeros( upper, 1UL, 2UL );
4844 checkNonZeros( upper, 2UL, 2UL );
4845 checkNonZeros( upper, 3UL, 1UL );
4846
4847 if( upper(0,3) != 3 ||
4848 upper(1,2) != 4 || upper(1,3) != 5 ||
4849 upper(2,2) != 6 || upper(2,3) != 7 ||
4850 upper(3,3) != 8 ) {
4851 std::ostringstream oss;
4852 oss << " Test: " << test_ << "\n"
4853 << " Error: Erasing from an empty range failed\n"
4854 << " Details:\n"
4855 << " Result:\n" << upper << "\n"
4856 << " Expected result:\n( 0 0 0 3 )\n( 0 0 4 5 )\n( 0 0 6 7 )\n( 0 0 0 8 )\n";
4857 throw std::runtime_error( oss.str() );
4858 }
4859 }
4860
4861
4862 //=====================================================================================
4863 // Column-major index-based erase function
4864 //=====================================================================================
4865
4866 {
4867 test_ = "Column-major UpperMatrix::erase( size_t, size_t )";
4868
4869 // Initialization check
4870 OUT upper( 4UL, 8UL );
4871 upper(0,0) = 1;
4872 upper(0,1) = 2;
4873 upper(0,2) = 3;
4874 upper(0,3) = 4;
4875 upper(1,1) = 5;
4876 upper(1,2) = 6;
4877 upper(1,3) = 7;
4878 upper(3,3) = 8;
4879
4880 checkRows ( upper, 4UL );
4881 checkColumns ( upper, 4UL );
4882 checkCapacity( upper, 8UL );
4883 checkNonZeros( upper, 8UL );
4884 checkNonZeros( upper, 0UL, 1UL );
4885 checkNonZeros( upper, 1UL, 2UL );
4886 checkNonZeros( upper, 2UL, 2UL );
4887 checkNonZeros( upper, 3UL, 3UL );
4888
4889 if( upper(0,0) != 1 || upper(0,1) != 2 || upper(0,2) != 3 || upper(0,3) != 4 ||
4890 upper(1,1) != 5 || upper(1,2) != 6 || upper(1,3) != 7 ||
4891 upper(3,3) != 8 ) {
4892 std::ostringstream oss;
4893 oss << " Test: " << test_ << "\n"
4894 << " Error: Initialization failed\n"
4895 << " Details:\n"
4896 << " Result:\n" << upper << "\n"
4897 << " Expected result:\n( 1 2 3 4 )\n( 0 5 6 7 )\n( 0 0 0 0 )\n( 0 0 0 8 )\n";
4898 throw std::runtime_error( oss.str() );
4899 }
4900
4901 // Erasing the element at (0,1)
4902 upper.erase( 0UL, 1UL );
4903
4904 checkRows ( upper, 4UL );
4905 checkColumns ( upper, 4UL );
4906 checkCapacity( upper, 8UL );
4907 checkNonZeros( upper, 7UL );
4908 checkNonZeros( upper, 0UL, 1UL );
4909 checkNonZeros( upper, 1UL, 1UL );
4910 checkNonZeros( upper, 2UL, 2UL );
4911 checkNonZeros( upper, 3UL, 3UL );
4912
4913 if( upper(0,0) != 1 || upper(0,2) != 3 || upper(0,3) != 4 ||
4914 upper(1,1) != 5 || upper(1,2) != 6 || upper(1,3) != 7 ||
4915 upper(3,3) != 8 ) {
4916 std::ostringstream oss;
4917 oss << " Test: " << test_ << "\n"
4918 << " Error: Erasing a non-zero element failed\n"
4919 << " Details:\n"
4920 << " Result:\n" << upper << "\n"
4921 << " Expected result:\n( 1 0 3 4 )\n( 0 5 6 7 )\n( 0 0 0 0 )\n( 0 0 0 8 )\n";
4922 throw std::runtime_error( oss.str() );
4923 }
4924
4925 // Erasing the element at (1,2)
4926 upper.erase( 1UL, 2UL );
4927
4928 checkRows ( upper, 4UL );
4929 checkColumns ( upper, 4UL );
4930 checkCapacity( upper, 8UL );
4931 checkNonZeros( upper, 6UL );
4932 checkNonZeros( upper, 0UL, 1UL );
4933 checkNonZeros( upper, 1UL, 1UL );
4934 checkNonZeros( upper, 2UL, 1UL );
4935 checkNonZeros( upper, 3UL, 3UL );
4936
4937 if( upper(0,0) != 1 || upper(0,2) != 3 || upper(0,3) != 4 ||
4938 upper(1,1) != 5 || upper(1,3) != 7 ||
4939 upper(3,3) != 8 ) {
4940 std::ostringstream oss;
4941 oss << " Test: " << test_ << "\n"
4942 << " Error: Erasing a non-zero element failed\n"
4943 << " Details:\n"
4944 << " Result:\n" << upper << "\n"
4945 << " Expected result:\n( 1 0 3 4 )\n( 0 5 0 7 )\n( 0 0 0 0 )\n( 0 0 0 8 )\n";
4946 throw std::runtime_error( oss.str() );
4947 }
4948
4949 // Erasing the element at (1,3)
4950 upper.erase( 1UL, 3UL );
4951
4952 checkRows ( upper, 4UL );
4953 checkColumns ( upper, 4UL );
4954 checkCapacity( upper, 8UL );
4955 checkNonZeros( upper, 5UL );
4956 checkNonZeros( upper, 0UL, 1UL );
4957 checkNonZeros( upper, 1UL, 1UL );
4958 checkNonZeros( upper, 2UL, 1UL );
4959 checkNonZeros( upper, 3UL, 2UL );
4960
4961 if( upper(0,0) != 1 || upper(0,2) != 3 || upper(0,3) != 4 ||
4962 upper(1,1) != 5 ||
4963 upper(3,3) != 8 ) {
4964 std::ostringstream oss;
4965 oss << " Test: " << test_ << "\n"
4966 << " Error: Erasing a non-zero element failed\n"
4967 << " Details:\n"
4968 << " Result:\n" << upper << "\n"
4969 << " Expected result:\n( 1 0 3 4 )\n( 0 5 0 0 )\n( 0 0 0 0 )\n( 0 0 0 8 )\n";
4970 throw std::runtime_error( oss.str() );
4971 }
4972
4973 // Trying to erase a zero element
4974 upper.erase( 2UL, 3UL );
4975
4976 checkRows ( upper, 4UL );
4977 checkColumns ( upper, 4UL );
4978 checkCapacity( upper, 8UL );
4979 checkNonZeros( upper, 5UL );
4980 checkNonZeros( upper, 0UL, 1UL );
4981 checkNonZeros( upper, 1UL, 1UL );
4982 checkNonZeros( upper, 2UL, 1UL );
4983 checkNonZeros( upper, 3UL, 2UL );
4984
4985 if( upper(0,0) != 1 || upper(0,2) != 3 || upper(0,3) != 4 ||
4986 upper(1,1) != 5 ||
4987 upper(3,3) != 8 ) {
4988 std::ostringstream oss;
4989 oss << " Test: " << test_ << "\n"
4990 << " Error: Erasing a zero element failed\n"
4991 << " Details:\n"
4992 << " Result:\n" << upper << "\n"
4993 << " Expected result:\n( 1 0 3 4 )\n( 0 5 0 0 )\n( 0 0 0 0 )\n( 0 0 0 8 )\n";
4994 throw std::runtime_error( oss.str() );
4995 }
4996 }
4997
4998
4999 //=====================================================================================
5000 // Column-major iterator-based erase function
5001 //=====================================================================================
5002
5003 {
5004 test_ = "Column-major UpperMatrix::erase( size_t, Iterator )";
5005
5006 using Iterator = OUT::Iterator;
5007
5008 // Initialization check
5009 OUT upper( 4UL, 8UL );
5010 upper(0,0) = 1;
5011 upper(0,1) = 2;
5012 upper(0,2) = 3;
5013 upper(0,3) = 4;
5014 upper(1,1) = 5;
5015 upper(1,2) = 6;
5016 upper(1,3) = 7;
5017 upper(3,3) = 8;
5018
5019 checkRows ( upper, 4UL );
5020 checkColumns ( upper, 4UL );
5021 checkCapacity( upper, 8UL );
5022 checkNonZeros( upper, 8UL );
5023 checkNonZeros( upper, 0UL, 1UL );
5024 checkNonZeros( upper, 1UL, 2UL );
5025 checkNonZeros( upper, 2UL, 2UL );
5026 checkNonZeros( upper, 3UL, 3UL );
5027
5028 if( upper(0,0) != 1 || upper(0,1) != 2 || upper(0,2) != 3 || upper(0,3) != 4 ||
5029 upper(1,1) != 5 || upper(1,2) != 6 || upper(1,3) != 7 ||
5030 upper(3,3) != 8 ) {
5031 std::ostringstream oss;
5032 oss << " Test: " << test_ << "\n"
5033 << " Error: Initialization failed\n"
5034 << " Details:\n"
5035 << " Result:\n" << upper << "\n"
5036 << " Expected result:\n( 1 2 3 4 )\n( 0 5 6 7 )\n( 0 0 0 0 )\n( 0 0 0 8 )\n";
5037 throw std::runtime_error( oss.str() );
5038 }
5039
5040 // Erasing the element at (0,1)
5041 {
5042 Iterator pos = upper.erase( 1UL, upper.find( 0UL, 1UL ) );
5043
5044 checkRows ( upper, 4UL );
5045 checkColumns ( upper, 4UL );
5046 checkCapacity( upper, 8UL );
5047 checkNonZeros( upper, 7UL );
5048 checkNonZeros( upper, 0UL, 1UL );
5049 checkNonZeros( upper, 1UL, 1UL );
5050 checkNonZeros( upper, 2UL, 2UL );
5051 checkNonZeros( upper, 3UL, 3UL );
5052
5053 if( upper(0,0) != 1 || upper(0,2) != 3 || upper(0,3) != 4 ||
5054 upper(1,1) != 5 || upper(1,2) != 6 || upper(1,3) != 7 ||
5055 upper(3,3) != 8 ) {
5056 std::ostringstream oss;
5057 oss << " Test: " << test_ << "\n"
5058 << " Error: Erasing a non-zero element failed\n"
5059 << " Details:\n"
5060 << " Result:\n" << upper << "\n"
5061 << " Expected result:\n( 1 0 3 4 )\n( 0 5 6 7 )\n( 0 0 0 0 )\n( 0 0 0 8 )\n";
5062 throw std::runtime_error( oss.str() );
5063 }
5064
5065 if( pos->value() != 5 || pos->index() != 1 ) {
5066 std::ostringstream oss;
5067 oss << " Test: " << test_ << "\n"
5068 << " Error: Invalid iterator returned\n"
5069 << " Details:\n"
5070 << " Value: " << pos->value() << "\n"
5071 << " Index: " << pos->index() << "\n"
5072 << " Expected value: 5\n"
5073 << " Expected index: 1\n";
5074 throw std::runtime_error( oss.str() );
5075 }
5076 }
5077
5078 // Erasing the element at (1,2)
5079 {
5080 Iterator pos = upper.erase( 2UL, upper.find( 1UL, 2UL ) );
5081
5082 checkRows ( upper, 4UL );
5083 checkColumns ( upper, 4UL );
5084 checkCapacity( upper, 8UL );
5085 checkNonZeros( upper, 6UL );
5086 checkNonZeros( upper, 0UL, 1UL );
5087 checkNonZeros( upper, 1UL, 1UL );
5088 checkNonZeros( upper, 2UL, 1UL );
5089 checkNonZeros( upper, 3UL, 3UL );
5090
5091 if( upper(0,0) != 1 || upper(0,2) != 3 || upper(0,3) != 4 ||
5092 upper(1,1) != 5 || upper(1,3) != 7 ||
5093 upper(3,3) != 8 ) {
5094 std::ostringstream oss;
5095 oss << " Test: " << test_ << "\n"
5096 << " Error: Erasing a non-zero element failed\n"
5097 << " Details:\n"
5098 << " Result:\n" << upper << "\n"
5099 << " Expected result:\n( 1 0 3 4 )\n( 0 5 0 7 )\n( 0 0 0 0 )\n( 0 0 0 8 )\n";
5100 throw std::runtime_error( oss.str() );
5101 }
5102
5103 if( pos != upper.end( 2UL ) ) {
5104 std::ostringstream oss;
5105 oss << " Test: " << test_ << "\n"
5106 << " Error: Invalid iterator returned\n"
5107 << " Details:\n"
5108 << " Expected result: the end() iterator\n";
5109 throw std::runtime_error( oss.str() );
5110 }
5111 }
5112
5113 // Erasing the element at (1,3)
5114 {
5115 Iterator pos = upper.erase( 3UL, upper.find( 1UL, 3UL ) );
5116
5117 checkRows ( upper, 4UL );
5118 checkColumns ( upper, 4UL );
5119 checkCapacity( upper, 8UL );
5120 checkNonZeros( upper, 5UL );
5121 checkNonZeros( upper, 0UL, 1UL );
5122 checkNonZeros( upper, 1UL, 1UL );
5123 checkNonZeros( upper, 2UL, 1UL );
5124 checkNonZeros( upper, 3UL, 2UL );
5125
5126 if( upper(0,0) != 1 || upper(0,2) != 3 || upper(0,3) != 4 ||
5127 upper(1,1) != 5 ||
5128 upper(3,3) != 8 ) {
5129 std::ostringstream oss;
5130 oss << " Test: " << test_ << "\n"
5131 << " Error: Erasing a non-zero element failed\n"
5132 << " Details:\n"
5133 << " Result:\n" << upper << "\n"
5134 << " Expected result:\n( 1 0 3 4 )\n( 0 5 0 0 )\n( 0 0 0 0 )\n( 0 0 0 8 )\n";
5135 throw std::runtime_error( oss.str() );
5136 }
5137
5138 if( pos->value() != 8 || pos->index() != 3 ) {
5139 std::ostringstream oss;
5140 oss << " Test: " << test_ << "\n"
5141 << " Error: Invalid iterator returned\n"
5142 << " Details:\n"
5143 << " Value: " << pos->value() << "\n"
5144 << " Index: " << pos->index() << "\n"
5145 << " Expected value: 8\n"
5146 << " Expected index: 3\n";
5147 throw std::runtime_error( oss.str() );
5148 }
5149 }
5150
5151 // Trying to erase a zero element
5152 {
5153 Iterator pos = upper.erase( 3UL, upper.find( 2UL, 3UL ) );
5154
5155 checkRows ( upper, 4UL );
5156 checkColumns ( upper, 4UL );
5157 checkCapacity( upper, 8UL );
5158 checkNonZeros( upper, 5UL );
5159 checkNonZeros( upper, 0UL, 1UL );
5160 checkNonZeros( upper, 1UL, 1UL );
5161 checkNonZeros( upper, 2UL, 1UL );
5162 checkNonZeros( upper, 3UL, 2UL );
5163
5164 if( upper(0,0) != 1 || upper(0,2) != 3 || upper(0,3) != 4 ||
5165 upper(1,1) != 5 ||
5166 upper(3,3) != 8 ) {
5167 std::ostringstream oss;
5168 oss << " Test: " << test_ << "\n"
5169 << " Error: Erasing a zero element failed\n"
5170 << " Details:\n"
5171 << " Result:\n" << upper << "\n"
5172 << " Expected result:\n( 1 0 3 4 )\n( 0 5 0 0 )\n( 0 0 0 0 )\n( 0 0 0 8 )\n";
5173 throw std::runtime_error( oss.str() );
5174 }
5175
5176 if( pos != upper.end( 3UL ) ) {
5177 std::ostringstream oss;
5178 oss << " Test: " << test_ << "\n"
5179 << " Error: Invalid iterator returned\n"
5180 << " Details:\n"
5181 << " Expected result: the end() iterator\n";
5182 throw std::runtime_error( oss.str() );
5183 }
5184 }
5185 }
5186
5187
5188 //=====================================================================================
5189 // Column-major iterator-range-based erase function
5190 //=====================================================================================
5191
5192 {
5193 test_ = "Column-major UpperMatrix::erase( size_t, Iterator, Iterator )";
5194
5195 using Iterator = OUT::Iterator;
5196
5197 // Initialization check
5198 OUT upper( 4UL, 8UL );
5199 upper(0,0) = 1;
5200 upper(0,1) = 2;
5201 upper(0,2) = 3;
5202 upper(0,3) = 4;
5203 upper(1,1) = 5;
5204 upper(1,2) = 6;
5205 upper(1,3) = 7;
5206 upper(3,3) = 8;
5207
5208 checkRows ( upper, 4UL );
5209 checkColumns ( upper, 4UL );
5210 checkCapacity( upper, 8UL );
5211 checkNonZeros( upper, 8UL );
5212 checkNonZeros( upper, 0UL, 1UL );
5213 checkNonZeros( upper, 1UL, 2UL );
5214 checkNonZeros( upper, 2UL, 2UL );
5215 checkNonZeros( upper, 3UL, 3UL );
5216
5217 if( upper(0,0) != 1 || upper(0,1) != 2 || upper(0,2) != 3 || upper(0,3) != 4 ||
5218 upper(1,1) != 5 || upper(1,2) != 6 || upper(1,3) != 7 ||
5219 upper(3,3) != 8 ) {
5220 std::ostringstream oss;
5221 oss << " Test: " << test_ << "\n"
5222 << " Error: Initialization failed\n"
5223 << " Details:\n"
5224 << " Result:\n" << upper << "\n"
5225 << " Expected result:\n( 1 2 3 4 )\n( 0 5 6 7 )\n( 0 0 0 0 )\n( 0 0 0 8 )\n";
5226 throw std::runtime_error( oss.str() );
5227 }
5228
5229 // Erasing the elements from the beginning of column 1 to (1,1)
5230 {
5231 Iterator pos = upper.erase( 1UL, upper.begin( 1UL ), upper.find( 1UL, 1UL ) );
5232
5233 checkRows ( upper, 4UL );
5234 checkColumns ( upper, 4UL );
5235 checkCapacity( upper, 8UL );
5236 checkNonZeros( upper, 7UL );
5237 checkNonZeros( upper, 0UL, 1UL );
5238 checkNonZeros( upper, 1UL, 1UL );
5239 checkNonZeros( upper, 2UL, 2UL );
5240 checkNonZeros( upper, 3UL, 3UL );
5241
5242 if( upper(0,0) != 1 || upper(0,2) != 3 || upper(0,3) != 4 ||
5243 upper(1,1) != 5 || upper(1,2) != 6 || upper(1,3) != 7 ||
5244 upper(3,3) != 8 ) {
5245 std::ostringstream oss;
5246 oss << " Test: " << test_ << "\n"
5247 << " Error: Erasing a single-element range failed\n"
5248 << " Details:\n"
5249 << " Result:\n" << upper << "\n"
5250 << " Expected result:\n( 1 0 3 4 )\n( 0 5 6 7 )\n( 0 0 0 0 )\n( 0 0 0 8 )\n";
5251 throw std::runtime_error( oss.str() );
5252 }
5253
5254 if( pos->value() != 5 || pos->index() != 1 ) {
5255 std::ostringstream oss;
5256 oss << " Test: " << test_ << "\n"
5257 << " Error: Invalid iterator returned\n"
5258 << " Details:\n"
5259 << " Value: " << pos->value() << "\n"
5260 << " Index: " << pos->index() << "\n"
5261 << " Expected value: 5\n"
5262 << " Expected index: 1\n";
5263 throw std::runtime_error( oss.str() );
5264 }
5265 }
5266
5267 // Erasing the elements from (1,2) to the column end
5268 {
5269 Iterator pos = upper.erase( 2UL, upper.find( 1UL, 2UL ), upper.end( 2UL ) );
5270
5271 checkRows ( upper, 4UL );
5272 checkColumns ( upper, 4UL );
5273 checkCapacity( upper, 8UL );
5274 checkNonZeros( upper, 6UL );
5275 checkNonZeros( upper, 0UL, 1UL );
5276 checkNonZeros( upper, 1UL, 1UL );
5277 checkNonZeros( upper, 2UL, 1UL );
5278 checkNonZeros( upper, 3UL, 3UL );
5279
5280 if( upper(0,0) != 1 || upper(0,2) != 3 || upper(0,3) != 4 ||
5281 upper(1,1) != 5 || upper(1,3) != 7 ||
5282 upper(3,3) != 8 ) {
5283 std::ostringstream oss;
5284 oss << " Test: " << test_ << "\n"
5285 << " Error: Erasing a single-element range failed\n"
5286 << " Details:\n"
5287 << " Result:\n" << upper << "\n"
5288 << " Expected result:\n( 1 0 3 4 )\n( 0 5 0 7 )\n( 0 0 0 0 )\n( 0 0 0 8 )\n";
5289 throw std::runtime_error( oss.str() );
5290 }
5291
5292 if( pos != upper.end( 2UL ) ) {
5293 std::ostringstream oss;
5294 oss << " Test: " << test_ << "\n"
5295 << " Error: Invalid iterator returned\n"
5296 << " Details:\n"
5297 << " Expected result: the end() iterator\n";
5298 throw std::runtime_error( oss.str() );
5299 }
5300 }
5301
5302 // Erasing the elements from (0,3) to (3,3)
5303 {
5304 Iterator pos = upper.erase( 3UL, upper.find( 0UL, 3UL ), upper.find( 3UL, 3UL ) );
5305
5306 checkRows ( upper, 4UL );
5307 checkColumns ( upper, 4UL );
5308 checkCapacity( upper, 8UL );
5309 checkNonZeros( upper, 4UL );
5310 checkNonZeros( upper, 0UL, 1UL );
5311 checkNonZeros( upper, 1UL, 1UL );
5312 checkNonZeros( upper, 2UL, 1UL );
5313 checkNonZeros( upper, 3UL, 1UL );
5314
5315 if( upper(0,0) != 1 || upper(0,2) != 3 ||
5316 upper(1,1) != 5 ||
5317 upper(3,3) != 8 ) {
5318 std::ostringstream oss;
5319 oss << " Test: " << test_ << "\n"
5320 << " Error: Erasing a multi-element range failed\n"
5321 << " Details:\n"
5322 << " Result:\n" << upper << "\n"
5323 << " Expected result:\n( 1 0 3 0 )\n( 0 5 0 0 )\n( 0 0 0 0 )\n( 0 0 0 8 )\n";
5324 throw std::runtime_error( oss.str() );
5325 }
5326
5327 if( pos->value() != 8 || pos->index() != 3 ) {
5328 std::ostringstream oss;
5329 oss << " Test: " << test_ << "\n"
5330 << " Error: Invalid iterator returned\n"
5331 << " Details:\n"
5332 << " Value: " << pos->value() << "\n"
5333 << " Index: " << pos->index() << "\n"
5334 << " Expected value: 8\n"
5335 << " Expected index: 3\n";
5336 throw std::runtime_error( oss.str() );
5337 }
5338 }
5339
5340 // Trying to erase an empty range
5341 {
5342 Iterator pos = upper.erase( 3UL, upper.find( 3UL, 3UL ), upper.find( 3UL, 3UL ) );
5343
5344 checkRows ( upper, 4UL );
5345 checkColumns ( upper, 4UL );
5346 checkCapacity( upper, 8UL );
5347 checkNonZeros( upper, 4UL );
5348 checkNonZeros( upper, 0UL, 1UL );
5349 checkNonZeros( upper, 1UL, 1UL );
5350 checkNonZeros( upper, 2UL, 1UL );
5351 checkNonZeros( upper, 3UL, 1UL );
5352
5353 if( upper(0,0) != 1 || upper(0,2) != 3 ||
5354 upper(1,1) != 5 ||
5355 upper(3,3) != 8 ) {
5356 std::ostringstream oss;
5357 oss << " Test: " << test_ << "\n"
5358 << " Error: Erasing an empty range failed\n"
5359 << " Details:\n"
5360 << " Result:\n" << upper << "\n"
5361 << " Expected result:\n( 1 0 3 0 )\n( 0 5 0 0 )\n( 0 0 0 0 )\n( 0 0 0 8 )\n";
5362 throw std::runtime_error( oss.str() );
5363 }
5364
5365 if( pos->value() != 8 || pos->index() != 3 ) {
5366 std::ostringstream oss;
5367 oss << " Test: " << test_ << "\n"
5368 << " Error: Invalid iterator returned\n"
5369 << " Details:\n"
5370 << " Value: " << pos->value() << "\n"
5371 << " Index: " << pos->index() << "\n"
5372 << " Expected value: 8\n"
5373 << " Expected index: 3\n";
5374 throw std::runtime_error( oss.str() );
5375 }
5376 }
5377 }
5378
5379
5380 //=====================================================================================
5381 // Column-major erase function with predicate
5382 //=====================================================================================
5383
5384 {
5385 test_ = "Column-major UpperMatrix::erase( Predicate )";
5386
5387 // Initialization check
5388 OUT upper( 4UL, 8UL );
5389 upper(0,0) = 1;
5390 upper(0,2) = 2;
5391 upper(0,3) = 3;
5392 upper(1,2) = 4;
5393 upper(1,3) = 5;
5394 upper(2,2) = 6;
5395 upper(2,3) = 7;
5396 upper(3,3) = 8;
5397
5398 checkRows ( upper, 4UL );
5399 checkColumns ( upper, 4UL );
5400 checkCapacity( upper, 8UL );
5401 checkNonZeros( upper, 8UL );
5402 checkNonZeros( upper, 0UL, 1UL );
5403 checkNonZeros( upper, 1UL, 0UL );
5404 checkNonZeros( upper, 2UL, 3UL );
5405 checkNonZeros( upper, 3UL, 4UL );
5406
5407 if( upper(0,0) != 1 || upper(0,2) != 2 || upper(0,3) != 3 ||
5408 upper(1,2) != 4 || upper(1,3) != 5 ||
5409 upper(2,2) != 6 || upper(2,3) != 7 ||
5410 upper(3,3) != 8 ) {
5411 std::ostringstream oss;
5412 oss << " Test: " << test_ << "\n"
5413 << " Error: Initialization failed\n"
5414 << " Details:\n"
5415 << " Result:\n" << upper << "\n"
5416 << " Expected result:\n( 1 0 2 3 )\n( 0 0 4 5 )\n( 0 0 6 7 )\n( 0 0 0 8 )\n";
5417 throw std::runtime_error( oss.str() );
5418 }
5419
5420 // Erasing a selection of elements
5421 upper.erase( []( int value ){ return value == 1 || value == 4 || value == 7; } );
5422
5423 checkRows ( upper, 4UL );
5424 checkColumns ( upper, 4UL );
5425 checkCapacity( upper, 8UL );
5426 checkNonZeros( upper, 5UL );
5427 checkNonZeros( upper, 0UL, 0UL );
5428 checkNonZeros( upper, 1UL, 0UL );
5429 checkNonZeros( upper, 2UL, 2UL );
5430 checkNonZeros( upper, 3UL, 3UL );
5431
5432 if( upper(0,2) != 2 || upper(0,3) != 3 ||
5433 upper(1,3) != 5 ||
5434 upper(2,2) != 6 ||
5435 upper(3,3) != 8 ) {
5436 std::ostringstream oss;
5437 oss << " Test: " << test_ << "\n"
5438 << " Error: Erasing a selection of elements failed\n"
5439 << " Details:\n"
5440 << " Result:\n" << upper << "\n"
5441 << " Expected result:\n( 0 0 2 3 )\n( 0 0 0 5 )\n( 0 0 6 0 )\n( 0 0 0 8 )\n";
5442 throw std::runtime_error( oss.str() );
5443 }
5444
5445 // Trying to erase all elements with value 1
5446 upper.erase( []( int value ){ return value == 1; } );
5447
5448 checkRows ( upper, 4UL );
5449 checkColumns ( upper, 4UL );
5450 checkCapacity( upper, 8UL );
5451 checkNonZeros( upper, 5UL );
5452 checkNonZeros( upper, 0UL, 0UL );
5453 checkNonZeros( upper, 1UL, 0UL );
5454 checkNonZeros( upper, 2UL, 2UL );
5455 checkNonZeros( upper, 3UL, 3UL );
5456
5457 if( upper(0,2) != 2 || upper(0,3) != 3 ||
5458 upper(1,3) != 5 ||
5459 upper(2,2) != 6 ||
5460 upper(3,3) != 8 ) {
5461 std::ostringstream oss;
5462 oss << " Test: " << test_ << "\n"
5463 << " Error: Erasing all element with value 1 failed\n"
5464 << " Details:\n"
5465 << " Result:\n" << upper << "\n"
5466 << " Expected result:\n( 0 0 2 3 )\n( 0 0 0 5 )\n( 0 0 6 0 )\n( 0 0 0 8 )\n";
5467 throw std::runtime_error( oss.str() );
5468 }
5469 }
5470
5471
5472 //=====================================================================================
5473 // Column-major iterator-range-based erase function with predicate
5474 //=====================================================================================
5475
5476 {
5477 test_ = "Column-major UpperMatrix::erase( size_t, Iterator, Iterator, Predicate )";
5478
5479 // Initialization check
5480 OUT upper( 4UL, 8UL );
5481 upper(0,0) = 1;
5482 upper(0,2) = 2;
5483 upper(0,3) = 3;
5484 upper(1,2) = 4;
5485 upper(1,3) = 5;
5486 upper(2,2) = 6;
5487 upper(2,3) = 7;
5488 upper(3,3) = 8;
5489
5490 checkRows ( upper, 4UL );
5491 checkColumns ( upper, 4UL );
5492 checkCapacity( upper, 8UL );
5493 checkNonZeros( upper, 8UL );
5494 checkNonZeros( upper, 0UL, 1UL );
5495 checkNonZeros( upper, 1UL, 0UL );
5496 checkNonZeros( upper, 2UL, 3UL );
5497 checkNonZeros( upper, 3UL, 4UL );
5498
5499 if( upper(0,0) != 1 || upper(0,2) != 2 || upper(0,3) != 3 ||
5500 upper(1,2) != 4 || upper(1,3) != 5 ||
5501 upper(2,2) != 6 || upper(2,3) != 7 ||
5502 upper(3,3) != 8 ) {
5503 std::ostringstream oss;
5504 oss << " Test: " << test_ << "\n"
5505 << " Error: Initialization failed\n"
5506 << " Details:\n"
5507 << " Result:\n" << upper << "\n"
5508 << " Expected result:\n( 1 0 2 3 )\n( 0 0 4 5 )\n( 0 0 6 7 )\n( 0 0 0 8 )\n";
5509 throw std::runtime_error( oss.str() );
5510 }
5511
5512 // Erasing a selection of elements
5513 upper.erase( 3UL, upper.begin( 3UL ), upper.find( 3UL, 3UL ),
5514 []( int value ){ return value == 3 || value == 7; } );
5515
5516 checkRows ( upper, 4UL );
5517 checkColumns ( upper, 4UL );
5518 checkCapacity( upper, 8UL );
5519 checkNonZeros( upper, 6UL );
5520 checkNonZeros( upper, 0UL, 1UL );
5521 checkNonZeros( upper, 1UL, 0UL );
5522 checkNonZeros( upper, 2UL, 3UL );
5523 checkNonZeros( upper, 3UL, 2UL );
5524
5525 if( upper(0,0) != 1 || upper(0,2) != 2 ||
5526 upper(1,2) != 4 || upper(1,3) != 5 ||
5527 upper(2,2) != 6 ||
5528 upper(3,3) != 8 ) {
5529 std::ostringstream oss;
5530 oss << " Test: " << test_ << "\n"
5531 << " Error: Erasing a selection of elements failed\n"
5532 << " Details:\n"
5533 << " Result:\n" << upper << "\n"
5534 << " Expected result:\n( 1 0 2 0 )\n( 0 0 4 5 )\n( 0 0 6 0 )\n( 0 0 0 8 )\n";
5535 throw std::runtime_error( oss.str() );
5536 }
5537
5538 // Trying to erase from an empty range
5539 upper.erase( 3UL, upper.begin( 3UL ), upper.begin( 3UL ), []( int ){ return true; } );
5540
5541 checkRows ( upper, 4UL );
5542 checkColumns ( upper, 4UL );
5543 checkCapacity( upper, 8UL );
5544 checkNonZeros( upper, 6UL );
5545 checkNonZeros( upper, 0UL, 1UL );
5546 checkNonZeros( upper, 1UL, 0UL );
5547 checkNonZeros( upper, 2UL, 3UL );
5548 checkNonZeros( upper, 3UL, 2UL );
5549
5550 if( upper(0,0) != 1 || upper(0,2) != 2 ||
5551 upper(1,2) != 4 || upper(1,3) != 5 ||
5552 upper(2,2) != 6 ||
5553 upper(3,3) != 8 ) {
5554 std::ostringstream oss;
5555 oss << " Test: " << test_ << "\n"
5556 << " Error: Erasing from an empty range failed\n"
5557 << " Details:\n"
5558 << " Result:\n" << upper << "\n"
5559 << " Expected result:\n( 1 0 2 0 )\n( 0 0 4 5 )\n( 0 0 6 0 )\n( 0 0 0 8 )\n";
5560 throw std::runtime_error( oss.str() );
5561 }
5562 }
5563 }
5564 //*************************************************************************************************
5565
5566
5567 //*************************************************************************************************
5568 /*!\brief Test of the \c find() member function of the UpperMatrix specialization.
5569 //
5570 // \return void
5571 // \exception std::runtime_error Error detected.
5572 //
5573 // This function performs a test of the \c find() member function of the UpperMatrix
5574 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
5575 */
testFind()5576 void SparseTest::testFind()
5577 {
5578 //=====================================================================================
5579 // Row-major matrix tests
5580 //=====================================================================================
5581
5582 {
5583 test_ = "Row-major UpperMatrix::find()";
5584
5585 using ConstIterator = UT::ConstIterator;
5586
5587 // Initialization check
5588 UT upper( 8UL, 3UL );
5589 upper(1,2) = 1;
5590 upper(2,3) = 2;
5591 upper(5,6) = 3;
5592
5593 checkRows ( upper, 8UL );
5594 checkColumns ( upper, 8UL );
5595 checkCapacity( upper, 3UL );
5596 checkNonZeros( upper, 3UL );
5597 checkNonZeros( upper, 0UL, 0UL );
5598 checkNonZeros( upper, 1UL, 1UL );
5599 checkNonZeros( upper, 2UL, 1UL );
5600 checkNonZeros( upper, 3UL, 0UL );
5601 checkNonZeros( upper, 4UL, 0UL );
5602 checkNonZeros( upper, 5UL, 1UL );
5603 checkNonZeros( upper, 6UL, 0UL );
5604 checkNonZeros( upper, 7UL, 0UL );
5605
5606 // Searching for the first element
5607 {
5608 ConstIterator pos( upper.find( 1UL, 2UL ) );
5609
5610 if( pos == upper.end( 1UL ) ) {
5611 std::ostringstream oss;
5612 oss << " Test: " << test_ << "\n"
5613 << " Error: Element could not be found\n"
5614 << " Details:\n"
5615 << " Required position = (1,2)\n"
5616 << " Current matrix:\n" << upper << "\n";
5617 throw std::runtime_error( oss.str() );
5618 }
5619 else if( pos->index() != 2 || pos->value() != 1 ) {
5620 std::ostringstream oss;
5621 oss << " Test: " << test_ << "\n"
5622 << " Error: Wrong element found\n"
5623 << " Details:\n"
5624 << " Required index = 2\n"
5625 << " Found index = " << pos->index() << "\n"
5626 << " Expected value = 1\n"
5627 << " Value at index = " << pos->value() << "\n"
5628 << " Current matrix:\n" << upper << "\n";
5629 throw std::runtime_error( oss.str() );
5630 }
5631 }
5632
5633 // Searching for the second element
5634 {
5635 ConstIterator pos( upper.find( 2UL, 3UL ) );
5636
5637 if( pos == upper.end( 2UL ) ) {
5638 std::ostringstream oss;
5639 oss << " Test: " << test_ << "\n"
5640 << " Error: Element could not be found\n"
5641 << " Details:\n"
5642 << " Required position = (2,3)\n"
5643 << " Current matrix:\n" << upper << "\n";
5644 throw std::runtime_error( oss.str() );
5645 }
5646 else if( pos->index() != 3 || pos->value() != 2 ) {
5647 std::ostringstream oss;
5648 oss << " Test: " << test_ << "\n"
5649 << " Error: Wrong element found\n"
5650 << " Details:\n"
5651 << " Required index = 3\n"
5652 << " Found index = " << pos->index() << "\n"
5653 << " Expected value = 2\n"
5654 << " Value at index = " << pos->value() << "\n"
5655 << " Current matrix:\n" << upper << "\n";
5656 throw std::runtime_error( oss.str() );
5657 }
5658 }
5659
5660 // Searching for the third element
5661 {
5662 ConstIterator pos( upper.find( 5UL, 6UL ) );
5663
5664 if( pos == upper.end( 5UL ) ) {
5665 std::ostringstream oss;
5666 oss << " Test: " << test_ << "\n"
5667 << " Error: Element could not be found\n"
5668 << " Details:\n"
5669 << " Required position = (5,6)\n"
5670 << " Current matrix:\n" << upper << "\n";
5671 throw std::runtime_error( oss.str() );
5672 }
5673 else if( pos->index() != 6 || pos->value() != 3 ) {
5674 std::ostringstream oss;
5675 oss << " Test: " << test_ << "\n"
5676 << " Error: Wrong element found\n"
5677 << " Details:\n"
5678 << " Required index = 6\n"
5679 << " Found index = " << pos->index() << "\n"
5680 << " Expected value = 3\n"
5681 << " Value at index = " << pos->value() << "\n"
5682 << " Current matrix:\n" << upper << "\n";
5683 throw std::runtime_error( oss.str() );
5684 }
5685 }
5686
5687 // Searching for a non-existing non-zero element
5688 {
5689 ConstIterator pos( upper.find( 0UL, 4UL ) );
5690
5691 if( pos != upper.end( 0UL ) ) {
5692 std::ostringstream oss;
5693 oss << " Test: " << test_ << "\n"
5694 << " Error: Non-existing element could be found\n"
5695 << " Details:\n"
5696 << " Required index = 4\n"
5697 << " Found index = " << pos->index() << "\n"
5698 << " Expected value = 0\n"
5699 << " Value at index = " << pos->value() << "\n"
5700 << " Current matrix:\n" << upper << "\n";
5701 throw std::runtime_error( oss.str() );
5702 }
5703 }
5704 }
5705
5706
5707 //=====================================================================================
5708 // Column-major matrix tests
5709 //=====================================================================================
5710
5711 {
5712 test_ = "Column-major UpperMatrix::find()";
5713
5714 using ConstIterator = OUT::ConstIterator;
5715
5716 // Initialization check
5717 OUT upper( 8UL, 3UL );
5718 upper(1,2) = 1;
5719 upper(2,3) = 2;
5720 upper(5,6) = 3;
5721
5722 checkRows ( upper, 8UL );
5723 checkColumns ( upper, 8UL );
5724 checkCapacity( upper, 3UL );
5725 checkNonZeros( upper, 3UL );
5726 checkNonZeros( upper, 0UL, 0UL );
5727 checkNonZeros( upper, 1UL, 0UL );
5728 checkNonZeros( upper, 2UL, 1UL );
5729 checkNonZeros( upper, 3UL, 1UL );
5730 checkNonZeros( upper, 4UL, 0UL );
5731 checkNonZeros( upper, 5UL, 0UL );
5732 checkNonZeros( upper, 6UL, 1UL );
5733 checkNonZeros( upper, 7UL, 0UL );
5734
5735 // Searching for the first element
5736 {
5737 ConstIterator pos( upper.find( 1UL, 2UL ) );
5738
5739 if( pos == upper.end( 2UL ) ) {
5740 std::ostringstream oss;
5741 oss << " Test: " << test_ << "\n"
5742 << " Error: Element could not be found\n"
5743 << " Details:\n"
5744 << " Required position = (1,2)\n"
5745 << " Current matrix:\n" << upper << "\n";
5746 throw std::runtime_error( oss.str() );
5747 }
5748 else if( pos->index() != 1 || pos->value() != 1 ) {
5749 std::ostringstream oss;
5750 oss << " Test: " << test_ << "\n"
5751 << " Error: Wrong element found\n"
5752 << " Details:\n"
5753 << " Required index = 1\n"
5754 << " Found index = " << pos->index() << "\n"
5755 << " Expected value = 1\n"
5756 << " Value at index = " << pos->value() << "\n"
5757 << " Current matrix:\n" << upper << "\n";
5758 throw std::runtime_error( oss.str() );
5759 }
5760 }
5761
5762 // Searching for the second element
5763 {
5764 ConstIterator pos( upper.find( 2UL, 3UL ) );
5765
5766 if( pos == upper.end( 3UL ) ) {
5767 std::ostringstream oss;
5768 oss << " Test: " << test_ << "\n"
5769 << " Error: Element could not be found\n"
5770 << " Details:\n"
5771 << " Required position = (2,3)\n"
5772 << " Current matrix:\n" << upper << "\n";
5773 throw std::runtime_error( oss.str() );
5774 }
5775 else if( pos->index() != 2 || pos->value() != 2 ) {
5776 std::ostringstream oss;
5777 oss << " Test: " << test_ << "\n"
5778 << " Error: Wrong element found\n"
5779 << " Details:\n"
5780 << " Required index = 2\n"
5781 << " Found index = " << pos->index() << "\n"
5782 << " Expected value = 2\n"
5783 << " Value at index = " << pos->value() << "\n"
5784 << " Current matrix:\n" << upper << "\n";
5785 throw std::runtime_error( oss.str() );
5786 }
5787 }
5788
5789 // Searching for the third element
5790 {
5791 ConstIterator pos( upper.find( 5UL, 6UL ) );
5792
5793 if( pos == upper.end( 6UL ) ) {
5794 std::ostringstream oss;
5795 oss << " Test: " << test_ << "\n"
5796 << " Error: Element could not be found\n"
5797 << " Details:\n"
5798 << " Required position = (5,6)\n"
5799 << " Current matrix:\n" << upper << "\n";
5800 throw std::runtime_error( oss.str() );
5801 }
5802 else if( pos->index() != 5 || pos->value() != 3 ) {
5803 std::ostringstream oss;
5804 oss << " Test: " << test_ << "\n"
5805 << " Error: Wrong element found\n"
5806 << " Details:\n"
5807 << " Required index = 5\n"
5808 << " Found index = " << pos->index() << "\n"
5809 << " Expected value = 3\n"
5810 << " Value at index = " << pos->value() << "\n"
5811 << " Current matrix:\n" << upper << "\n";
5812 throw std::runtime_error( oss.str() );
5813 }
5814 }
5815
5816 // Searching for a non-existing non-zero element
5817 {
5818 ConstIterator pos( upper.find( 0UL, 4UL ) );
5819
5820 if( pos != upper.end( 4UL ) ) {
5821 std::ostringstream oss;
5822 oss << " Test: " << test_ << "\n"
5823 << " Error: Non-existing element could be found\n"
5824 << " Details:\n"
5825 << " Required index = 0\n"
5826 << " Found index = " << pos->index() << "\n"
5827 << " Expected value = 0\n"
5828 << " Value at index = " << pos->value() << "\n"
5829 << " Current matrix:\n" << upper << "\n";
5830 throw std::runtime_error( oss.str() );
5831 }
5832 }
5833 }
5834 }
5835 //*************************************************************************************************
5836
5837
5838 //*************************************************************************************************
5839 /*!\brief Test of the \c lowerBound() member function of the UpperMatrix specialization.
5840 //
5841 // \return void
5842 // \exception std::runtime_error Error detected.
5843 //
5844 // This function performs a test of the \c lowerBound() member function of the UpperMatrix
5845 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
5846 */
testLowerBound()5847 void SparseTest::testLowerBound()
5848 {
5849 //=====================================================================================
5850 // Row-major matrix tests
5851 //=====================================================================================
5852
5853 {
5854 test_ = "Row-major UpperMatrix::lowerBound()";
5855
5856 using ConstIterator = UT::ConstIterator;
5857
5858 // Initialization check
5859 UT upper( 6UL, 2UL );
5860 upper(1,2) = 1;
5861 upper(1,4) = 2;
5862
5863 checkRows ( upper, 6UL );
5864 checkColumns ( upper, 6UL );
5865 checkCapacity( upper, 2UL );
5866 checkNonZeros( upper, 2UL );
5867 checkNonZeros( upper, 0UL, 0UL );
5868 checkNonZeros( upper, 1UL, 2UL );
5869 checkNonZeros( upper, 2UL, 0UL );
5870 checkNonZeros( upper, 3UL, 0UL );
5871 checkNonZeros( upper, 4UL, 0UL );
5872 checkNonZeros( upper, 5UL, 0UL );
5873
5874 // Determining the lower bound for position (1,1)
5875 {
5876 ConstIterator pos( upper.lowerBound( 1UL, 1UL ) );
5877
5878 if( pos == upper.end( 1UL ) ) {
5879 std::ostringstream oss;
5880 oss << " Test: " << test_ << "\n"
5881 << " Error: Lower bound could not be determined\n"
5882 << " Details:\n"
5883 << " Required position = (1,1)\n"
5884 << " Current matrix:\n" << upper << "\n";
5885 throw std::runtime_error( oss.str() );
5886 }
5887 else if( pos->index() != 2 || pos->value() != 1 ) {
5888 std::ostringstream oss;
5889 oss << " Test: " << test_ << "\n"
5890 << " Error: Wrong element found\n"
5891 << " Details:\n"
5892 << " Required index = 2\n"
5893 << " Found index = " << pos->index() << "\n"
5894 << " Expected value = 1\n"
5895 << " Value at index = " << pos->value() << "\n"
5896 << " Current matrix:\n" << upper << "\n";
5897 throw std::runtime_error( oss.str() );
5898 }
5899 }
5900
5901 // Determining the lower bound for position (1,2)
5902 {
5903 ConstIterator pos( upper.lowerBound( 1UL, 2UL ) );
5904
5905 if( pos == upper.end( 1UL ) ) {
5906 std::ostringstream oss;
5907 oss << " Test: " << test_ << "\n"
5908 << " Error: Lower bound could not be determined\n"
5909 << " Details:\n"
5910 << " Required position = (1,2)\n"
5911 << " Current matrix:\n" << upper << "\n";
5912 throw std::runtime_error( oss.str() );
5913 }
5914 else if( pos->index() != 2 || pos->value() != 1 ) {
5915 std::ostringstream oss;
5916 oss << " Test: " << test_ << "\n"
5917 << " Error: Wrong element found\n"
5918 << " Details:\n"
5919 << " Required index = 2\n"
5920 << " Found index = " << pos->index() << "\n"
5921 << " Expected value = 1\n"
5922 << " Value at index = " << pos->value() << "\n"
5923 << " Current matrix:\n" << upper << "\n";
5924 throw std::runtime_error( oss.str() );
5925 }
5926 }
5927
5928 // Determining the lower bound for position (1,3)
5929 {
5930 ConstIterator pos( upper.lowerBound( 1UL, 3UL ) );
5931
5932 if( pos == upper.end( 1UL ) ) {
5933 std::ostringstream oss;
5934 oss << " Test: " << test_ << "\n"
5935 << " Error: Lower bound could not be determined\n"
5936 << " Details:\n"
5937 << " Required position = (1,3)\n"
5938 << " Current matrix:\n" << upper << "\n";
5939 throw std::runtime_error( oss.str() );
5940 }
5941 else if( pos->index() != 4 || pos->value() != 2 ) {
5942 std::ostringstream oss;
5943 oss << " Test: " << test_ << "\n"
5944 << " Error: Wrong element found\n"
5945 << " Details:\n"
5946 << " Required index = 4\n"
5947 << " Found index = " << pos->index() << "\n"
5948 << " Expected value = 2\n"
5949 << " Value at index = " << pos->value() << "\n"
5950 << " Current matrix:\n" << upper << "\n";
5951 throw std::runtime_error( oss.str() );
5952 }
5953 }
5954
5955 // Determining the lower bound for position (1,4)
5956 {
5957 ConstIterator pos( upper.lowerBound( 1UL, 4UL ) );
5958
5959 if( pos == upper.end( 1UL ) ) {
5960 std::ostringstream oss;
5961 oss << " Test: " << test_ << "\n"
5962 << " Error: Lower bound could not be determined\n"
5963 << " Details:\n"
5964 << " Required position = (1,4)\n"
5965 << " Current matrix:\n" << upper << "\n";
5966 throw std::runtime_error( oss.str() );
5967 }
5968 else if( pos->index() != 4 || pos->value() != 2 ) {
5969 std::ostringstream oss;
5970 oss << " Test: " << test_ << "\n"
5971 << " Error: Wrong element found\n"
5972 << " Details:\n"
5973 << " Required index = 4\n"
5974 << " Found index = " << pos->index() << "\n"
5975 << " Expected value = 2\n"
5976 << " Value at index = " << pos->value() << "\n"
5977 << " Current matrix:\n" << upper << "\n";
5978 throw std::runtime_error( oss.str() );
5979 }
5980 }
5981
5982 // Determining the lower bound for position (1,5)
5983 {
5984 ConstIterator pos( upper.lowerBound( 1UL, 5UL ) );
5985
5986 if( pos != upper.end( 1UL ) ) {
5987 std::ostringstream oss;
5988 oss << " Test: " << test_ << "\n"
5989 << " Error: Lower bound could not be determined\n"
5990 << " Details:\n"
5991 << " Required position = (1,5)\n"
5992 << " Current matrix:\n" << upper << "\n";
5993 throw std::runtime_error( oss.str() );
5994 }
5995 }
5996 }
5997
5998
5999 //=====================================================================================
6000 // Column-major matrix tests
6001 //=====================================================================================
6002
6003 {
6004 test_ = "Column-major UpperMatrix::lowerBound()";
6005
6006 using ConstIterator = OUT::ConstIterator;
6007
6008 // Initialization check
6009 OUT upper( 6UL, 2UL );
6010 upper(1,4) = 1;
6011 upper(3,4) = 2;
6012
6013 checkRows ( upper, 6UL );
6014 checkColumns ( upper, 6UL );
6015 checkCapacity( upper, 2UL );
6016 checkNonZeros( upper, 2UL );
6017 checkNonZeros( upper, 0UL, 0UL );
6018 checkNonZeros( upper, 1UL, 0UL );
6019 checkNonZeros( upper, 2UL, 0UL );
6020 checkNonZeros( upper, 3UL, 0UL );
6021 checkNonZeros( upper, 4UL, 2UL );
6022 checkNonZeros( upper, 5UL, 0UL );
6023
6024 // Determining the lower bound for position (0,4)
6025 {
6026 ConstIterator pos( upper.lowerBound( 0UL, 4UL ) );
6027
6028 if( pos == upper.end( 4UL ) ) {
6029 std::ostringstream oss;
6030 oss << " Test: " << test_ << "\n"
6031 << " Error: Lower bound could not be determined\n"
6032 << " Details:\n"
6033 << " Required position = (0,4)\n"
6034 << " Current matrix:\n" << upper << "\n";
6035 throw std::runtime_error( oss.str() );
6036 }
6037 else if( pos->index() != 1 || pos->value() != 1 ) {
6038 std::ostringstream oss;
6039 oss << " Test: " << test_ << "\n"
6040 << " Error: Wrong element found\n"
6041 << " Details:\n"
6042 << " Required index = 1\n"
6043 << " Found index = " << pos->index() << "\n"
6044 << " Expected value = 1\n"
6045 << " Value at index = " << pos->value() << "\n"
6046 << " Current matrix:\n" << upper << "\n";
6047 throw std::runtime_error( oss.str() );
6048 }
6049 }
6050
6051 // Determining the lower bound for position (1,4)
6052 {
6053 ConstIterator pos( upper.lowerBound( 1UL, 4UL ) );
6054
6055 if( pos == upper.end( 4UL ) ) {
6056 std::ostringstream oss;
6057 oss << " Test: " << test_ << "\n"
6058 << " Error: Lower bound could not be determined\n"
6059 << " Details:\n"
6060 << " Required position = (1,4)\n"
6061 << " Current matrix:\n" << upper << "\n";
6062 throw std::runtime_error( oss.str() );
6063 }
6064 else if( pos->index() != 1 || pos->value() != 1 ) {
6065 std::ostringstream oss;
6066 oss << " Test: " << test_ << "\n"
6067 << " Error: Wrong element found\n"
6068 << " Details:\n"
6069 << " Required index = 1\n"
6070 << " Found index = " << pos->index() << "\n"
6071 << " Expected value = 1\n"
6072 << " Value at index = " << pos->value() << "\n"
6073 << " Current matrix:\n" << upper << "\n";
6074 throw std::runtime_error( oss.str() );
6075 }
6076 }
6077
6078 // Determining the lower bound for position (2,4)
6079 {
6080 ConstIterator pos( upper.lowerBound( 2UL, 4UL ) );
6081
6082 if( pos == upper.end( 4UL ) ) {
6083 std::ostringstream oss;
6084 oss << " Test: " << test_ << "\n"
6085 << " Error: Lower bound could not be determined\n"
6086 << " Details:\n"
6087 << " Required position = (2,4)\n"
6088 << " Current matrix:\n" << upper << "\n";
6089 throw std::runtime_error( oss.str() );
6090 }
6091 else if( pos->index() != 3 || pos->value() != 2 ) {
6092 std::ostringstream oss;
6093 oss << " Test: " << test_ << "\n"
6094 << " Error: Wrong element found\n"
6095 << " Details:\n"
6096 << " Required index = 3\n"
6097 << " Found index = " << pos->index() << "\n"
6098 << " Expected value = 2\n"
6099 << " Value at index = " << pos->value() << "\n"
6100 << " Current matrix:\n" << upper << "\n";
6101 throw std::runtime_error( oss.str() );
6102 }
6103 }
6104
6105 // Determining the lower bound for position (3,4)
6106 {
6107 ConstIterator pos( upper.lowerBound( 3UL, 4UL ) );
6108
6109 if( pos == upper.end( 4UL ) ) {
6110 std::ostringstream oss;
6111 oss << " Test: " << test_ << "\n"
6112 << " Error: Lower bound could not be determined\n"
6113 << " Details:\n"
6114 << " Required position = (3,4)\n"
6115 << " Current matrix:\n" << upper << "\n";
6116 throw std::runtime_error( oss.str() );
6117 }
6118 else if( pos->index() != 3 || pos->value() != 2 ) {
6119 std::ostringstream oss;
6120 oss << " Test: " << test_ << "\n"
6121 << " Error: Wrong element found\n"
6122 << " Details:\n"
6123 << " Required index = 3\n"
6124 << " Found index = " << pos->index() << "\n"
6125 << " Expected value = 2\n"
6126 << " Value at index = " << pos->value() << "\n"
6127 << " Current matrix:\n" << upper << "\n";
6128 throw std::runtime_error( oss.str() );
6129 }
6130 }
6131
6132 // Determining the lower bound for position (4,4)
6133 {
6134 ConstIterator pos( upper.lowerBound( 4UL, 4UL ) );
6135
6136 if( pos != upper.end( 4UL ) ) {
6137 std::ostringstream oss;
6138 oss << " Test: " << test_ << "\n"
6139 << " Error: Lower bound could not be determined\n"
6140 << " Details:\n"
6141 << " Required position = (4,4)\n"
6142 << " Current matrix:\n" << upper << "\n";
6143 throw std::runtime_error( oss.str() );
6144 }
6145 }
6146 }
6147 }
6148 //*************************************************************************************************
6149
6150
6151 //*************************************************************************************************
6152 /*!\brief Test of the \c upperBound() member function of the UpperMatrix specialization.
6153 //
6154 // \return void
6155 // \exception std::runtime_error Error detected.
6156 //
6157 // This function performs a test of the \c upperBound() member function of the UpperMatrix
6158 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
6159 */
testUpperBound()6160 void SparseTest::testUpperBound()
6161 {
6162 //=====================================================================================
6163 // Row-major matrix tests
6164 //=====================================================================================
6165
6166 {
6167 test_ = "Row-major UpperMatrix::upperBound()";
6168
6169 using ConstIterator = UT::ConstIterator;
6170
6171 // Initialization check
6172 UT upper( 6UL, 2UL );
6173 upper(1,2) = 1;
6174 upper(1,4) = 2;
6175
6176 checkRows ( upper, 6UL );
6177 checkColumns ( upper, 6UL );
6178 checkCapacity( upper, 2UL );
6179 checkNonZeros( upper, 2UL );
6180 checkNonZeros( upper, 0UL, 0UL );
6181 checkNonZeros( upper, 1UL, 2UL );
6182 checkNonZeros( upper, 2UL, 0UL );
6183 checkNonZeros( upper, 3UL, 0UL );
6184 checkNonZeros( upper, 4UL, 0UL );
6185 checkNonZeros( upper, 5UL, 0UL );
6186
6187 // Determining the upper bound for position (1,1)
6188 {
6189 ConstIterator pos( upper.upperBound( 1UL, 1UL ) );
6190
6191 if( pos == upper.end( 1UL ) ) {
6192 std::ostringstream oss;
6193 oss << " Test: " << test_ << "\n"
6194 << " Error: Upper bound could not be determined\n"
6195 << " Details:\n"
6196 << " Required position = (1,1)\n"
6197 << " Current matrix:\n" << upper << "\n";
6198 throw std::runtime_error( oss.str() );
6199 }
6200 else if( pos->index() != 2 || pos->value() != 1 ) {
6201 std::ostringstream oss;
6202 oss << " Test: " << test_ << "\n"
6203 << " Error: Wrong element found\n"
6204 << " Details:\n"
6205 << " Required index = 2\n"
6206 << " Found index = " << pos->index() << "\n"
6207 << " Expected value = 1\n"
6208 << " Value at index = " << pos->value() << "\n"
6209 << " Current matrix:\n" << upper << "\n";
6210 throw std::runtime_error( oss.str() );
6211 }
6212 }
6213
6214 // Determining the upper bound for position (1,2)
6215 {
6216 ConstIterator pos( upper.upperBound( 1UL, 2UL ) );
6217
6218 if( pos == upper.end( 1UL ) ) {
6219 std::ostringstream oss;
6220 oss << " Test: " << test_ << "\n"
6221 << " Error: Upper bound could not be determined\n"
6222 << " Details:\n"
6223 << " Required position = (1,2)\n"
6224 << " Current matrix:\n" << upper << "\n";
6225 throw std::runtime_error( oss.str() );
6226 }
6227 else if( pos->index() != 4 || pos->value() != 2 ) {
6228 std::ostringstream oss;
6229 oss << " Test: " << test_ << "\n"
6230 << " Error: Wrong element found\n"
6231 << " Details:\n"
6232 << " Required index = 4\n"
6233 << " Found index = " << pos->index() << "\n"
6234 << " Expected value = 2\n"
6235 << " Value at index = " << pos->value() << "\n"
6236 << " Current matrix:\n" << upper << "\n";
6237 throw std::runtime_error( oss.str() );
6238 }
6239 }
6240
6241 // Determining the upper bound for position (1,3)
6242 {
6243 ConstIterator pos( upper.upperBound( 1UL, 3UL ) );
6244
6245 if( pos == upper.end( 1UL ) ) {
6246 std::ostringstream oss;
6247 oss << " Test: " << test_ << "\n"
6248 << " Error: Upper bound could not be determined\n"
6249 << " Details:\n"
6250 << " Required position = (1,3)\n"
6251 << " Current matrix:\n" << upper << "\n";
6252 throw std::runtime_error( oss.str() );
6253 }
6254 else if( pos->index() != 4 || pos->value() != 2 ) {
6255 std::ostringstream oss;
6256 oss << " Test: " << test_ << "\n"
6257 << " Error: Wrong element found\n"
6258 << " Details:\n"
6259 << " Required index = 4\n"
6260 << " Found index = " << pos->index() << "\n"
6261 << " Expected value = 2\n"
6262 << " Value at index = " << pos->value() << "\n"
6263 << " Current matrix:\n" << upper << "\n";
6264 throw std::runtime_error( oss.str() );
6265 }
6266 }
6267
6268 // Determining the upper bound for position (1,4)
6269 {
6270 ConstIterator pos( upper.upperBound( 1UL, 4UL ) );
6271
6272 if( pos != upper.end( 1UL ) ) {
6273 std::ostringstream oss;
6274 oss << " Test: " << test_ << "\n"
6275 << " Error: Upper bound could not be determined\n"
6276 << " Details:\n"
6277 << " Required position = (1,4)\n"
6278 << " Current matrix:\n" << upper << "\n";
6279 throw std::runtime_error( oss.str() );
6280 }
6281 }
6282
6283 // Determining the upper bound for position (1,5)
6284 {
6285 ConstIterator pos( upper.upperBound( 1UL, 5UL ) );
6286
6287 if( pos != upper.end( 1UL ) ) {
6288 std::ostringstream oss;
6289 oss << " Test: " << test_ << "\n"
6290 << " Error: Upper bound could not be determined\n"
6291 << " Details:\n"
6292 << " Required position = (1,5)\n"
6293 << " Current matrix:\n" << upper << "\n";
6294 throw std::runtime_error( oss.str() );
6295 }
6296 }
6297 }
6298
6299
6300 //=====================================================================================
6301 // Column-major matrix tests
6302 //=====================================================================================
6303
6304 {
6305 test_ = "Column-major UpperMatrix::upperBound()";
6306
6307 using ConstIterator = OUT::ConstIterator;
6308
6309 // Initialization check
6310 OUT upper( 6UL, 2UL );
6311 upper(1,4) = 1;
6312 upper(3,4) = 2;
6313
6314 checkRows ( upper, 6UL );
6315 checkColumns ( upper, 6UL );
6316 checkCapacity( upper, 2UL );
6317 checkNonZeros( upper, 2UL );
6318 checkNonZeros( upper, 0UL, 0UL );
6319 checkNonZeros( upper, 1UL, 0UL );
6320 checkNonZeros( upper, 2UL, 0UL );
6321 checkNonZeros( upper, 3UL, 0UL );
6322 checkNonZeros( upper, 4UL, 2UL );
6323 checkNonZeros( upper, 5UL, 0UL );
6324
6325 // Determining the upper bound for position (0,4)
6326 {
6327 ConstIterator pos( upper.upperBound( 0UL, 4UL ) );
6328
6329 if( pos == upper.end( 4UL ) ) {
6330 std::ostringstream oss;
6331 oss << " Test: " << test_ << "\n"
6332 << " Error: Upper bound could not be determined\n"
6333 << " Details:\n"
6334 << " Required position = (0,4)\n"
6335 << " Current matrix:\n" << upper << "\n";
6336 throw std::runtime_error( oss.str() );
6337 }
6338 else if( pos->index() != 1 || pos->value() != 1 ) {
6339 std::ostringstream oss;
6340 oss << " Test: " << test_ << "\n"
6341 << " Error: Wrong element found\n"
6342 << " Details:\n"
6343 << " Required index = 1\n"
6344 << " Found index = " << pos->index() << "\n"
6345 << " Expected value = 1\n"
6346 << " Value at index = " << pos->value() << "\n"
6347 << " Current matrix:\n" << upper << "\n";
6348 throw std::runtime_error( oss.str() );
6349 }
6350 }
6351
6352 // Determining the upper bound for position (1,4)
6353 {
6354 ConstIterator pos( upper.upperBound( 1UL, 4UL ) );
6355
6356 if( pos == upper.end( 4UL ) ) {
6357 std::ostringstream oss;
6358 oss << " Test: " << test_ << "\n"
6359 << " Error: Upper bound could not be determined\n"
6360 << " Details:\n"
6361 << " Required position = (1,4)\n"
6362 << " Current matrix:\n" << upper << "\n";
6363 throw std::runtime_error( oss.str() );
6364 }
6365 else if( pos->index() != 3 || pos->value() != 2 ) {
6366 std::ostringstream oss;
6367 oss << " Test: " << test_ << "\n"
6368 << " Error: Wrong element found\n"
6369 << " Details:\n"
6370 << " Required index = 3\n"
6371 << " Found index = " << pos->index() << "\n"
6372 << " Expected value = 2\n"
6373 << " Value at index = " << pos->value() << "\n"
6374 << " Current matrix:\n" << upper << "\n";
6375 throw std::runtime_error( oss.str() );
6376 }
6377 }
6378
6379 // Determining the upper bound for position (2,4)
6380 {
6381 ConstIterator pos( upper.upperBound( 2UL, 4UL ) );
6382
6383 if( pos == upper.end( 4UL ) ) {
6384 std::ostringstream oss;
6385 oss << " Test: " << test_ << "\n"
6386 << " Error: Upper bound could not be determined\n"
6387 << " Details:\n"
6388 << " Required position = (2,4)\n"
6389 << " Current matrix:\n" << upper << "\n";
6390 throw std::runtime_error( oss.str() );
6391 }
6392 else if( pos->index() != 3 || pos->value() != 2 ) {
6393 std::ostringstream oss;
6394 oss << " Test: " << test_ << "\n"
6395 << " Error: Wrong element found\n"
6396 << " Details:\n"
6397 << " Required index = 3\n"
6398 << " Found index = " << pos->index() << "\n"
6399 << " Expected value = 2\n"
6400 << " Value at index = " << pos->value() << "\n"
6401 << " Current matrix:\n" << upper << "\n";
6402 throw std::runtime_error( oss.str() );
6403 }
6404 }
6405
6406 // Determining the upper bound for position (3,4)
6407 {
6408 ConstIterator pos( upper.upperBound( 3UL, 4UL ) );
6409
6410 if( pos != upper.end( 4UL ) ) {
6411 std::ostringstream oss;
6412 oss << " Test: " << test_ << "\n"
6413 << " Error: Upper bound could not be determined\n"
6414 << " Details:\n"
6415 << " Required position = (3,4)\n"
6416 << " Current matrix:\n" << upper << "\n";
6417 throw std::runtime_error( oss.str() );
6418 }
6419 }
6420
6421 // Determining the upper bound for position (4,4)
6422 {
6423 ConstIterator pos( upper.upperBound( 4UL, 4UL ) );
6424
6425 if( pos != upper.end( 4UL ) ) {
6426 std::ostringstream oss;
6427 oss << " Test: " << test_ << "\n"
6428 << " Error: Upper bound could not be determined\n"
6429 << " Details:\n"
6430 << " Required position = (4,4)\n"
6431 << " Current matrix:\n" << upper << "\n";
6432 throw std::runtime_error( oss.str() );
6433 }
6434 }
6435 }
6436 }
6437 //*************************************************************************************************
6438
6439
6440 //*************************************************************************************************
6441 /*!\brief Test of the \c isDefault() function with the UpperMatrix specialization.
6442 //
6443 // \return void
6444 // \exception std::runtime_error Error detected.
6445 //
6446 // This function performs a test of the \c isDefault() function with the UpperMatrix
6447 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
6448 */
testIsDefault()6449 void SparseTest::testIsDefault()
6450 {
6451 //=====================================================================================
6452 // Row-major matrix tests
6453 //=====================================================================================
6454
6455 {
6456 test_ = "Row-major isDefault() function";
6457
6458 // isDefault with 0x0 matrix
6459 {
6460 UT upper;
6461
6462 if( isDefault( upper ) != true ) {
6463 std::ostringstream oss;
6464 oss << " Test: " << test_ << "\n"
6465 << " Error: Invalid isDefault evaluation\n"
6466 << " Details:\n"
6467 << " Matrix:\n" << upper << "\n";
6468 throw std::runtime_error( oss.str() );
6469 }
6470 }
6471
6472 // isDefault with default matrix
6473 {
6474 UT upper( 3UL );
6475
6476 if( isDefault( upper(0,1) ) != true ) {
6477 std::ostringstream oss;
6478 oss << " Test: " << test_ << "\n"
6479 << " Error: Invalid isDefault evaluation\n"
6480 << " Details:\n"
6481 << " Matrix element:\n" << upper(0,1) << "\n";
6482 throw std::runtime_error( oss.str() );
6483 }
6484
6485 if( isDefault( upper ) != false ) {
6486 std::ostringstream oss;
6487 oss << " Test: " << test_ << "\n"
6488 << " Error: Invalid isDefault evaluation\n"
6489 << " Details:\n"
6490 << " Matrix:\n" << upper << "\n";
6491 throw std::runtime_error( oss.str() );
6492 }
6493 }
6494
6495 // isDefault with non-default matrix
6496 {
6497 UT upper( 3UL );
6498 upper(0,1) = 1;
6499
6500 if( isDefault( upper(0,1) ) != false ) {
6501 std::ostringstream oss;
6502 oss << " Test: " << test_ << "\n"
6503 << " Error: Invalid isDefault evaluation\n"
6504 << " Details:\n"
6505 << " Matrix element:\n" << upper(0,1) << "\n";
6506 throw std::runtime_error( oss.str() );
6507 }
6508
6509 if( isDefault( upper ) != false ) {
6510 std::ostringstream oss;
6511 oss << " Test: " << test_ << "\n"
6512 << " Error: Invalid isDefault evaluation\n"
6513 << " Details:\n"
6514 << " Matrix:\n" << upper << "\n";
6515 throw std::runtime_error( oss.str() );
6516 }
6517 }
6518 }
6519
6520
6521 //=====================================================================================
6522 // Column-major matrix tests
6523 //=====================================================================================
6524
6525 {
6526 test_ = "Column-major isDefault() function";
6527
6528 // isDefault with 0x0 matrix
6529 {
6530 OUT upper;
6531
6532 if( isDefault( upper ) != true ) {
6533 std::ostringstream oss;
6534 oss << " Test: " << test_ << "\n"
6535 << " Error: Invalid isDefault evaluation\n"
6536 << " Details:\n"
6537 << " Matrix:\n" << upper << "\n";
6538 throw std::runtime_error( oss.str() );
6539 }
6540 }
6541
6542 // isDefault with default matrix
6543 {
6544 OUT upper( 3UL );
6545
6546 if( isDefault( upper(0,1) ) != true ) {
6547 std::ostringstream oss;
6548 oss << " Test: " << test_ << "\n"
6549 << " Error: Invalid isDefault evaluation\n"
6550 << " Details:\n"
6551 << " Matrix element:\n" << upper(0,1) << "\n";
6552 throw std::runtime_error( oss.str() );
6553 }
6554
6555 if( isDefault( upper ) != false ) {
6556 std::ostringstream oss;
6557 oss << " Test: " << test_ << "\n"
6558 << " Error: Invalid isDefault evaluation\n"
6559 << " Details:\n"
6560 << " Matrix:\n" << upper << "\n";
6561 throw std::runtime_error( oss.str() );
6562 }
6563 }
6564
6565 // isDefault with non-default matrix
6566 {
6567 OUT upper( 3UL );
6568 upper(0,1) = 1;
6569
6570 if( isDefault( upper(0,1) ) != false ) {
6571 std::ostringstream oss;
6572 oss << " Test: " << test_ << "\n"
6573 << " Error: Invalid isDefault evaluation\n"
6574 << " Details:\n"
6575 << " Matrix element:\n" << upper(0,1) << "\n";
6576 throw std::runtime_error( oss.str() );
6577 }
6578
6579 if( isDefault( upper ) != false ) {
6580 std::ostringstream oss;
6581 oss << " Test: " << test_ << "\n"
6582 << " Error: Invalid isDefault evaluation\n"
6583 << " Details:\n"
6584 << " Matrix:\n" << upper << "\n";
6585 throw std::runtime_error( oss.str() );
6586 }
6587 }
6588 }
6589 }
6590 //*************************************************************************************************
6591
6592
6593 //*************************************************************************************************
6594 /*!\brief Test of the \c submatrix() function with the UpperMatrix specialization.
6595 //
6596 // \return void
6597 // \exception std::runtime_error Error detected.
6598 //
6599 // This function performs a test of the \c submatrix() function with the UpperMatrix
6600 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
6601 */
testSubmatrix()6602 void SparseTest::testSubmatrix()
6603 {
6604 //=====================================================================================
6605 // Row-major general tests
6606 //=====================================================================================
6607
6608 {
6609 test_ = "Row-major submatrix() function";
6610
6611 using SMT = blaze::Submatrix<UT>;
6612
6613 UT upper( 3UL );
6614 upper(0,0) = 1;
6615 upper(0,1) = -4;
6616 upper(0,2) = 7;
6617 upper(1,1) = 2;
6618 upper(2,2) = 3;
6619
6620 SMT sm = submatrix( upper, 1UL, 1UL, 2UL, 2UL );
6621
6622 if( sm(1,1) != 3 ) {
6623 std::ostringstream oss;
6624 oss << " Test: " << test_ << "\n"
6625 << " Error: Function call operator access failed\n"
6626 << " Details:\n"
6627 << " Result: " << sm(1,1) << "\n"
6628 << " Expected result: 3\n";
6629 throw std::runtime_error( oss.str() );
6630 }
6631
6632 SMT::Iterator it = sm.begin(0UL);
6633
6634 if( it == sm.end(0UL) || it->value() != 2 ) {
6635 std::ostringstream oss;
6636 oss << " Test: " << test_ << "\n"
6637 << " Error: Iterator access failed\n"
6638 << " Details:\n"
6639 << " Result: " << it->value() << "\n"
6640 << " Expected result: 2\n";
6641 throw std::runtime_error( oss.str() );
6642 }
6643
6644 sm(0,1) = -5;
6645
6646 if( sm(0,0) != 2 || sm(0,1) != -5 ||
6647 sm(1,0) != 0 || sm(1,1) != 3 ) {
6648 std::ostringstream oss;
6649 oss << " Test: " << test_ << "\n"
6650 << " Error: Submatrix access failed\n"
6651 << " Details:\n"
6652 << " Result:\n" << sm << "\n"
6653 << " Expected result:\n( 2 -5 )\n( 0 3 )\n";
6654 throw std::runtime_error( oss.str() );
6655 }
6656
6657 if( upper(0,0) != 1 || upper(0,1) != -4 || upper(0,2) != 7 ||
6658 upper(1,0) != 0 || upper(1,1) != 2 || upper(1,2) != -5 ||
6659 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 3 ) {
6660 std::ostringstream oss;
6661 oss << " Test: " << test_ << "\n"
6662 << " Error: Submatrix access failed\n"
6663 << " Details:\n"
6664 << " Result:\n" << upper << "\n"
6665 << " Expected result:\n( 1 -4 7 )\n( 0 2 -5 )\n( 0 0 3 )\n";
6666 throw std::runtime_error( oss.str() );
6667 }
6668
6669 reset( sm );
6670
6671 if( sm(0,0) != 0 || sm(0,1) != 0 ||
6672 sm(1,0) != 0 || sm(1,1) != 0 ) {
6673 std::ostringstream oss;
6674 oss << " Test: " << test_ << "\n"
6675 << " Error: Submatrix reset failed\n"
6676 << " Details:\n"
6677 << " Result:\n" << sm << "\n"
6678 << " Expected result:\n( 0 0 )\n( 0 0 )\n";
6679 throw std::runtime_error( oss.str() );
6680 }
6681
6682 if( upper(0,0) != 1 || upper(0,1) != -4 || upper(0,2) != 7 ||
6683 upper(1,0) != 0 || upper(1,1) != 0 || upper(1,2) != 0 ||
6684 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 0 ) {
6685 std::ostringstream oss;
6686 oss << " Test: " << test_ << "\n"
6687 << " Error: Submatrix reset failed\n"
6688 << " Details:\n"
6689 << " Result:\n" << upper << "\n"
6690 << " Expected result:\n( 1 -4 7 )\n( 0 0 0 )\n( 0 0 0 )\n";
6691 throw std::runtime_error( oss.str() );
6692 }
6693 }
6694
6695
6696 //=====================================================================================
6697 // Column-major general tests
6698 //=====================================================================================
6699
6700 {
6701 test_ = "Column-major submatrix() function";
6702
6703 using SMT = blaze::Submatrix<OUT>;
6704
6705 OUT upper( 3UL );
6706 upper(0,0) = 1;
6707 upper(0,1) = -4;
6708 upper(0,2) = 7;
6709 upper(1,1) = 2;
6710 upper(2,2) = 3;
6711
6712 SMT sm = submatrix( upper, 1UL, 1UL, 2UL, 2UL );
6713
6714 if( sm(1,1) != 3 ) {
6715 std::ostringstream oss;
6716 oss << " Test: " << test_ << "\n"
6717 << " Error: Function call operator access failed\n"
6718 << " Details:\n"
6719 << " Result: " << sm(1,1) << "\n"
6720 << " Expected result: 3\n";
6721 throw std::runtime_error( oss.str() );
6722 }
6723
6724 SMT::Iterator it = sm.begin(0UL);
6725
6726 if( it == sm.end(0UL) || it->value() != 2 ) {
6727 std::ostringstream oss;
6728 oss << " Test: " << test_ << "\n"
6729 << " Error: Iterator access failed\n"
6730 << " Details:\n"
6731 << " Result: " << it->value() << "\n"
6732 << " Expected result: 2\n";
6733 throw std::runtime_error( oss.str() );
6734 }
6735
6736 sm(0,1) = -5;
6737
6738 if( sm(0,0) != 2 || sm(0,1) != -5 ||
6739 sm(1,0) != 0 || sm(1,1) != 3 ) {
6740 std::ostringstream oss;
6741 oss << " Test: " << test_ << "\n"
6742 << " Error: Submatrix access failed\n"
6743 << " Details:\n"
6744 << " Result:\n" << sm << "\n"
6745 << " Expected result:\n( 2 -5 )\n( 0 3 )\n";
6746 throw std::runtime_error( oss.str() );
6747 }
6748
6749 if( upper(0,0) != 1 || upper(0,1) != -4 || upper(0,2) != 7 ||
6750 upper(1,0) != 0 || upper(1,1) != 2 || upper(1,2) != -5 ||
6751 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 3 ) {
6752 std::ostringstream oss;
6753 oss << " Test: " << test_ << "\n"
6754 << " Error: Submatrix access failed\n"
6755 << " Details:\n"
6756 << " Result:\n" << upper << "\n"
6757 << " Expected result:\n( 1 -4 7 )\n( 0 2 -5 )\n( 0 0 3 )\n";
6758 throw std::runtime_error( oss.str() );
6759 }
6760
6761 reset( sm );
6762
6763 if( sm(0,0) != 0 || sm(0,1) != 0 ||
6764 sm(1,0) != 0 || sm(1,1) != 0 ) {
6765 std::ostringstream oss;
6766 oss << " Test: " << test_ << "\n"
6767 << " Error: Submatrix reset failed\n"
6768 << " Details:\n"
6769 << " Result:\n" << sm << "\n"
6770 << " Expected result:\n( 0 0 )\n( 0 0 )\n";
6771 throw std::runtime_error( oss.str() );
6772 }
6773
6774 if( upper(0,0) != 1 || upper(0,1) != -4 || upper(0,2) != 7 ||
6775 upper(1,0) != 0 || upper(1,1) != 0 || upper(1,2) != 0 ||
6776 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 0 ) {
6777 std::ostringstream oss;
6778 oss << " Test: " << test_ << "\n"
6779 << " Error: Submatrix reset failed\n"
6780 << " Details:\n"
6781 << " Result:\n" << upper << "\n"
6782 << " Expected result:\n( 1 -4 7 )\n( 0 0 0 )\n( 0 0 0 )\n";
6783 throw std::runtime_error( oss.str() );
6784 }
6785 }
6786 }
6787 //*************************************************************************************************
6788
6789
6790 //*************************************************************************************************
6791 /*!\brief Test of the \c row() function with the UpperMatrix specialization.
6792 //
6793 // \return void
6794 // \exception std::runtime_error Error detected.
6795 //
6796 // This function performs a test of the \c row() function with the UpperMatrix specialization.
6797 // In case an error is detected, a \a std::runtime_error exception is thrown.
6798 */
testRow()6799 void SparseTest::testRow()
6800 {
6801 //=====================================================================================
6802 // Row-major general tests
6803 //=====================================================================================
6804
6805 {
6806 test_ = "Row-major row() function";
6807
6808 using RT = blaze::Row<UT>;
6809
6810 UT upper( 3UL );
6811 upper(0,0) = 1;
6812 upper(0,1) = -4;
6813 upper(0,2) = 7;
6814 upper(1,1) = 2;
6815 upper(2,2) = 3;
6816
6817 RT row1 = row( upper, 1UL );
6818
6819 if( row1[1] != 2 ) {
6820 std::ostringstream oss;
6821 oss << " Test: " << test_ << "\n"
6822 << " Error: Function call operator access failed\n"
6823 << " Details:\n"
6824 << " Result: " << row1[1] << "\n"
6825 << " Expected result: 2\n";
6826 throw std::runtime_error( oss.str() );
6827 }
6828
6829 RT::Iterator it( row1.begin() );
6830
6831 if( it == row1.end() || it->value() != 2 ) {
6832 std::ostringstream oss;
6833 oss << " Test: " << test_ << "\n"
6834 << " Error: Iterator access failed\n"
6835 << " Details:\n"
6836 << " Result: " << it->value() << "\n"
6837 << " Expected result: 2\n";
6838 throw std::runtime_error( oss.str() );
6839 }
6840
6841 row1[1] = -5;
6842
6843 if( row1[0] != 0 || row1[1] != -5 || row1[2] != 0 ) {
6844 std::ostringstream oss;
6845 oss << " Test: " << test_ << "\n"
6846 << " Error: Row access failed\n"
6847 << " Details:\n"
6848 << " Result:\n" << row1 << "\n"
6849 << " Expected result:\n( 0 -5 0 )\n";
6850 throw std::runtime_error( oss.str() );
6851 }
6852
6853 if( upper(0,0) != 1 || upper(0,1) != -4 || upper(0,2) != 7 ||
6854 upper(1,0) != 0 || upper(1,1) != -5 || upper(1,2) != 0 ||
6855 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 3 ) {
6856 std::ostringstream oss;
6857 oss << " Test: " << test_ << "\n"
6858 << " Error: Row access failed\n"
6859 << " Details:\n"
6860 << " Result:\n" << upper << "\n"
6861 << " Expected result:\n( 1 -4 7 )\n( 0 -5 0 )\n( 0 0 3 )\n";
6862 throw std::runtime_error( oss.str() );
6863 }
6864
6865 reset( row1 );
6866
6867 if( row1[0] != 0 || row1[1] != 0 || row1[2] != 0 ) {
6868 std::ostringstream oss;
6869 oss << " Test: " << test_ << "\n"
6870 << " Error: Row reset failed\n"
6871 << " Details:\n"
6872 << " Result:\n" << row1 << "\n"
6873 << " Expected result:\n( 0 0 0 )\n";
6874 throw std::runtime_error( oss.str() );
6875 }
6876
6877 if( upper(0,0) != 1 || upper(0,1) != -4 || upper(0,2) != 7 ||
6878 upper(1,0) != 0 || upper(1,1) != 0 || upper(1,2) != 0 ||
6879 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 3 ) {
6880 std::ostringstream oss;
6881 oss << " Test: " << test_ << "\n"
6882 << " Error: Row reset failed\n"
6883 << " Details:\n"
6884 << " Result:\n" << upper << "\n"
6885 << " Expected result:\n( 1 -4 7 )\n( 0 0 0 )\n( 0 0 3 )\n";
6886 throw std::runtime_error( oss.str() );
6887 }
6888 }
6889
6890
6891 //=====================================================================================
6892 // Column-major general tests
6893 //=====================================================================================
6894
6895 {
6896 test_ = "Column-major row() function";
6897
6898 using RT = blaze::Row<OUT>;
6899
6900 OUT upper( 3UL );
6901 upper(0,0) = 1;
6902 upper(0,1) = -4;
6903 upper(0,2) = 7;
6904 upper(1,1) = 2;
6905 upper(2,2) = 3;
6906
6907 RT row1 = row( upper, 1UL );
6908
6909 if( row1[1] != 2 ) {
6910 std::ostringstream oss;
6911 oss << " Test: " << test_ << "\n"
6912 << " Error: Function call operator access failed\n"
6913 << " Details:\n"
6914 << " Result: " << row1[1] << "\n"
6915 << " Expected result: 2\n";
6916 throw std::runtime_error( oss.str() );
6917 }
6918
6919 RT::Iterator it( row1.begin() );
6920
6921 if( it == row1.end() || it->value() != 2 ) {
6922 std::ostringstream oss;
6923 oss << " Test: " << test_ << "\n"
6924 << " Error: Iterator access failed\n"
6925 << " Details:\n"
6926 << " Result: " << it->value() << "\n"
6927 << " Expected result: 2\n";
6928 throw std::runtime_error( oss.str() );
6929 }
6930
6931 row1[1] = -5;
6932
6933 if( row1[0] != 0 || row1[1] != -5 || row1[2] != 0 ) {
6934 std::ostringstream oss;
6935 oss << " Test: " << test_ << "\n"
6936 << " Error: Row access failed\n"
6937 << " Details:\n"
6938 << " Result:\n" << row1 << "\n"
6939 << " Expected result:\n( 0 -5 0 )\n";
6940 throw std::runtime_error( oss.str() );
6941 }
6942
6943 if( upper(0,0) != 1 || upper(0,1) != -4 || upper(0,2) != 7 ||
6944 upper(1,0) != 0 || upper(1,1) != -5 || upper(1,2) != 0 ||
6945 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 3 ) {
6946 std::ostringstream oss;
6947 oss << " Test: " << test_ << "\n"
6948 << " Error: Row access failed\n"
6949 << " Details:\n"
6950 << " Result:\n" << upper << "\n"
6951 << " Expected result:\n( 1 -4 7 )\n( 0 -5 0 )\n( 0 0 3 )\n";
6952 throw std::runtime_error( oss.str() );
6953 }
6954
6955 reset( row1 );
6956
6957 if( row1[0] != 0 || row1[1] != 0 || row1[2] != 0 ) {
6958 std::ostringstream oss;
6959 oss << " Test: " << test_ << "\n"
6960 << " Error: Row reset failed\n"
6961 << " Details:\n"
6962 << " Result:\n" << row1 << "\n"
6963 << " Expected result:\n( 0 0 0 )\n";
6964 throw std::runtime_error( oss.str() );
6965 }
6966
6967 if( upper(0,0) != 1 || upper(0,1) != -4 || upper(0,2) != 7 ||
6968 upper(1,0) != 0 || upper(1,1) != 0 || upper(1,2) != 0 ||
6969 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 3 ) {
6970 std::ostringstream oss;
6971 oss << " Test: " << test_ << "\n"
6972 << " Error: Row reset failed\n"
6973 << " Details:\n"
6974 << " Result:\n" << upper << "\n"
6975 << " Expected result:\n( 1 -4 7 )\n( 0 0 0 )\n( 0 0 3 )\n";
6976 throw std::runtime_error( oss.str() );
6977 }
6978 }
6979 }
6980 //*************************************************************************************************
6981
6982
6983 //*************************************************************************************************
6984 /*!\brief Test of the \c column() function with the UpperMatrix specialization.
6985 //
6986 // \return void
6987 // \exception std::runtime_error Error detected.
6988 //
6989 // This function performs a test of the \c column() function with the UpperMatrix
6990 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
6991 */
testColumn()6992 void SparseTest::testColumn()
6993 {
6994 //=====================================================================================
6995 // Row-major general tests
6996 //=====================================================================================
6997
6998 {
6999 test_ = "Row-major column() function";
7000
7001 using CT = blaze::Column<UT>;
7002
7003 UT upper( 3UL );
7004 upper(0,0) = 1;
7005 upper(0,1) = -4;
7006 upper(0,2) = 7;
7007 upper(1,1) = 2;
7008 upper(2,2) = 3;
7009
7010 CT col1 = column( upper, 1UL );
7011
7012 if( col1[1] != 2 ) {
7013 std::ostringstream oss;
7014 oss << " Test: " << test_ << "\n"
7015 << " Error: Function call operator access failed\n"
7016 << " Details:\n"
7017 << " Result: " << col1[1] << "\n"
7018 << " Expected result: 2\n";
7019 throw std::runtime_error( oss.str() );
7020 }
7021
7022 CT::Iterator it( col1.begin() );
7023
7024 if( it == col1.end() || it->value() != -4 ) {
7025 std::ostringstream oss;
7026 oss << " Test: " << test_ << "\n"
7027 << " Error: Iterator access failed\n"
7028 << " Details:\n"
7029 << " Result: " << it->value() << "\n"
7030 << " Expected result: -4\n";
7031 throw std::runtime_error( oss.str() );
7032 }
7033
7034 col1[1] = -5;
7035
7036 if( col1[0] != -4 || col1[1] != -5 || col1[2] != 0 ) {
7037 std::ostringstream oss;
7038 oss << " Test: " << test_ << "\n"
7039 << " Error: Column access failed\n"
7040 << " Details:\n"
7041 << " Result:\n" << col1 << "\n"
7042 << " Expected result:\n( -4 -5 0 )\n";
7043 throw std::runtime_error( oss.str() );
7044 }
7045
7046 if( upper(0,0) != 1 || upper(0,1) != -4 || upper(0,2) != 7 ||
7047 upper(1,0) != 0 || upper(1,1) != -5 || upper(1,2) != 0 ||
7048 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 3 ) {
7049 std::ostringstream oss;
7050 oss << " Test: " << test_ << "\n"
7051 << " Error: Column access failed\n"
7052 << " Details:\n"
7053 << " Result:\n" << upper << "\n"
7054 << " Expected result:\n( 1 -4 7 )\n( 0 -5 0 )\n( 0 0 3 )\n";
7055 throw std::runtime_error( oss.str() );
7056 }
7057
7058 reset( col1 );
7059
7060 if( col1[0] != 0 || col1[1] != 0 || col1[2] != 0 ) {
7061 std::ostringstream oss;
7062 oss << " Test: " << test_ << "\n"
7063 << " Error: Column reset failed\n"
7064 << " Details:\n"
7065 << " Result:\n" << col1 << "\n"
7066 << " Expected result:\n( 0 0 0 )\n";
7067 throw std::runtime_error( oss.str() );
7068 }
7069
7070 if( upper(0,0) != 1 || upper(0,1) != 0 || upper(0,2) != 7 ||
7071 upper(1,0) != 0 || upper(1,1) != 0 || upper(1,2) != 0 ||
7072 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 3 ) {
7073 std::ostringstream oss;
7074 oss << " Test: " << test_ << "\n"
7075 << " Error: Column reset failed\n"
7076 << " Details:\n"
7077 << " Result:\n" << upper << "\n"
7078 << " Expected result:\n( 1 0 7 )\n( 0 0 0 )\n( 0 0 3 )\n";
7079 throw std::runtime_error( oss.str() );
7080 }
7081 }
7082
7083
7084 //=====================================================================================
7085 // Column-major general tests
7086 //=====================================================================================
7087
7088 {
7089 test_ = "Column-major column() function";
7090
7091 using CT = blaze::Column<OUT>;
7092
7093 OUT upper( 3UL );
7094 upper(0,0) = 1;
7095 upper(0,1) = -4;
7096 upper(0,2) = 7;
7097 upper(1,1) = 2;
7098 upper(2,2) = 3;
7099
7100 CT col1 = column( upper, 1UL );
7101
7102 if( col1[1] != 2 ) {
7103 std::ostringstream oss;
7104 oss << " Test: " << test_ << "\n"
7105 << " Error: Function call operator access failed\n"
7106 << " Details:\n"
7107 << " Result: " << col1[1] << "\n"
7108 << " Expected result: 2\n";
7109 throw std::runtime_error( oss.str() );
7110 }
7111
7112 CT::Iterator it( col1.begin() );
7113
7114 if( it == col1.end() || it->value() != -4 ) {
7115 std::ostringstream oss;
7116 oss << " Test: " << test_ << "\n"
7117 << " Error: Iterator access failed\n"
7118 << " Details:\n"
7119 << " Result: " << it->value() << "\n"
7120 << " Expected result: -4\n";
7121 throw std::runtime_error( oss.str() );
7122 }
7123
7124 col1[1] = -5;
7125
7126 if( col1[0] != -4 || col1[1] != -5 || col1[2] != 0 ) {
7127 std::ostringstream oss;
7128 oss << " Test: " << test_ << "\n"
7129 << " Error: Column access failed\n"
7130 << " Details:\n"
7131 << " Result:\n" << col1 << "\n"
7132 << " Expected result:\n( -4 -5 0 )\n";
7133 throw std::runtime_error( oss.str() );
7134 }
7135
7136 if( upper(0,0) != 1 || upper(0,1) != -4 || upper(0,2) != 7 ||
7137 upper(1,0) != 0 || upper(1,1) != -5 || upper(1,2) != 0 ||
7138 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 3 ) {
7139 std::ostringstream oss;
7140 oss << " Test: " << test_ << "\n"
7141 << " Error: Column access failed\n"
7142 << " Details:\n"
7143 << " Result:\n" << upper << "\n"
7144 << " Expected result:\n( 1 -4 7 )\n( 0 -5 0 )\n( 0 0 3 )\n";
7145 throw std::runtime_error( oss.str() );
7146 }
7147
7148 reset( col1 );
7149
7150 if( col1[0] != 0 || col1[1] != 0 || col1[2] != 0 ) {
7151 std::ostringstream oss;
7152 oss << " Test: " << test_ << "\n"
7153 << " Error: Column reset failed\n"
7154 << " Details:\n"
7155 << " Result:\n" << col1 << "\n"
7156 << " Expected result:\n( 0 0 0 )\n";
7157 throw std::runtime_error( oss.str() );
7158 }
7159
7160 if( upper(0,0) != 1 || upper(0,1) != 0 || upper(0,2) != 7 ||
7161 upper(1,0) != 0 || upper(1,1) != 0 || upper(1,2) != 0 ||
7162 upper(2,0) != 0 || upper(2,1) != 0 || upper(2,2) != 3 ) {
7163 std::ostringstream oss;
7164 oss << " Test: " << test_ << "\n"
7165 << " Error: Column reset failed\n"
7166 << " Details:\n"
7167 << " Result:\n" << upper << "\n"
7168 << " Expected result:\n( 1 0 7 )\n( 0 0 0 )\n( 0 0 3 )\n";
7169 throw std::runtime_error( oss.str() );
7170 }
7171 }
7172 }
7173 //*************************************************************************************************
7174
7175 } // namespace uppermatrix
7176
7177
7178 } // namespace adaptors
7179
7180 } // namespace mathtest
7181
7182 } // namespace blazetest
7183
7184
7185
7186
7187 //=================================================================================================
7188 //
7189 // MAIN FUNCTION
7190 //
7191 //=================================================================================================
7192
7193 //*************************************************************************************************
main()7194 int main()
7195 {
7196 std::cout << " Running UpperMatrix sparse test (part 2)..." << std::endl;
7197
7198 try
7199 {
7200 RUN_UPPERMATRIX_SPARSE_TEST;
7201 }
7202 catch( std::exception& ex ) {
7203 std::cerr << "\n\n ERROR DETECTED during UpperMatrix sparse test (part 2):\n"
7204 << ex.what() << "\n";
7205 return EXIT_FAILURE;
7206 }
7207
7208 return EXIT_SUCCESS;
7209 }
7210 //*************************************************************************************************
7211