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