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