1 //=================================================================================================
2 /*!
3 // \file src/mathtest/views/submatrix/SparseTest2.cpp
4 // \brief Source file for the Submatrix sparse test (part 2)
5 //
6 // Copyright (C) 2012-2020 Klaus Iglberger - All Rights Reserved
7 //
8 // This file is part of the Blaze library. You can redistribute it and/or modify it under
9 // the terms of the New (Revised) BSD License. Redistribution and use in source and binary
10 // forms, with or without modification, are permitted provided that the following conditions
11 // are met:
12 //
13 // 1. Redistributions of source code must retain the above copyright notice, this list of
14 // conditions and the following disclaimer.
15 // 2. Redistributions in binary form must reproduce the above copyright notice, this list
16 // of conditions and the following disclaimer in the documentation and/or other materials
17 // provided with the distribution.
18 // 3. Neither the names of the Blaze development group nor the names of its contributors
19 // may be used to endorse or promote products derived from this software without specific
20 // prior written permission.
21 //
22 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
23 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24 // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
25 // SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
27 // TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
28 // BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 // CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
30 // ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
31 // DAMAGE.
32 */
33 //=================================================================================================
34
35
36 //*************************************************************************************************
37 // Includes
38 //*************************************************************************************************
39
40 #include <cstdlib>
41 #include <iostream>
42 #include <blaze/math/Views.h>
43 #include <blazetest/mathtest/views/submatrix/SparseTest.h>
44
45 #ifdef BLAZE_USE_HPX_THREADS
46 # include <hpx/hpx_main.hpp>
47 #endif
48
49
50 namespace blazetest {
51
52 namespace mathtest {
53
54 namespace views {
55
56 namespace submatrix {
57
58 //=================================================================================================
59 //
60 // CONSTRUCTORS
61 //
62 //=================================================================================================
63
64 //*************************************************************************************************
65 /*!\brief Constructor for the Submatrix sparse test.
66 //
67 // \exception std::runtime_error Operation error detected.
68 */
SparseTest()69 SparseTest::SparseTest()
70 : mat_ ( 5UL, 4UL )
71 , tmat_( 4UL, 5UL )
72 {
73 testScaling();
74 testFunctionCall();
75 testIterator();
76 testNonZeros();
77 testReset();
78 testClear();
79 testReserve();
80 testTrim();
81 testSet();
82 testInsert();
83 testAppend();
84 testErase();
85 testFind();
86 testLowerBound();
87 testUpperBound();
88 testTranspose();
89 testCTranspose();
90 testIsDefault();
91 testIsSame();
92 testSubmatrix();
93 testRow();
94 testRows();
95 testColumn();
96 testColumns();
97 testBand();
98 }
99 //*************************************************************************************************
100
101
102
103
104 //=================================================================================================
105 //
106 // TEST FUNCTIONS
107 //
108 //=================================================================================================
109
110 //*************************************************************************************************
111 /*!\brief Test of all Submatrix (self-)scaling operations.
112 //
113 // \return void
114 // \exception std::runtime_error Error detected.
115 //
116 // This function performs a test of all available ways to scale an instance of the Submatrix
117 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
118 */
testScaling()119 void SparseTest::testScaling()
120 {
121 //=====================================================================================
122 // Row-major self-scaling (M*=s)
123 //=====================================================================================
124
125 {
126 test_ = "Row-major self-scaling (M*=s) (2x3)";
127
128 initialize();
129
130 SMT sm = blaze::submatrix( mat_, 2UL, 0UL, 2UL, 3UL );
131
132 sm *= 3;
133
134 checkRows ( sm , 2UL );
135 checkColumns ( sm , 3UL );
136 checkNonZeros( sm , 4UL );
137 checkRows ( mat_, 5UL );
138 checkColumns ( mat_, 4UL );
139 checkNonZeros( mat_, 10UL );
140
141 if( sm(0,0) != -6 || sm(0,1) != 0 || sm(0,2) != -9 ||
142 sm(1,0) != 0 || sm(1,1) != 12 || sm(1,2) != 15 ) {
143 std::ostringstream oss;
144 oss << " Test: " << test_ << "\n"
145 << " Error: Failed self-scaling operation\n"
146 << " Details:\n"
147 << " Result:\n" << sm << "\n"
148 << " Expected result:\n( -6 0 -9 )\n( 0 12 15 )\n";
149 throw std::runtime_error( oss.str() );
150 }
151
152 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
153 mat_(1,0) != 0 || mat_(1,1) != 1 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
154 mat_(2,0) != -6 || mat_(2,1) != 0 || mat_(2,2) != -9 || mat_(2,3) != 0 ||
155 mat_(3,0) != 0 || mat_(3,1) != 12 || mat_(3,2) != 15 || mat_(3,3) != -6 ||
156 mat_(4,0) != 7 || mat_(4,1) != -8 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
157 std::ostringstream oss;
158 oss << " Test: " << test_ << "\n"
159 << " Error: Failed self-scaling operation\n"
160 << " Details:\n"
161 << " Result:\n" << mat_ << "\n"
162 << " Expected result:\n( 0 0 0 0 )\n"
163 "( 0 1 0 0 )\n"
164 "( -6 0 -9 0 )\n"
165 "( 0 12 15 -6 )\n"
166 "( 7 -8 9 10 )\n";
167 throw std::runtime_error( oss.str() );
168 }
169 }
170
171 {
172 test_ = "Row-major self-scaling (M*=s) (3x2)";
173
174 initialize();
175
176 SMT sm = blaze::submatrix( mat_, 2UL, 0UL, 3UL, 2UL );
177
178 sm *= 3;
179
180 checkRows ( sm , 3UL );
181 checkColumns ( sm , 2UL );
182 checkNonZeros( sm , 4UL );
183 checkRows ( mat_, 5UL );
184 checkColumns ( mat_, 4UL );
185 checkNonZeros( mat_, 10UL );
186
187 if( sm(0,0) != -6 || sm(0,1) != 0 ||
188 sm(1,0) != 0 || sm(1,1) != 12 ||
189 sm(2,0) != 21 || sm(2,1) != -24 ) {
190 std::ostringstream oss;
191 oss << " Test: " << test_ << "\n"
192 << " Error: Failed self-scaling operation\n"
193 << " Details:\n"
194 << " Result:\n" << sm << "\n"
195 << " Expected result:\n( -6 0 )\n( 0 12 )\n( 21 -24 )\n";
196 throw std::runtime_error( oss.str() );
197 }
198
199 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
200 mat_(1,0) != 0 || mat_(1,1) != 1 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
201 mat_(2,0) != -6 || mat_(2,1) != 0 || mat_(2,2) != -3 || mat_(2,3) != 0 ||
202 mat_(3,0) != 0 || mat_(3,1) != 12 || mat_(3,2) != 5 || mat_(3,3) != -6 ||
203 mat_(4,0) != 21 || mat_(4,1) != -24 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
204 std::ostringstream oss;
205 oss << " Test: " << test_ << "\n"
206 << " Error: Failed self-scaling operation\n"
207 << " Details:\n"
208 << " Result:\n" << mat_ << "\n"
209 << " Expected result:\n( 0 0 0 0 )\n"
210 "( 0 1 0 0 )\n"
211 "( -6 0 -3 0 )\n"
212 "( 0 12 5 -6 )\n"
213 "( 21 -24 9 10 )\n";
214 throw std::runtime_error( oss.str() );
215 }
216 }
217
218
219 //=====================================================================================
220 // Row-major self-scaling (M=M*s)
221 //=====================================================================================
222
223 {
224 test_ = "Row-major self-scaling (M=M*s) (2x3)";
225
226 initialize();
227
228 SMT sm = blaze::submatrix( mat_, 2UL, 0UL, 2UL, 3UL );
229
230 sm = sm * 3;
231
232 checkRows ( sm , 2UL );
233 checkColumns ( sm , 3UL );
234 checkNonZeros( sm , 4UL );
235 checkRows ( mat_, 5UL );
236 checkColumns ( mat_, 4UL );
237 checkNonZeros( mat_, 10UL );
238
239 if( sm(0,0) != -6 || sm(0,1) != 0 || sm(0,2) != -9 ||
240 sm(1,0) != 0 || sm(1,1) != 12 || sm(1,2) != 15 ) {
241 std::ostringstream oss;
242 oss << " Test: " << test_ << "\n"
243 << " Error: Failed self-scaling operation\n"
244 << " Details:\n"
245 << " Result:\n" << sm << "\n"
246 << " Expected result:\n( -6 0 -9 )\n( 0 12 15 )\n";
247 throw std::runtime_error( oss.str() );
248 }
249
250 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
251 mat_(1,0) != 0 || mat_(1,1) != 1 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
252 mat_(2,0) != -6 || mat_(2,1) != 0 || mat_(2,2) != -9 || mat_(2,3) != 0 ||
253 mat_(3,0) != 0 || mat_(3,1) != 12 || mat_(3,2) != 15 || mat_(3,3) != -6 ||
254 mat_(4,0) != 7 || mat_(4,1) != -8 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
255 std::ostringstream oss;
256 oss << " Test: " << test_ << "\n"
257 << " Error: Failed self-scaling operation\n"
258 << " Details:\n"
259 << " Result:\n" << mat_ << "\n"
260 << " Expected result:\n( 0 0 0 0 )\n"
261 "( 0 1 0 0 )\n"
262 "( -6 0 -9 0 )\n"
263 "( 0 12 15 -6 )\n"
264 "( 7 -8 9 10 )\n";
265 throw std::runtime_error( oss.str() );
266 }
267 }
268
269 {
270 test_ = "Row-major self-scaling (M=M*s) (3x2)";
271
272 initialize();
273
274 SMT sm = blaze::submatrix( mat_, 2UL, 0UL, 3UL, 2UL );
275
276 sm = sm * 3;
277
278 checkRows ( sm , 3UL );
279 checkColumns ( sm , 2UL );
280 checkNonZeros( sm , 4UL );
281 checkRows ( mat_, 5UL );
282 checkColumns ( mat_, 4UL );
283 checkNonZeros( mat_, 10UL );
284
285 if( sm(0,0) != -6 || sm(0,1) != 0 ||
286 sm(1,0) != 0 || sm(1,1) != 12 ||
287 sm(2,0) != 21 || sm(2,1) != -24 ) {
288 std::ostringstream oss;
289 oss << " Test: " << test_ << "\n"
290 << " Error: Failed self-scaling operation\n"
291 << " Details:\n"
292 << " Result:\n" << sm << "\n"
293 << " Expected result:\n( -6 0 )\n( 0 12 )\n( 21 -24 )\n";
294 throw std::runtime_error( oss.str() );
295 }
296
297 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
298 mat_(1,0) != 0 || mat_(1,1) != 1 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
299 mat_(2,0) != -6 || mat_(2,1) != 0 || mat_(2,2) != -3 || mat_(2,3) != 0 ||
300 mat_(3,0) != 0 || mat_(3,1) != 12 || mat_(3,2) != 5 || mat_(3,3) != -6 ||
301 mat_(4,0) != 21 || mat_(4,1) != -24 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
302 std::ostringstream oss;
303 oss << " Test: " << test_ << "\n"
304 << " Error: Failed self-scaling operation\n"
305 << " Details:\n"
306 << " Result:\n" << mat_ << "\n"
307 << " Expected result:\n( 0 0 0 0 )\n"
308 "( 0 1 0 0 )\n"
309 "( -6 0 -3 0 )\n"
310 "( 0 12 5 -6 )\n"
311 "( 21 -24 9 10 )\n";
312 throw std::runtime_error( oss.str() );
313 }
314 }
315
316
317 //=====================================================================================
318 // Row-major self-scaling (M=s*M)
319 //=====================================================================================
320
321 {
322 test_ = "Row-major self-scaling (M=s*M) (2x3)";
323
324 initialize();
325
326 SMT sm = blaze::submatrix( mat_, 2UL, 0UL, 2UL, 3UL );
327
328 sm = 3 * sm;
329
330 checkRows ( sm , 2UL );
331 checkColumns ( sm , 3UL );
332 checkNonZeros( sm , 4UL );
333 checkRows ( mat_, 5UL );
334 checkColumns ( mat_, 4UL );
335 checkNonZeros( mat_, 10UL );
336
337 if( sm(0,0) != -6 || sm(0,1) != 0 || sm(0,2) != -9 ||
338 sm(1,0) != 0 || sm(1,1) != 12 || sm(1,2) != 15 ) {
339 std::ostringstream oss;
340 oss << " Test: " << test_ << "\n"
341 << " Error: Failed self-scaling operation\n"
342 << " Details:\n"
343 << " Result:\n" << sm << "\n"
344 << " Expected result:\n( -6 0 -9 )\n( 0 12 15 )\n";
345 throw std::runtime_error( oss.str() );
346 }
347
348 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
349 mat_(1,0) != 0 || mat_(1,1) != 1 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
350 mat_(2,0) != -6 || mat_(2,1) != 0 || mat_(2,2) != -9 || mat_(2,3) != 0 ||
351 mat_(3,0) != 0 || mat_(3,1) != 12 || mat_(3,2) != 15 || mat_(3,3) != -6 ||
352 mat_(4,0) != 7 || mat_(4,1) != -8 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
353 std::ostringstream oss;
354 oss << " Test: " << test_ << "\n"
355 << " Error: Failed self-scaling operation\n"
356 << " Details:\n"
357 << " Result:\n" << mat_ << "\n"
358 << " Expected result:\n( 0 0 0 0 )\n"
359 "( 0 1 0 0 )\n"
360 "( -6 0 -9 0 )\n"
361 "( 0 12 15 -6 )\n"
362 "( 7 -8 9 10 )\n";
363 throw std::runtime_error( oss.str() );
364 }
365 }
366
367 {
368 test_ = "Row-major self-scaling (M=s*M) (3x2)";
369
370 initialize();
371
372 SMT sm = blaze::submatrix( mat_, 2UL, 0UL, 3UL, 2UL );
373
374 sm = 3 * sm;
375
376 checkRows ( sm , 3UL );
377 checkColumns ( sm , 2UL );
378 checkNonZeros( sm , 4UL );
379 checkRows ( mat_, 5UL );
380 checkColumns ( mat_, 4UL );
381 checkNonZeros( mat_, 10UL );
382
383 if( sm(0,0) != -6 || sm(0,1) != 0 ||
384 sm(1,0) != 0 || sm(1,1) != 12 ||
385 sm(2,0) != 21 || sm(2,1) != -24 ) {
386 std::ostringstream oss;
387 oss << " Test: " << test_ << "\n"
388 << " Error: Failed self-scaling operation\n"
389 << " Details:\n"
390 << " Result:\n" << sm << "\n"
391 << " Expected result:\n( -6 0 )\n( 0 12 )\n( 21 -24 )\n";
392 throw std::runtime_error( oss.str() );
393 }
394
395 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
396 mat_(1,0) != 0 || mat_(1,1) != 1 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
397 mat_(2,0) != -6 || mat_(2,1) != 0 || mat_(2,2) != -3 || mat_(2,3) != 0 ||
398 mat_(3,0) != 0 || mat_(3,1) != 12 || mat_(3,2) != 5 || mat_(3,3) != -6 ||
399 mat_(4,0) != 21 || mat_(4,1) != -24 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
400 std::ostringstream oss;
401 oss << " Test: " << test_ << "\n"
402 << " Error: Failed self-scaling operation\n"
403 << " Details:\n"
404 << " Result:\n" << mat_ << "\n"
405 << " Expected result:\n( 0 0 0 0 )\n"
406 "( 0 1 0 0 )\n"
407 "( -6 0 -3 0 )\n"
408 "( 0 12 5 -6 )\n"
409 "( 21 -24 9 10 )\n";
410 throw std::runtime_error( oss.str() );
411 }
412 }
413
414
415 //=====================================================================================
416 // Row-major self-scaling (M/=s)
417 //=====================================================================================
418
419 {
420 test_ = "Row-major self-scaling (M/=s) (2x3)";
421
422 initialize();
423
424 SMT sm = blaze::submatrix( mat_, 2UL, 0UL, 2UL, 3UL );
425
426 sm /= 0.5;
427
428 checkRows ( sm , 2UL );
429 checkColumns ( sm , 3UL );
430 checkNonZeros( sm , 4UL );
431 checkRows ( mat_, 5UL );
432 checkColumns ( mat_, 4UL );
433 checkNonZeros( mat_, 10UL );
434
435 if( sm(0,0) != -4 || sm(0,1) != 0 || sm(0,2) != -6 ||
436 sm(1,0) != 0 || sm(1,1) != 8 || sm(1,2) != 10 ) {
437 std::ostringstream oss;
438 oss << " Test: " << test_ << "\n"
439 << " Error: Failed self-scaling operation\n"
440 << " Details:\n"
441 << " Result:\n" << sm << "\n"
442 << " Expected result:\n( -4 0 -6 )\n( 0 8 10 )\n";
443 throw std::runtime_error( oss.str() );
444 }
445
446 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
447 mat_(1,0) != 0 || mat_(1,1) != 1 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
448 mat_(2,0) != -4 || mat_(2,1) != 0 || mat_(2,2) != -6 || mat_(2,3) != 0 ||
449 mat_(3,0) != 0 || mat_(3,1) != 8 || mat_(3,2) != 10 || mat_(3,3) != -6 ||
450 mat_(4,0) != 7 || mat_(4,1) != -8 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
451 std::ostringstream oss;
452 oss << " Test: " << test_ << "\n"
453 << " Error: Failed self-scaling operation\n"
454 << " Details:\n"
455 << " Result:\n" << mat_ << "\n"
456 << " Expected result:\n( 0 0 0 0 )\n"
457 "( 0 1 0 0 )\n"
458 "( -4 0 -6 0 )\n"
459 "( 0 8 10 -6 )\n"
460 "( 7 -8 9 10 )\n";
461 throw std::runtime_error( oss.str() );
462 }
463 }
464
465 {
466 test_ = "Row-major self-scaling (M/=s) (3x2)";
467
468 initialize();
469
470 SMT sm = blaze::submatrix( mat_, 2UL, 0UL, 3UL, 2UL );
471
472 sm /= 0.5;
473
474 checkRows ( sm , 3UL );
475 checkColumns ( sm , 2UL );
476 checkNonZeros( sm , 4UL );
477 checkRows ( mat_, 5UL );
478 checkColumns ( mat_, 4UL );
479 checkNonZeros( mat_, 10UL );
480
481 if( sm(0,0) != -4 || sm(0,1) != 0 ||
482 sm(1,0) != 0 || sm(1,1) != 8 ||
483 sm(2,0) != 14 || sm(2,1) != -16 ) {
484 std::ostringstream oss;
485 oss << " Test: " << test_ << "\n"
486 << " Error: Failed self-scaling operation\n"
487 << " Details:\n"
488 << " Result:\n" << sm << "\n"
489 << " Expected result:\n( -4 0 )\n( 0 8 )\n( 14 -16 )\n";
490 throw std::runtime_error( oss.str() );
491 }
492
493 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
494 mat_(1,0) != 0 || mat_(1,1) != 1 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
495 mat_(2,0) != -4 || mat_(2,1) != 0 || mat_(2,2) != -3 || mat_(2,3) != 0 ||
496 mat_(3,0) != 0 || mat_(3,1) != 8 || mat_(3,2) != 5 || mat_(3,3) != -6 ||
497 mat_(4,0) != 14 || mat_(4,1) != -16 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
498 std::ostringstream oss;
499 oss << " Test: " << test_ << "\n"
500 << " Error: Failed self-scaling operation\n"
501 << " Details:\n"
502 << " Result:\n" << mat_ << "\n"
503 << " Expected result:\n( 0 0 0 0 )\n"
504 "( 0 1 0 0 )\n"
505 "( -4 0 -3 0 )\n"
506 "( 0 8 5 -6 )\n"
507 "( 14 -16 9 10 )\n";
508 throw std::runtime_error( oss.str() );
509 }
510 }
511
512
513 //=====================================================================================
514 // Row-major self-scaling (M=M/s)
515 //=====================================================================================
516
517 {
518 test_ = "Row-major self-scaling (M=M/s) (2x3)";
519
520 initialize();
521
522 SMT sm = blaze::submatrix( mat_, 2UL, 0UL, 2UL, 3UL );
523
524 sm = sm / 0.5;
525
526 checkRows ( sm , 2UL );
527 checkColumns ( sm , 3UL );
528 checkNonZeros( sm , 4UL );
529 checkRows ( mat_, 5UL );
530 checkColumns ( mat_, 4UL );
531 checkNonZeros( mat_, 10UL );
532
533 if( sm(0,0) != -4 || sm(0,1) != 0 || sm(0,2) != -6 ||
534 sm(1,0) != 0 || sm(1,1) != 8 || sm(1,2) != 10 ) {
535 std::ostringstream oss;
536 oss << " Test: " << test_ << "\n"
537 << " Error: Failed self-scaling operation\n"
538 << " Details:\n"
539 << " Result:\n" << sm << "\n"
540 << " Expected result:\n( -4 0 -6 )\n( 0 8 10 )\n";
541 throw std::runtime_error( oss.str() );
542 }
543
544 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
545 mat_(1,0) != 0 || mat_(1,1) != 1 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
546 mat_(2,0) != -4 || mat_(2,1) != 0 || mat_(2,2) != -6 || mat_(2,3) != 0 ||
547 mat_(3,0) != 0 || mat_(3,1) != 8 || mat_(3,2) != 10 || mat_(3,3) != -6 ||
548 mat_(4,0) != 7 || mat_(4,1) != -8 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
549 std::ostringstream oss;
550 oss << " Test: " << test_ << "\n"
551 << " Error: Failed self-scaling operation\n"
552 << " Details:\n"
553 << " Result:\n" << mat_ << "\n"
554 << " Expected result:\n( 0 0 0 0 )\n"
555 "( 0 1 0 0 )\n"
556 "( -4 0 -6 0 )\n"
557 "( 0 8 10 -6 )\n"
558 "( 7 -8 9 10 )\n";
559 throw std::runtime_error( oss.str() );
560 }
561 }
562
563 {
564 test_ = "Row-major self-scaling (M=M/s) (3x2)";
565
566 initialize();
567
568 SMT sm = blaze::submatrix( mat_, 2UL, 0UL, 3UL, 2UL );
569
570 sm = sm / 0.5;
571
572 checkRows ( sm , 3UL );
573 checkColumns ( sm , 2UL );
574 checkNonZeros( sm , 4UL );
575 checkRows ( mat_, 5UL );
576 checkColumns ( mat_, 4UL );
577 checkNonZeros( mat_, 10UL );
578
579 if( sm(0,0) != -4 || sm(0,1) != 0 ||
580 sm(1,0) != 0 || sm(1,1) != 8 ||
581 sm(2,0) != 14 || sm(2,1) != -16 ) {
582 std::ostringstream oss;
583 oss << " Test: " << test_ << "\n"
584 << " Error: Failed self-scaling operation\n"
585 << " Details:\n"
586 << " Result:\n" << sm << "\n"
587 << " Expected result:\n( -4 0 )\n( 0 8 )\n( 14 -16 )\n";
588 throw std::runtime_error( oss.str() );
589 }
590
591 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
592 mat_(1,0) != 0 || mat_(1,1) != 1 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
593 mat_(2,0) != -4 || mat_(2,1) != 0 || mat_(2,2) != -3 || mat_(2,3) != 0 ||
594 mat_(3,0) != 0 || mat_(3,1) != 8 || mat_(3,2) != 5 || mat_(3,3) != -6 ||
595 mat_(4,0) != 14 || mat_(4,1) != -16 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
596 std::ostringstream oss;
597 oss << " Test: " << test_ << "\n"
598 << " Error: Failed self-scaling operation\n"
599 << " Details:\n"
600 << " Result:\n" << mat_ << "\n"
601 << " Expected result:\n( 0 0 0 0 )\n"
602 "( 0 1 0 0 )\n"
603 "( -4 0 -3 0 )\n"
604 "( 0 8 5 -6 )\n"
605 "( 14 -16 9 10 )\n";
606 throw std::runtime_error( oss.str() );
607 }
608 }
609
610
611 //=====================================================================================
612 // Row-major Submatrix::scale()
613 //=====================================================================================
614
615 {
616 test_ = "Row-major Submatrix::scale()";
617
618 initialize();
619
620 // Initialization check
621 SMT sm = blaze::submatrix( mat_, 2UL, 1UL, 2UL, 2UL );
622
623 checkRows ( sm, 2UL );
624 checkColumns ( sm, 2UL );
625 checkNonZeros( sm, 3UL );
626 checkNonZeros( sm, 0UL, 1UL );
627 checkNonZeros( sm, 1UL, 2UL );
628
629 if( sm(0,0) != 0 || sm(0,1) != -3 ||
630 sm(1,0) != 4 || sm(1,1) != 5 ) {
631 std::ostringstream oss;
632 oss << " Test: " << test_ << "\n"
633 << " Error: Initialization failed\n"
634 << " Details:\n"
635 << " Result:\n" << sm << "\n"
636 << " Expected result:\n( 0 -3 )\n( 4 5 )\n";
637 throw std::runtime_error( oss.str() );
638 }
639
640 // Integral scaling of the matrix
641 sm.scale( 2 );
642
643 checkRows ( sm, 2UL );
644 checkColumns ( sm, 2UL );
645 checkNonZeros( sm, 3UL );
646 checkNonZeros( sm, 0UL, 1UL );
647 checkNonZeros( sm, 1UL, 2UL );
648
649 if( sm(0,0) != 0 || sm(0,1) != -6 ||
650 sm(1,0) != 8 || sm(1,1) != 10 ) {
651 std::ostringstream oss;
652 oss << " Test: " << test_ << "\n"
653 << " Error: Integral scale operation failed\n"
654 << " Details:\n"
655 << " Result:\n" << sm << "\n"
656 << " Expected result:\n( 0 -6 )\n( 8 10 )\n";
657 throw std::runtime_error( oss.str() );
658 }
659
660 // Floating point scaling of the matrix
661 sm.scale( 0.5 );
662
663 checkRows ( sm, 2UL );
664 checkColumns ( sm, 2UL );
665 checkNonZeros( sm, 3UL );
666 checkNonZeros( sm, 0UL, 1UL );
667 checkNonZeros( sm, 1UL, 2UL );
668
669 if( sm(0,0) != 0 || sm(0,1) != -3 ||
670 sm(1,0) != 4 || sm(1,1) != 5 ) {
671 std::ostringstream oss;
672 oss << " Test: " << test_ << "\n"
673 << " Error: Floating point scale operation failed\n"
674 << " Details:\n"
675 << " Result:\n" << sm << "\n"
676 << " Expected result:\n( 0 -3 )\n( 4 5 )\n";
677 throw std::runtime_error( oss.str() );
678 }
679 }
680
681
682 //=====================================================================================
683 // Column-major self-scaling (M*=s)
684 //=====================================================================================
685
686 {
687 test_ = "Column-major self-scaling (M*=s) (3x2)";
688
689 initialize();
690
691 OSMT sm = blaze::submatrix( tmat_, 0UL, 2UL, 3UL, 2UL );
692
693 sm *= 3;
694
695 checkRows ( sm , 3UL );
696 checkColumns ( sm , 2UL );
697 checkNonZeros( sm , 4UL );
698 checkRows ( tmat_, 4UL );
699 checkColumns ( tmat_, 5UL );
700 checkNonZeros( tmat_, 10UL );
701
702 if( sm(0,0) != -6 || sm(0,1) != 0 ||
703 sm(1,0) != 0 || sm(1,1) != 12 ||
704 sm(2,0) != -9 || sm(2,1) != 15 ) {
705 std::ostringstream oss;
706 oss << " Test: " << test_ << "\n"
707 << " Error: Failed self-scaling operation\n"
708 << " Details:\n"
709 << " Result:\n" << sm << "\n"
710 << " Expected result:\n( -6 0 )\n( 0 12 )\n( -9 15 )\n";
711 throw std::runtime_error( oss.str() );
712 }
713
714 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != -6 || tmat_(0,3) != 0 || tmat_(0,4) != 7 ||
715 tmat_(1,0) != 0 || tmat_(1,1) != 1 || tmat_(1,2) != 0 || tmat_(1,3) != 12 || tmat_(1,4) != -8 ||
716 tmat_(2,0) != 0 || tmat_(2,1) != 0 || tmat_(2,2) != -9 || tmat_(2,3) != 15 || tmat_(2,4) != 9 ||
717 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
718 std::ostringstream oss;
719 oss << " Test: " << test_ << "\n"
720 << " Error: Failed self-scaling operation\n"
721 << " Details:\n"
722 << " Result:\n" << tmat_ << "\n"
723 << " Expected result:\n( 0 0 -6 0 7 )\n"
724 "( 0 1 0 12 -8 )\n"
725 "( 0 0 -9 15 9 )\n"
726 "( 0 0 0 -6 10 )\n";
727 throw std::runtime_error( oss.str() );
728 }
729 }
730
731 {
732 test_ = "Column-major self-scaling (M*=s) (2x3)";
733
734 initialize();
735
736 OSMT sm = blaze::submatrix( tmat_, 0UL, 2UL, 2UL, 3UL );
737
738 sm *= 3;
739
740 checkRows ( sm , 2UL );
741 checkColumns ( sm , 3UL );
742 checkNonZeros( sm , 4UL );
743 checkRows ( tmat_, 4UL );
744 checkColumns ( tmat_, 5UL );
745 checkNonZeros( tmat_, 10UL );
746
747 if( sm(0,0) != -6 || sm(0,1) != 0 || sm(0,2) != 21 ||
748 sm(1,0) != 0 || sm(1,1) != 12 || sm(1,2) != -24 ) {
749 std::ostringstream oss;
750 oss << " Test: " << test_ << "\n"
751 << " Error: Failed self-scaling operation\n"
752 << " Details:\n"
753 << " Result:\n" << sm << "\n"
754 << " Expected result:\n( -6 0 21 )\n( 0 12 -24 )\n";
755 throw std::runtime_error( oss.str() );
756 }
757
758 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != -6 || tmat_(0,3) != 0 || tmat_(0,4) != 21 ||
759 tmat_(1,0) != 0 || tmat_(1,1) != 1 || tmat_(1,2) != 0 || tmat_(1,3) != 12 || tmat_(1,4) != -24 ||
760 tmat_(2,0) != 0 || tmat_(2,1) != 0 || tmat_(2,2) != -3 || tmat_(2,3) != 5 || tmat_(2,4) != 9 ||
761 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
762 std::ostringstream oss;
763 oss << " Test: " << test_ << "\n"
764 << " Error: Failed self-scaling operation\n"
765 << " Details:\n"
766 << " Result:\n" << tmat_ << "\n"
767 << " Expected result:\n( 0 0 -6 0 21 )\n"
768 "( 0 1 0 12 -24 )\n"
769 "( 0 0 -3 5 9 )\n"
770 "( 0 0 0 -6 10 )\n";
771 throw std::runtime_error( oss.str() );
772 }
773 }
774
775
776 //=====================================================================================
777 // Column-major self-scaling (M=M*s)
778 //=====================================================================================
779
780 {
781 test_ = "Column-major self-scaling (M=M*s) (3x2)";
782
783 initialize();
784
785 OSMT sm = blaze::submatrix( tmat_, 0UL, 2UL, 3UL, 2UL );
786
787 sm = sm * 3;
788
789 checkRows ( sm , 3UL );
790 checkColumns ( sm , 2UL );
791 checkNonZeros( sm , 4UL );
792 checkRows ( tmat_, 4UL );
793 checkColumns ( tmat_, 5UL );
794 checkNonZeros( tmat_, 10UL );
795
796 if( sm(0,0) != -6 || sm(0,1) != 0 ||
797 sm(1,0) != 0 || sm(1,1) != 12 ||
798 sm(2,0) != -9 || sm(2,1) != 15 ) {
799 std::ostringstream oss;
800 oss << " Test: " << test_ << "\n"
801 << " Error: Failed self-scaling operation\n"
802 << " Details:\n"
803 << " Result:\n" << sm << "\n"
804 << " Expected result:\n( -6 0 )\n( 0 12 )\n( -9 15 )\n";
805 throw std::runtime_error( oss.str() );
806 }
807
808 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != -6 || tmat_(0,3) != 0 || tmat_(0,4) != 7 ||
809 tmat_(1,0) != 0 || tmat_(1,1) != 1 || tmat_(1,2) != 0 || tmat_(1,3) != 12 || tmat_(1,4) != -8 ||
810 tmat_(2,0) != 0 || tmat_(2,1) != 0 || tmat_(2,2) != -9 || tmat_(2,3) != 15 || tmat_(2,4) != 9 ||
811 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
812 std::ostringstream oss;
813 oss << " Test: " << test_ << "\n"
814 << " Error: Failed self-scaling operation\n"
815 << " Details:\n"
816 << " Result:\n" << tmat_ << "\n"
817 << " Expected result:\n( 0 0 -6 0 7 )\n"
818 "( 0 1 0 12 -8 )\n"
819 "( 0 0 -9 15 9 )\n"
820 "( 0 0 0 -6 10 )\n";
821 throw std::runtime_error( oss.str() );
822 }
823 }
824
825 {
826 test_ = "Column-major self-scaling (M=M*s) (2x3)";
827
828 initialize();
829
830 OSMT sm = blaze::submatrix( tmat_, 0UL, 2UL, 2UL, 3UL );
831
832 sm = sm * 3;
833
834 checkRows ( sm , 2UL );
835 checkColumns ( sm , 3UL );
836 checkNonZeros( sm , 4UL );
837 checkRows ( tmat_, 4UL );
838 checkColumns ( tmat_, 5UL );
839 checkNonZeros( tmat_, 10UL );
840
841 if( sm(0,0) != -6 || sm(0,1) != 0 || sm(0,2) != 21 ||
842 sm(1,0) != 0 || sm(1,1) != 12 || sm(1,2) != -24 ) {
843 std::ostringstream oss;
844 oss << " Test: " << test_ << "\n"
845 << " Error: Failed self-scaling operation\n"
846 << " Details:\n"
847 << " Result:\n" << sm << "\n"
848 << " Expected result:\n( -6 0 21 )\n( 0 12 -24 )\n";
849 throw std::runtime_error( oss.str() );
850 }
851
852 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != -6 || tmat_(0,3) != 0 || tmat_(0,4) != 21 ||
853 tmat_(1,0) != 0 || tmat_(1,1) != 1 || tmat_(1,2) != 0 || tmat_(1,3) != 12 || tmat_(1,4) != -24 ||
854 tmat_(2,0) != 0 || tmat_(2,1) != 0 || tmat_(2,2) != -3 || tmat_(2,3) != 5 || tmat_(2,4) != 9 ||
855 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
856 std::ostringstream oss;
857 oss << " Test: " << test_ << "\n"
858 << " Error: Failed self-scaling operation\n"
859 << " Details:\n"
860 << " Result:\n" << tmat_ << "\n"
861 << " Expected result:\n( 0 0 -6 0 21 )\n"
862 "( 0 1 0 12 -24 )\n"
863 "( 0 0 -3 5 9 )\n"
864 "( 0 0 0 -6 10 )\n";
865 throw std::runtime_error( oss.str() );
866 }
867 }
868
869
870 //=====================================================================================
871 // Column-major self-scaling (M=s*M)
872 //=====================================================================================
873
874 {
875 test_ = "Column-major self-scaling (M=s*M) (3x2)";
876
877 initialize();
878
879 OSMT sm = blaze::submatrix( tmat_, 0UL, 2UL, 3UL, 2UL );
880
881 sm = 3 * sm;
882
883 checkRows ( sm , 3UL );
884 checkColumns ( sm , 2UL );
885 checkNonZeros( sm , 4UL );
886 checkRows ( tmat_, 4UL );
887 checkColumns ( tmat_, 5UL );
888 checkNonZeros( tmat_, 10UL );
889
890 if( sm(0,0) != -6 || sm(0,1) != 0 ||
891 sm(1,0) != 0 || sm(1,1) != 12 ||
892 sm(2,0) != -9 || sm(2,1) != 15 ) {
893 std::ostringstream oss;
894 oss << " Test: " << test_ << "\n"
895 << " Error: Failed self-scaling operation\n"
896 << " Details:\n"
897 << " Result:\n" << sm << "\n"
898 << " Expected result:\n( -6 0 )\n( 0 12 )\n( -9 15 )\n";
899 throw std::runtime_error( oss.str() );
900 }
901
902 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != -6 || tmat_(0,3) != 0 || tmat_(0,4) != 7 ||
903 tmat_(1,0) != 0 || tmat_(1,1) != 1 || tmat_(1,2) != 0 || tmat_(1,3) != 12 || tmat_(1,4) != -8 ||
904 tmat_(2,0) != 0 || tmat_(2,1) != 0 || tmat_(2,2) != -9 || tmat_(2,3) != 15 || tmat_(2,4) != 9 ||
905 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
906 std::ostringstream oss;
907 oss << " Test: " << test_ << "\n"
908 << " Error: Failed self-scaling operation\n"
909 << " Details:\n"
910 << " Result:\n" << tmat_ << "\n"
911 << " Expected result:\n( 0 0 -6 0 7 )\n"
912 "( 0 1 0 12 -8 )\n"
913 "( 0 0 -9 15 9 )\n"
914 "( 0 0 0 -6 10 )\n";
915 throw std::runtime_error( oss.str() );
916 }
917 }
918
919 {
920 test_ = "Column-major self-scaling (M=s*M) (2x3)";
921
922 initialize();
923
924 OSMT sm = blaze::submatrix( tmat_, 0UL, 2UL, 2UL, 3UL );
925
926 sm = 3 * sm;
927
928 checkRows ( sm , 2UL );
929 checkColumns ( sm , 3UL );
930 checkNonZeros( sm , 4UL );
931 checkRows ( tmat_, 4UL );
932 checkColumns ( tmat_, 5UL );
933 checkNonZeros( tmat_, 10UL );
934
935 if( sm(0,0) != -6 || sm(0,1) != 0 || sm(0,2) != 21 ||
936 sm(1,0) != 0 || sm(1,1) != 12 || sm(1,2) != -24 ) {
937 std::ostringstream oss;
938 oss << " Test: " << test_ << "\n"
939 << " Error: Failed self-scaling operation\n"
940 << " Details:\n"
941 << " Result:\n" << sm << "\n"
942 << " Expected result:\n( -6 0 21 )\n( 0 12 -24 )\n";
943 throw std::runtime_error( oss.str() );
944 }
945
946 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != -6 || tmat_(0,3) != 0 || tmat_(0,4) != 21 ||
947 tmat_(1,0) != 0 || tmat_(1,1) != 1 || tmat_(1,2) != 0 || tmat_(1,3) != 12 || tmat_(1,4) != -24 ||
948 tmat_(2,0) != 0 || tmat_(2,1) != 0 || tmat_(2,2) != -3 || tmat_(2,3) != 5 || tmat_(2,4) != 9 ||
949 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
950 std::ostringstream oss;
951 oss << " Test: " << test_ << "\n"
952 << " Error: Failed self-scaling operation\n"
953 << " Details:\n"
954 << " Result:\n" << tmat_ << "\n"
955 << " Expected result:\n( 0 0 -6 0 21 )\n"
956 "( 0 1 0 12 -24 )\n"
957 "( 0 0 -3 5 9 )\n"
958 "( 0 0 0 -6 10 )\n";
959 throw std::runtime_error( oss.str() );
960 }
961 }
962
963
964 //=====================================================================================
965 // Column-major self-scaling (M/=s)
966 //=====================================================================================
967
968 {
969 test_ = "Column-major self-scaling (M/=s) (3x2)";
970
971 initialize();
972
973 OSMT sm = blaze::submatrix( tmat_, 0UL, 2UL, 3UL, 2UL );
974
975 sm /= 0.5;
976
977 checkRows ( sm , 3UL );
978 checkColumns ( sm , 2UL );
979 checkNonZeros( sm , 4UL );
980 checkRows ( tmat_, 4UL );
981 checkColumns ( tmat_, 5UL );
982 checkNonZeros( tmat_, 10UL );
983
984 if( sm(0,0) != -4 || sm(0,1) != 0 ||
985 sm(1,0) != 0 || sm(1,1) != 8 ||
986 sm(2,0) != -6 || sm(2,1) != 10 ) {
987 std::ostringstream oss;
988 oss << " Test: " << test_ << "\n"
989 << " Error: Failed self-scaling operation\n"
990 << " Details:\n"
991 << " Result:\n" << sm << "\n"
992 << " Expected result:\n( -4 0 )\n( 0 8 )\n( -6 10 )\n";
993 throw std::runtime_error( oss.str() );
994 }
995
996 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != -4 || tmat_(0,3) != 0 || tmat_(0,4) != 7 ||
997 tmat_(1,0) != 0 || tmat_(1,1) != 1 || tmat_(1,2) != 0 || tmat_(1,3) != 8 || tmat_(1,4) != -8 ||
998 tmat_(2,0) != 0 || tmat_(2,1) != 0 || tmat_(2,2) != -6 || tmat_(2,3) != 10 || tmat_(2,4) != 9 ||
999 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
1000 std::ostringstream oss;
1001 oss << " Test: " << test_ << "\n"
1002 << " Error: Failed self-scaling operation\n"
1003 << " Details:\n"
1004 << " Result:\n" << tmat_ << "\n"
1005 << " Expected result:\n( 0 0 -4 0 7 )\n"
1006 "( 0 1 0 8 -8 )\n"
1007 "( 0 0 -6 10 9 )\n"
1008 "( 0 0 0 -6 10 )\n";
1009 throw std::runtime_error( oss.str() );
1010 }
1011 }
1012
1013 {
1014 test_ = "Column-major self-scaling (M/=s) (2x3)";
1015
1016 initialize();
1017
1018 OSMT sm = blaze::submatrix( tmat_, 0UL, 2UL, 2UL, 3UL );
1019
1020 sm /= 0.5;
1021
1022 checkRows ( sm , 2UL );
1023 checkColumns ( sm , 3UL );
1024 checkNonZeros( sm , 4UL );
1025 checkRows ( tmat_, 4UL );
1026 checkColumns ( tmat_, 5UL );
1027 checkNonZeros( tmat_, 10UL );
1028
1029 if( sm(0,0) != -4 || sm(0,1) != 0 || sm(0,2) != 14 ||
1030 sm(1,0) != 0 || sm(1,1) != 8 || sm(1,2) != -16 ) {
1031 std::ostringstream oss;
1032 oss << " Test: " << test_ << "\n"
1033 << " Error: Failed self-scaling operation\n"
1034 << " Details:\n"
1035 << " Result:\n" << sm << "\n"
1036 << " Expected result:\n( -4 0 14 )\n( 0 8 -16 )\n";
1037 throw std::runtime_error( oss.str() );
1038 }
1039
1040 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != -4 || tmat_(0,3) != 0 || tmat_(0,4) != 14 ||
1041 tmat_(1,0) != 0 || tmat_(1,1) != 1 || tmat_(1,2) != 0 || tmat_(1,3) != 8 || tmat_(1,4) != -16 ||
1042 tmat_(2,0) != 0 || tmat_(2,1) != 0 || tmat_(2,2) != -3 || tmat_(2,3) != 5 || tmat_(2,4) != 9 ||
1043 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
1044 std::ostringstream oss;
1045 oss << " Test: " << test_ << "\n"
1046 << " Error: Failed self-scaling operation\n"
1047 << " Details:\n"
1048 << " Result:\n" << tmat_ << "\n"
1049 << " Expected result:\n( 0 0 -4 0 14 )\n"
1050 "( 0 1 0 8 -16 )\n"
1051 "( 0 0 -3 5 9 )\n"
1052 "( 0 0 0 -6 10 )\n";
1053 throw std::runtime_error( oss.str() );
1054 }
1055 }
1056
1057
1058 //=====================================================================================
1059 // Column-major Submatrix::scale()
1060 //=====================================================================================
1061
1062 {
1063 test_ = "Column-major Submatrix::scale()";
1064
1065 initialize();
1066
1067 // Initialization check
1068 OSMT sm = blaze::submatrix( tmat_, 1UL, 2UL, 2UL, 2UL );
1069
1070 checkRows ( sm, 2UL );
1071 checkColumns ( sm, 2UL );
1072 checkNonZeros( sm, 3UL );
1073 checkNonZeros( sm, 0UL, 1UL );
1074 checkNonZeros( sm, 1UL, 2UL );
1075
1076 if( sm(0,0) != 0 || sm(0,1) != 4 ||
1077 sm(1,0) != -3 || sm(1,1) != 5 ) {
1078 std::ostringstream oss;
1079 oss << " Test: " << test_ << "\n"
1080 << " Error: Initialization failed\n"
1081 << " Details:\n"
1082 << " Result:\n" << sm << "\n"
1083 << " Expected result:\n( 0 4 )\n( -3 5 )\n";
1084 throw std::runtime_error( oss.str() );
1085 }
1086
1087 // Integral scaling of the matrix
1088 sm.scale( 2 );
1089
1090 checkRows ( sm, 2UL );
1091 checkColumns ( sm, 2UL );
1092 checkNonZeros( sm, 3UL );
1093 checkNonZeros( sm, 0UL, 1UL );
1094 checkNonZeros( sm, 1UL, 2UL );
1095
1096 if( sm(0,0) != 0 || sm(0,1) != 8 ||
1097 sm(1,0) != -6 || sm(1,1) != 10 ) {
1098 std::ostringstream oss;
1099 oss << " Test: " << test_ << "\n"
1100 << " Error: Integral scale operation failed\n"
1101 << " Details:\n"
1102 << " Result:\n" << sm << "\n"
1103 << " Expected result:\n( 0 8 )\n( -6 10 )\n";
1104 throw std::runtime_error( oss.str() );
1105 }
1106
1107 // Floating point scaling of the matrix
1108 sm.scale( 0.5 );
1109
1110 checkRows ( sm, 2UL );
1111 checkColumns ( sm, 2UL );
1112 checkNonZeros( sm, 3UL );
1113 checkNonZeros( sm, 0UL, 1UL );
1114 checkNonZeros( sm, 1UL, 2UL );
1115
1116 if( sm(0,0) != 0 || sm(0,1) != 4 ||
1117 sm(1,0) != -3 || sm(1,1) != 5 ) {
1118 std::ostringstream oss;
1119 oss << " Test: " << test_ << "\n"
1120 << " Error: Floating point scale operation failed\n"
1121 << " Details:\n"
1122 << " Result:\n" << sm << "\n"
1123 << " Expected result:\n( 0 4 )\n( -3 5 )\n";
1124 throw std::runtime_error( oss.str() );
1125 }
1126 }
1127 }
1128 //*************************************************************************************************
1129
1130
1131 //*************************************************************************************************
1132 /*!\brief Test of the Submatrix function call operator.
1133 //
1134 // \return void
1135 // \exception std::runtime_error Error detected.
1136 //
1137 // This function performs a test of adding and accessing elements via the function call operator
1138 // of the Submatrix specialization. In case an error is detected, a \a std::runtime_error
1139 // exception is thrown.
1140 */
testFunctionCall()1141 void SparseTest::testFunctionCall()
1142 {
1143 //=====================================================================================
1144 // Row-major submatrix tests
1145 //=====================================================================================
1146
1147 {
1148 test_ = "Row-major Submatrix::operator()";
1149
1150 initialize();
1151
1152 SMT sm = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 2UL );
1153
1154 // Assignment to the element (1,0)
1155 {
1156 sm(1,0) = 9;
1157
1158 checkRows ( sm , 3UL );
1159 checkColumns ( sm , 2UL );
1160 checkNonZeros( sm , 5UL );
1161 checkNonZeros( sm , 0UL, 1UL );
1162 checkNonZeros( sm , 1UL, 2UL );
1163 checkNonZeros( sm , 2UL, 2UL );
1164 checkRows ( mat_, 5UL );
1165 checkColumns ( mat_, 4UL );
1166 checkNonZeros( mat_, 11UL );
1167
1168 if( sm(0,0) != 1 || sm(0,1) != 0 ||
1169 sm(1,0) != 9 || sm(1,1) != -3 ||
1170 sm(2,0) != 4 || sm(2,1) != 5 ) {
1171 std::ostringstream oss;
1172 oss << " Test: " << test_ << "\n"
1173 << " Error: Function call operator failed\n"
1174 << " Details:\n"
1175 << " Result:\n" << sm << "\n"
1176 << " Expected result:\n( 1 0 )\n( 9 -3 )\n( 4 5 )\n";
1177 throw std::runtime_error( oss.str() );
1178 }
1179
1180 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
1181 mat_(1,0) != 0 || mat_(1,1) != 1 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
1182 mat_(2,0) != -2 || mat_(2,1) != 9 || mat_(2,2) != -3 || mat_(2,3) != 0 ||
1183 mat_(3,0) != 0 || mat_(3,1) != 4 || mat_(3,2) != 5 || mat_(3,3) != -6 ||
1184 mat_(4,0) != 7 || mat_(4,1) != -8 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
1185 std::ostringstream oss;
1186 oss << " Test: " << test_ << "\n"
1187 << " Error: Subscript operator failed\n"
1188 << " Details:\n"
1189 << " Result:\n" << mat_ << "\n"
1190 << " Expected result:\n( 0 0 0 0 )\n"
1191 "( 0 1 0 0 )\n"
1192 "( -2 9 -3 0 )\n"
1193 "( 0 4 5 -6 )\n"
1194 "( 7 -8 9 10 )\n";
1195 throw std::runtime_error( oss.str() );
1196 }
1197 }
1198
1199 // Assignment to the element (2,0)
1200 {
1201 sm(2,0) = 0;
1202
1203 checkRows ( sm , 3UL );
1204 checkColumns ( sm , 2UL );
1205 checkNonZeros( sm , 4UL );
1206 checkNonZeros( sm , 0UL, 1UL );
1207 checkNonZeros( sm , 1UL, 2UL );
1208 checkNonZeros( sm , 2UL, 1UL );
1209 checkRows ( mat_, 5UL );
1210 checkColumns ( mat_, 4UL );
1211 checkNonZeros( mat_, 10UL );
1212
1213 if( sm(0,0) != 1 || sm(0,1) != 0 ||
1214 sm(1,0) != 9 || sm(1,1) != -3 ||
1215 sm(2,0) != 0 || sm(2,1) != 5 ) {
1216 std::ostringstream oss;
1217 oss << " Test: " << test_ << "\n"
1218 << " Error: Function call operator failed\n"
1219 << " Details:\n"
1220 << " Result:\n" << sm << "\n"
1221 << " Expected result:\n( 1 0 )\n( 9 -3 )\n( 0 5 )\n";
1222 throw std::runtime_error( oss.str() );
1223 }
1224
1225 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
1226 mat_(1,0) != 0 || mat_(1,1) != 1 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
1227 mat_(2,0) != -2 || mat_(2,1) != 9 || mat_(2,2) != -3 || mat_(2,3) != 0 ||
1228 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 5 || mat_(3,3) != -6 ||
1229 mat_(4,0) != 7 || mat_(4,1) != -8 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
1230 std::ostringstream oss;
1231 oss << " Test: " << test_ << "\n"
1232 << " Error: Subscript operator failed\n"
1233 << " Details:\n"
1234 << " Result:\n" << mat_ << "\n"
1235 << " Expected result:\n( 0 0 0 0 )\n"
1236 "( 0 1 0 0 )\n"
1237 "( -2 9 -3 0 )\n"
1238 "( 0 0 5 -6 )\n"
1239 "( 7 -8 9 10 )\n";
1240 throw std::runtime_error( oss.str() );
1241 }
1242 }
1243
1244 // Assignment to the element (1,1)
1245 {
1246 sm(1,1) = 11;
1247
1248 checkRows ( sm , 3UL );
1249 checkColumns ( sm , 2UL );
1250 checkNonZeros( sm , 4UL );
1251 checkNonZeros( sm , 0UL, 1UL );
1252 checkNonZeros( sm , 1UL, 2UL );
1253 checkNonZeros( sm , 2UL, 1UL );
1254 checkRows ( mat_, 5UL );
1255 checkColumns ( mat_, 4UL );
1256 checkNonZeros( mat_, 10UL );
1257
1258 if( sm(0,0) != 1 || sm(0,1) != 0 ||
1259 sm(1,0) != 9 || sm(1,1) != 11 ||
1260 sm(2,0) != 0 || sm(2,1) != 5 ) {
1261 std::ostringstream oss;
1262 oss << " Test: " << test_ << "\n"
1263 << " Error: Function call operator failed\n"
1264 << " Details:\n"
1265 << " Result:\n" << sm << "\n"
1266 << " Expected result:\n( 1 0 )\n( 9 11 )\n( 0 5 )\n";
1267 throw std::runtime_error( oss.str() );
1268 }
1269
1270 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
1271 mat_(1,0) != 0 || mat_(1,1) != 1 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
1272 mat_(2,0) != -2 || mat_(2,1) != 9 || mat_(2,2) != 11 || mat_(2,3) != 0 ||
1273 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 5 || mat_(3,3) != -6 ||
1274 mat_(4,0) != 7 || mat_(4,1) != -8 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
1275 std::ostringstream oss;
1276 oss << " Test: " << test_ << "\n"
1277 << " Error: Subscript operator failed\n"
1278 << " Details:\n"
1279 << " Result:\n" << mat_ << "\n"
1280 << " Expected result:\n( 0 0 0 0 )\n"
1281 "( 0 1 0 0 )\n"
1282 "( -2 9 11 0 )\n"
1283 "( 0 0 5 -6 )\n"
1284 "( 7 -8 9 10 )\n";
1285 throw std::runtime_error( oss.str() );
1286 }
1287 }
1288
1289 // Addition assignment to the element (0,0)
1290 {
1291 sm(0,0) += 3;
1292
1293 checkRows ( sm , 3UL );
1294 checkColumns ( sm , 2UL );
1295 checkNonZeros( sm , 4UL );
1296 checkNonZeros( sm , 0UL, 1UL );
1297 checkNonZeros( sm , 1UL, 2UL );
1298 checkNonZeros( sm , 2UL, 1UL );
1299 checkRows ( mat_, 5UL );
1300 checkColumns ( mat_, 4UL );
1301 checkNonZeros( mat_, 10UL );
1302
1303 if( sm(0,0) != 4 || sm(0,1) != 0 ||
1304 sm(1,0) != 9 || sm(1,1) != 11 ||
1305 sm(2,0) != 0 || sm(2,1) != 5 ) {
1306 std::ostringstream oss;
1307 oss << " Test: " << test_ << "\n"
1308 << " Error: Function call operator failed\n"
1309 << " Details:\n"
1310 << " Result:\n" << sm << "\n"
1311 << " Expected result:\n( 4 0 )\n( 9 11 )\n( 0 5 )\n";
1312 throw std::runtime_error( oss.str() );
1313 }
1314
1315 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
1316 mat_(1,0) != 0 || mat_(1,1) != 4 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
1317 mat_(2,0) != -2 || mat_(2,1) != 9 || mat_(2,2) != 11 || mat_(2,3) != 0 ||
1318 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 5 || mat_(3,3) != -6 ||
1319 mat_(4,0) != 7 || mat_(4,1) != -8 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
1320 std::ostringstream oss;
1321 oss << " Test: " << test_ << "\n"
1322 << " Error: Subscript operator failed\n"
1323 << " Details:\n"
1324 << " Result:\n" << mat_ << "\n"
1325 << " Expected result:\n( 0 0 0 0 )\n"
1326 "( 0 4 0 0 )\n"
1327 "( -2 9 11 0 )\n"
1328 "( 0 0 5 -6 )\n"
1329 "( 7 -8 9 10 )\n";
1330 throw std::runtime_error( oss.str() );
1331 }
1332 }
1333
1334 // Subtraction assignment to the element (0,1)
1335 {
1336 sm(0,1) -= 6;
1337
1338 checkRows ( sm , 3UL );
1339 checkColumns ( sm , 2UL );
1340 checkNonZeros( sm , 5UL );
1341 checkNonZeros( sm , 0UL, 2UL );
1342 checkNonZeros( sm , 1UL, 2UL );
1343 checkNonZeros( sm , 2UL, 1UL );
1344 checkRows ( mat_, 5UL );
1345 checkColumns ( mat_, 4UL );
1346 checkNonZeros( mat_, 11UL );
1347
1348 if( sm(0,0) != 4 || sm(0,1) != -6 ||
1349 sm(1,0) != 9 || sm(1,1) != 11 ||
1350 sm(2,0) != 0 || sm(2,1) != 5 ) {
1351 std::ostringstream oss;
1352 oss << " Test: " << test_ << "\n"
1353 << " Error: Function call operator failed\n"
1354 << " Details:\n"
1355 << " Result:\n" << sm << "\n"
1356 << " Expected result:\n( 4 -6 )\n( 9 11 )\n( 0 5 )\n";
1357 throw std::runtime_error( oss.str() );
1358 }
1359
1360 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
1361 mat_(1,0) != 0 || mat_(1,1) != 4 || mat_(1,2) != -6 || mat_(1,3) != 0 ||
1362 mat_(2,0) != -2 || mat_(2,1) != 9 || mat_(2,2) != 11 || mat_(2,3) != 0 ||
1363 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 5 || mat_(3,3) != -6 ||
1364 mat_(4,0) != 7 || mat_(4,1) != -8 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
1365 std::ostringstream oss;
1366 oss << " Test: " << test_ << "\n"
1367 << " Error: Subscript operator failed\n"
1368 << " Details:\n"
1369 << " Result:\n" << mat_ << "\n"
1370 << " Expected result:\n( 0 0 0 0 )\n"
1371 "( 0 4 -6 0 )\n"
1372 "( -2 9 11 0 )\n"
1373 "( 0 0 5 -6 )\n"
1374 "( 7 -8 9 10 )\n";
1375 throw std::runtime_error( oss.str() );
1376 }
1377 }
1378
1379 // Multiplication assignment to the element (1,1)
1380 {
1381 sm(1,1) *= 2;
1382
1383 checkRows ( sm , 3UL );
1384 checkColumns ( sm , 2UL );
1385 checkNonZeros( sm , 5UL );
1386 checkNonZeros( sm , 0UL, 2UL );
1387 checkNonZeros( sm , 1UL, 2UL );
1388 checkNonZeros( sm , 2UL, 1UL );
1389 checkRows ( mat_, 5UL );
1390 checkColumns ( mat_, 4UL );
1391 checkNonZeros( mat_, 11UL );
1392
1393 if( sm(0,0) != 4 || sm(0,1) != -6 ||
1394 sm(1,0) != 9 || sm(1,1) != 22 ||
1395 sm(2,0) != 0 || sm(2,1) != 5 ) {
1396 std::ostringstream oss;
1397 oss << " Test: " << test_ << "\n"
1398 << " Error: Function call operator failed\n"
1399 << " Details:\n"
1400 << " Result:\n" << sm << "\n"
1401 << " Expected result:\n( 4 -6 )\n( 9 22 )\n( 0 5 )\n";
1402 throw std::runtime_error( oss.str() );
1403 }
1404
1405 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
1406 mat_(1,0) != 0 || mat_(1,1) != 4 || mat_(1,2) != -6 || mat_(1,3) != 0 ||
1407 mat_(2,0) != -2 || mat_(2,1) != 9 || mat_(2,2) != 22 || mat_(2,3) != 0 ||
1408 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 5 || mat_(3,3) != -6 ||
1409 mat_(4,0) != 7 || mat_(4,1) != -8 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
1410 std::ostringstream oss;
1411 oss << " Test: " << test_ << "\n"
1412 << " Error: Subscript operator failed\n"
1413 << " Details:\n"
1414 << " Result:\n" << mat_ << "\n"
1415 << " Expected result:\n( 0 0 0 0 )\n"
1416 "( 0 4 -6 0 )\n"
1417 "( -2 9 22 0 )\n"
1418 "( 0 0 5 -6 )\n"
1419 "( 7 -8 9 10 )\n";
1420 throw std::runtime_error( oss.str() );
1421 }
1422 }
1423
1424 // Division assignment to the element (1,1)
1425 {
1426 sm(1,1) /= 2;
1427
1428 checkRows ( sm , 3UL );
1429 checkColumns ( sm , 2UL );
1430 checkNonZeros( sm , 5UL );
1431 checkNonZeros( sm , 0UL, 2UL );
1432 checkNonZeros( sm , 1UL, 2UL );
1433 checkNonZeros( sm , 2UL, 1UL );
1434 checkRows ( mat_, 5UL );
1435 checkColumns ( mat_, 4UL );
1436 checkNonZeros( mat_, 11UL );
1437
1438 if( sm(0,0) != 4 || sm(0,1) != -6 ||
1439 sm(1,0) != 9 || sm(1,1) != 11 ||
1440 sm(2,0) != 0 || sm(2,1) != 5 ) {
1441 std::ostringstream oss;
1442 oss << " Test: " << test_ << "\n"
1443 << " Error: Function call operator failed\n"
1444 << " Details:\n"
1445 << " Result:\n" << sm << "\n"
1446 << " Expected result:\n( 4 -6 )\n( 9 11 )\n( 0 5 )\n";
1447 throw std::runtime_error( oss.str() );
1448 }
1449
1450 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
1451 mat_(1,0) != 0 || mat_(1,1) != 4 || mat_(1,2) != -6 || mat_(1,3) != 0 ||
1452 mat_(2,0) != -2 || mat_(2,1) != 9 || mat_(2,2) != 11 || mat_(2,3) != 0 ||
1453 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 5 || mat_(3,3) != -6 ||
1454 mat_(4,0) != 7 || mat_(4,1) != -8 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
1455 std::ostringstream oss;
1456 oss << " Test: " << test_ << "\n"
1457 << " Error: Subscript operator failed\n"
1458 << " Details:\n"
1459 << " Result:\n" << mat_ << "\n"
1460 << " Expected result:\n( 0 0 0 0 )\n"
1461 "( 0 4 -6 0 )\n"
1462 "( -2 9 11 0 )\n"
1463 "( 0 0 5 -6 )\n"
1464 "( 7 -8 9 10 )\n";
1465 throw std::runtime_error( oss.str() );
1466 }
1467 }
1468 }
1469
1470
1471 //=====================================================================================
1472 // Column-major submatrix tests
1473 //=====================================================================================
1474
1475 {
1476 test_ = "Column-major Submatrix::operator()";
1477
1478 initialize();
1479
1480 OSMT sm = blaze::submatrix( tmat_, 1UL, 1UL, 2UL, 3UL );
1481
1482 // Assignment to the element (0,1)
1483 {
1484 sm(0,1) = 9;
1485
1486 checkRows ( sm , 2UL );
1487 checkColumns ( sm , 3UL );
1488 checkNonZeros( sm , 5UL );
1489 checkNonZeros( sm , 0UL, 1UL );
1490 checkNonZeros( sm , 1UL, 2UL );
1491 checkNonZeros( sm , 2UL, 2UL );
1492 checkRows ( tmat_, 4UL );
1493 checkColumns ( tmat_, 5UL );
1494 checkNonZeros( tmat_, 11UL );
1495
1496 if( sm(0,0) != 1 || sm(0,1) != 9 || sm(0,2) != 4 ||
1497 sm(1,0) != 0 || sm(1,1) != -3 || sm(1,2) != 5 ) {
1498 std::ostringstream oss;
1499 oss << " Test: " << test_ << "\n"
1500 << " Error: Function call operator failed\n"
1501 << " Details:\n"
1502 << " Result:\n" << sm << "\n"
1503 << " Expected result:\n( 1 9 4 )\n( 0 -3 5 )\n";
1504 throw std::runtime_error( oss.str() );
1505 }
1506
1507 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != -2 || tmat_(0,3) != 0 || tmat_(0,4) != 7 ||
1508 tmat_(1,0) != 0 || tmat_(1,1) != 1 || tmat_(1,2) != 9 || tmat_(1,3) != 4 || tmat_(1,4) != -8 ||
1509 tmat_(2,0) != 0 || tmat_(2,1) != 0 || tmat_(2,2) != -3 || tmat_(2,3) != 5 || tmat_(2,4) != 9 ||
1510 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
1511 std::ostringstream oss;
1512 oss << " Test: " << test_ << "\n"
1513 << " Error: Subscript operator failed\n"
1514 << " Details:\n"
1515 << " Result:\n" << tmat_ << "\n"
1516 << " Expected result:\n( 0 0 -2 0 7 )\n"
1517 "( 0 1 9 4 -8 )\n"
1518 "( 0 0 -3 5 9 )\n"
1519 "( 0 0 0 -6 10 )\n";
1520 throw std::runtime_error( oss.str() );
1521 }
1522 }
1523
1524 // Assignment to the element (0,2)
1525 {
1526 sm(0,2) = 0;
1527
1528 checkRows ( sm , 2UL );
1529 checkColumns ( sm , 3UL );
1530 checkNonZeros( sm , 4UL );
1531 checkNonZeros( sm , 0UL, 1UL );
1532 checkNonZeros( sm , 1UL, 2UL );
1533 checkNonZeros( sm , 2UL, 1UL );
1534 checkRows ( tmat_, 4UL );
1535 checkColumns ( tmat_, 5UL );
1536 checkNonZeros( tmat_, 10UL );
1537
1538 if( sm(0,0) != 1 || sm(0,1) != 9 || sm(0,2) != 0 ||
1539 sm(1,0) != 0 || sm(1,1) != -3 || sm(1,2) != 5 ) {
1540 std::ostringstream oss;
1541 oss << " Test: " << test_ << "\n"
1542 << " Error: Function call operator failed\n"
1543 << " Details:\n"
1544 << " Result:\n" << sm << "\n"
1545 << " Expected result:\n( 1 9 0 )\n( 0 -3 5 )\n";
1546 throw std::runtime_error( oss.str() );
1547 }
1548
1549 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != -2 || tmat_(0,3) != 0 || tmat_(0,4) != 7 ||
1550 tmat_(1,0) != 0 || tmat_(1,1) != 1 || tmat_(1,2) != 9 || tmat_(1,3) != 0 || tmat_(1,4) != -8 ||
1551 tmat_(2,0) != 0 || tmat_(2,1) != 0 || tmat_(2,2) != -3 || tmat_(2,3) != 5 || tmat_(2,4) != 9 ||
1552 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
1553 std::ostringstream oss;
1554 oss << " Test: " << test_ << "\n"
1555 << " Error: Subscript operator failed\n"
1556 << " Details:\n"
1557 << " Result:\n" << tmat_ << "\n"
1558 << " Expected result:\n( 0 0 -2 0 7 )\n"
1559 "( 0 1 9 0 -8 )\n"
1560 "( 0 0 -3 5 9 )\n"
1561 "( 0 0 0 -6 10 )\n";
1562 throw std::runtime_error( oss.str() );
1563 }
1564 }
1565
1566 // Assignment to the element (1,1)
1567 {
1568 sm(1,1) = 11;
1569
1570 checkRows ( sm , 2UL );
1571 checkColumns ( sm , 3UL );
1572 checkNonZeros( sm , 4UL );
1573 checkNonZeros( sm , 0UL, 1UL );
1574 checkNonZeros( sm , 1UL, 2UL );
1575 checkNonZeros( sm , 2UL, 1UL );
1576 checkRows ( tmat_, 4UL );
1577 checkColumns ( tmat_, 5UL );
1578 checkNonZeros( tmat_, 10UL );
1579
1580 if( sm(0,0) != 1 || sm(0,1) != 9 || sm(0,2) != 0 ||
1581 sm(1,0) != 0 || sm(1,1) != 11 || sm(1,2) != 5 ) {
1582 std::ostringstream oss;
1583 oss << " Test: " << test_ << "\n"
1584 << " Error: Function call operator failed\n"
1585 << " Details:\n"
1586 << " Result:\n" << sm << "\n"
1587 << " Expected result:\n( 1 11 0 )\n( 0 -3 5 )\n";
1588 throw std::runtime_error( oss.str() );
1589 }
1590
1591 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != -2 || tmat_(0,3) != 0 || tmat_(0,4) != 7 ||
1592 tmat_(1,0) != 0 || tmat_(1,1) != 1 || tmat_(1,2) != 9 || tmat_(1,3) != 0 || tmat_(1,4) != -8 ||
1593 tmat_(2,0) != 0 || tmat_(2,1) != 0 || tmat_(2,2) != 11 || tmat_(2,3) != 5 || tmat_(2,4) != 9 ||
1594 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
1595 std::ostringstream oss;
1596 oss << " Test: " << test_ << "\n"
1597 << " Error: Subscript operator failed\n"
1598 << " Details:\n"
1599 << " Result:\n" << tmat_ << "\n"
1600 << " Expected result:\n( 0 0 -2 0 7 )\n"
1601 "( 0 1 9 0 -8 )\n"
1602 "( 0 0 11 5 9 )\n"
1603 "( 0 0 0 -6 10 )\n";
1604 throw std::runtime_error( oss.str() );
1605 }
1606 }
1607
1608 // Addition assignment to the element (0,0)
1609 {
1610 sm(0,0) += 3;
1611
1612 checkRows ( sm , 2UL );
1613 checkColumns ( sm , 3UL );
1614 checkNonZeros( sm , 4UL );
1615 checkNonZeros( sm , 0UL, 1UL );
1616 checkNonZeros( sm , 1UL, 2UL );
1617 checkNonZeros( sm , 2UL, 1UL );
1618 checkRows ( tmat_, 4UL );
1619 checkColumns ( tmat_, 5UL );
1620 checkNonZeros( tmat_, 10UL );
1621
1622 if( sm(0,0) != 4 || sm(0,1) != 9 || sm(0,2) != 0 ||
1623 sm(1,0) != 0 || sm(1,1) != 11 || sm(1,2) != 5 ) {
1624 std::ostringstream oss;
1625 oss << " Test: " << test_ << "\n"
1626 << " Error: Function call operator failed\n"
1627 << " Details:\n"
1628 << " Result:\n" << sm << "\n"
1629 << " Expected result:\n( 4 11 0 )\n( 0 -3 5 )\n";
1630 throw std::runtime_error( oss.str() );
1631 }
1632
1633 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != -2 || tmat_(0,3) != 0 || tmat_(0,4) != 7 ||
1634 tmat_(1,0) != 0 || tmat_(1,1) != 4 || tmat_(1,2) != 9 || tmat_(1,3) != 0 || tmat_(1,4) != -8 ||
1635 tmat_(2,0) != 0 || tmat_(2,1) != 0 || tmat_(2,2) != 11 || tmat_(2,3) != 5 || tmat_(2,4) != 9 ||
1636 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
1637 std::ostringstream oss;
1638 oss << " Test: " << test_ << "\n"
1639 << " Error: Subscript operator failed\n"
1640 << " Details:\n"
1641 << " Result:\n" << tmat_ << "\n"
1642 << " Expected result:\n( 0 0 -2 0 7 )\n"
1643 "( 0 4 9 0 -8 )\n"
1644 "( 0 0 11 5 9 )\n"
1645 "( 0 0 0 -6 10 )\n";
1646 throw std::runtime_error( oss.str() );
1647 }
1648 }
1649
1650 // Subtraction assignment to the element (1,0)
1651 {
1652 sm(1,0) -= 6;
1653
1654 checkRows ( sm , 2UL );
1655 checkColumns ( sm , 3UL );
1656 checkNonZeros( sm , 5UL );
1657 checkNonZeros( sm , 0UL, 2UL );
1658 checkNonZeros( sm , 1UL, 2UL );
1659 checkNonZeros( sm , 2UL, 1UL );
1660 checkRows ( tmat_, 4UL );
1661 checkColumns ( tmat_, 5UL );
1662 checkNonZeros( tmat_, 11UL );
1663
1664 if( sm(0,0) != 4 || sm(0,1) != 9 || sm(0,2) != 0 ||
1665 sm(1,0) != -6 || sm(1,1) != 11 || sm(1,2) != 5 ) {
1666 std::ostringstream oss;
1667 oss << " Test: " << test_ << "\n"
1668 << " Error: Function call operator failed\n"
1669 << " Details:\n"
1670 << " Result:\n" << sm << "\n"
1671 << " Expected result:\n( 4 11 0 )\n( -6 -3 5 )\n";
1672 throw std::runtime_error( oss.str() );
1673 }
1674
1675 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != -2 || tmat_(0,3) != 0 || tmat_(0,4) != 7 ||
1676 tmat_(1,0) != 0 || tmat_(1,1) != 4 || tmat_(1,2) != 9 || tmat_(1,3) != 0 || tmat_(1,4) != -8 ||
1677 tmat_(2,0) != 0 || tmat_(2,1) != -6 || tmat_(2,2) != 11 || tmat_(2,3) != 5 || tmat_(2,4) != 9 ||
1678 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
1679 std::ostringstream oss;
1680 oss << " Test: " << test_ << "\n"
1681 << " Error: Subscript operator failed\n"
1682 << " Details:\n"
1683 << " Result:\n" << tmat_ << "\n"
1684 << " Expected result:\n( 0 0 -2 0 7 )\n"
1685 "( 0 4 9 0 -8 )\n"
1686 "( 0 -6 11 5 9 )\n"
1687 "( 0 0 0 -6 10 )\n";
1688 throw std::runtime_error( oss.str() );
1689 }
1690 }
1691
1692 // Multiplication assignment to the element (1,1)
1693 {
1694 sm(1,1) *= 2;
1695
1696 checkRows ( sm , 2UL );
1697 checkColumns ( sm , 3UL );
1698 checkNonZeros( sm , 5UL );
1699 checkNonZeros( sm , 0UL, 2UL );
1700 checkNonZeros( sm , 1UL, 2UL );
1701 checkNonZeros( sm , 2UL, 1UL );
1702 checkRows ( tmat_, 4UL );
1703 checkColumns ( tmat_, 5UL );
1704 checkNonZeros( tmat_, 11UL );
1705
1706 if( sm(0,0) != 4 || sm(0,1) != 9 || sm(0,2) != 0 ||
1707 sm(1,0) != -6 || sm(1,1) != 22 || sm(1,2) != 5 ) {
1708 std::ostringstream oss;
1709 oss << " Test: " << test_ << "\n"
1710 << " Error: Function call operator failed\n"
1711 << " Details:\n"
1712 << " Result:\n" << sm << "\n"
1713 << " Expected result:\n( 4 22 0 )\n( -6 -3 5 )\n";
1714 throw std::runtime_error( oss.str() );
1715 }
1716
1717 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != -2 || tmat_(0,3) != 0 || tmat_(0,4) != 7 ||
1718 tmat_(1,0) != 0 || tmat_(1,1) != 4 || tmat_(1,2) != 9 || tmat_(1,3) != 0 || tmat_(1,4) != -8 ||
1719 tmat_(2,0) != 0 || tmat_(2,1) != -6 || tmat_(2,2) != 22 || tmat_(2,3) != 5 || tmat_(2,4) != 9 ||
1720 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
1721 std::ostringstream oss;
1722 oss << " Test: " << test_ << "\n"
1723 << " Error: Subscript operator failed\n"
1724 << " Details:\n"
1725 << " Result:\n" << tmat_ << "\n"
1726 << " Expected result:\n( 0 0 -2 0 7 )\n"
1727 "( 0 4 9 0 -8 )\n"
1728 "( 0 -6 22 5 9 )\n"
1729 "( 0 0 0 -6 10 )\n";
1730 throw std::runtime_error( oss.str() );
1731 }
1732 }
1733
1734 // Division assignment to the element (1,1)
1735 {
1736 sm(1,1) /= 2;
1737
1738 checkRows ( sm , 2UL );
1739 checkColumns ( sm , 3UL );
1740 checkNonZeros( sm , 5UL );
1741 checkNonZeros( sm , 0UL, 2UL );
1742 checkNonZeros( sm , 1UL, 2UL );
1743 checkNonZeros( sm , 2UL, 1UL );
1744 checkRows ( tmat_, 4UL );
1745 checkColumns ( tmat_, 5UL );
1746 checkNonZeros( tmat_, 11UL );
1747
1748 if( sm(0,0) != 4 || sm(0,1) != 9 || sm(0,2) != 0 ||
1749 sm(1,0) != -6 || sm(1,1) != 11 || sm(1,2) != 5 ) {
1750 std::ostringstream oss;
1751 oss << " Test: " << test_ << "\n"
1752 << " Error: Function call operator failed\n"
1753 << " Details:\n"
1754 << " Result:\n" << sm << "\n"
1755 << " Expected result:\n( 4 11 0 )\n( -6 -3 5 )\n";
1756 throw std::runtime_error( oss.str() );
1757 }
1758
1759 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != -2 || tmat_(0,3) != 0 || tmat_(0,4) != 7 ||
1760 tmat_(1,0) != 0 || tmat_(1,1) != 4 || tmat_(1,2) != 9 || tmat_(1,3) != 0 || tmat_(1,4) != -8 ||
1761 tmat_(2,0) != 0 || tmat_(2,1) != -6 || tmat_(2,2) != 11 || tmat_(2,3) != 5 || tmat_(2,4) != 9 ||
1762 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
1763 std::ostringstream oss;
1764 oss << " Test: " << test_ << "\n"
1765 << " Error: Subscript operator failed\n"
1766 << " Details:\n"
1767 << " Result:\n" << tmat_ << "\n"
1768 << " Expected result:\n( 0 0 -2 0 7 )\n"
1769 "( 0 4 9 0 -8 )\n"
1770 "( 0 -6 11 5 9 )\n"
1771 "( 0 0 0 -6 10 )\n";
1772 throw std::runtime_error( oss.str() );
1773 }
1774 }
1775 }
1776 }
1777 //*************************************************************************************************
1778
1779
1780 //*************************************************************************************************
1781 /*!\brief Test of the Submatrix iterator implementation.
1782 //
1783 // \return void
1784 // \exception std::runtime_error Error detected.
1785 //
1786 // This function performs a test of the iterator implementation of the Submatrix specialization.
1787 // In case an error is detected, a \a std::runtime_error exception is thrown.
1788 */
testIterator()1789 void SparseTest::testIterator()
1790 {
1791 //=====================================================================================
1792 // Row-major submatrix tests
1793 //=====================================================================================
1794
1795 {
1796 initialize();
1797
1798 SMT sm = blaze::submatrix( mat_, 1UL, 0UL, 3UL, 3UL );
1799
1800 // Testing the Iterator default constructor
1801 {
1802 test_ = "Row-major Iterator default constructor";
1803
1804 SMT::Iterator it{};
1805
1806 if( it != SMT::Iterator() ) {
1807 std::ostringstream oss;
1808 oss << " Test: " << test_ << "\n"
1809 << " Error: Failed iterator default constructor\n";
1810 throw std::runtime_error( oss.str() );
1811 }
1812 }
1813
1814 // Testing the ConstIterator default constructor
1815 {
1816 test_ = "Row-major ConstIterator default constructor";
1817
1818 SMT::ConstIterator it{};
1819
1820 if( it != SMT::ConstIterator() ) {
1821 std::ostringstream oss;
1822 oss << " Test: " << test_ << "\n"
1823 << " Error: Failed iterator default constructor\n";
1824 throw std::runtime_error( oss.str() );
1825 }
1826 }
1827
1828 // Testing conversion from Iterator to ConstIterator
1829 {
1830 test_ = "Row-major Iterator/ConstIterator conversion";
1831
1832 SMT::ConstIterator it( begin( sm, 1UL ) );
1833
1834 if( it == end( sm, 1UL ) || it->value() != -2 ) {
1835 std::ostringstream oss;
1836 oss << " Test: " << test_ << "\n"
1837 << " Error: Failed iterator conversion detected\n";
1838 throw std::runtime_error( oss.str() );
1839 }
1840 }
1841
1842 // Counting the number of elements in 0th row via Iterator (end-begin)
1843 {
1844 test_ = "Row-major Iterator subtraction (end-begin)";
1845
1846 const ptrdiff_t number( end( sm, 0UL ) - begin( sm, 0UL ) );
1847
1848 if( number != 1L ) {
1849 std::ostringstream oss;
1850 oss << " Test: " << test_ << "\n"
1851 << " Error: Invalid number of elements detected\n"
1852 << " Details:\n"
1853 << " Number of elements : " << number << "\n"
1854 << " Expected number of elements: 1\n";
1855 throw std::runtime_error( oss.str() );
1856 }
1857 }
1858
1859 // Counting the number of elements in 1st row via ConstIterator (end-begin)
1860 {
1861 test_ = "Row-major ConstIterator subtraction (end-begin)";
1862
1863 const ptrdiff_t number( cend( sm, 1UL ) - cbegin( sm, 1UL ) );
1864
1865 if( number != 2L ) {
1866 std::ostringstream oss;
1867 oss << " Test: " << test_ << "\n"
1868 << " Error: Invalid number of elements detected\n"
1869 << " Details:\n"
1870 << " Number of elements : " << number << "\n"
1871 << " Expected number of elements: 2\n";
1872 throw std::runtime_error( oss.str() );
1873 }
1874 }
1875
1876 // Testing read-only access via ConstIterator
1877 {
1878 test_ = "Row-major read-only access via ConstIterator";
1879
1880 SMT::ConstIterator it ( cbegin( sm, 2UL ) );
1881 SMT::ConstIterator end( cend( sm, 2UL ) );
1882
1883 if( it == end || it->value() != 4 ) {
1884 std::ostringstream oss;
1885 oss << " Test: " << test_ << "\n"
1886 << " Error: Invalid initial iterator detected\n";
1887 throw std::runtime_error( oss.str() );
1888 }
1889
1890 ++it;
1891
1892 if( it == end || it->value() != 5 ) {
1893 std::ostringstream oss;
1894 oss << " Test: " << test_ << "\n"
1895 << " Error: Iterator pre-increment failed\n";
1896 throw std::runtime_error( oss.str() );
1897 }
1898
1899 it++;
1900
1901 if( it != cend( sm, 2UL ) ) {
1902 std::ostringstream oss;
1903 oss << " Test: " << test_ << "\n"
1904 << " Error: Iterator post-increment failed\n";
1905 throw std::runtime_error( oss.str() );
1906 }
1907 }
1908
1909 // Testing assignment via Iterator
1910 {
1911 test_ = "Row-major assignment via Iterator";
1912
1913 int value = 8;
1914
1915 for( SMT::Iterator it=begin( sm, 2UL ); it!=end( sm, 2UL ); ++it ) {
1916 *it = value++;
1917 }
1918
1919 if( sm(0,0) != 0 || sm(0,1) != 1 || sm(0,2) != 0 ||
1920 sm(1,0) != -2 || sm(1,1) != 0 || sm(1,2) != -3 ||
1921 sm(2,0) != 0 || sm(2,1) != 8 || sm(2,2) != 9 ) {
1922 std::ostringstream oss;
1923 oss << " Test: " << test_ << "\n"
1924 << " Error: Assignment via iterator failed\n"
1925 << " Details:\n"
1926 << " Result:\n" << sm << "\n"
1927 << " Expected result:\n( 0 1 0 )\n( -2 0 -3 )\n( 0 8 9 )\n";
1928 throw std::runtime_error( oss.str() );
1929 }
1930
1931 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
1932 mat_(1,0) != 0 || mat_(1,1) != 1 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
1933 mat_(2,0) != -2 || mat_(2,1) != 0 || mat_(2,2) != -3 || mat_(2,3) != 0 ||
1934 mat_(3,0) != 0 || mat_(3,1) != 8 || mat_(3,2) != 9 || mat_(3,3) != -6 ||
1935 mat_(4,0) != 7 || mat_(4,1) != -8 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
1936 std::ostringstream oss;
1937 oss << " Test: " << test_ << "\n"
1938 << " Error: Assignment via iterator failed\n"
1939 << " Details:\n"
1940 << " Result:\n" << mat_ << "\n"
1941 << " Expected result:\n( 0 0 0 0 )\n"
1942 "( 0 1 0 0 )\n"
1943 "( -2 0 -3 0 )\n"
1944 "( 0 8 9 -6 )\n"
1945 "( 7 -8 9 10 )\n";
1946 throw std::runtime_error( oss.str() );
1947 }
1948 }
1949
1950 // Testing addition assignment via Iterator
1951 {
1952 test_ = "Row-major addition assignment via Iterator";
1953
1954 int value = 4;
1955
1956 for( SMT::Iterator it=begin( sm, 1UL ); it!=end( sm, 1UL ); ++it ) {
1957 *it += value++;
1958 }
1959
1960 if( sm(0,0) != 0 || sm(0,1) != 1 || sm(0,2) != 0 ||
1961 sm(1,0) != 2 || sm(1,1) != 0 || sm(1,2) != 2 ||
1962 sm(2,0) != 0 || sm(2,1) != 8 || sm(2,2) != 9 ) {
1963 std::ostringstream oss;
1964 oss << " Test: " << test_ << "\n"
1965 << " Error: Addition assignment via iterator failed\n"
1966 << " Details:\n"
1967 << " Result:\n" << sm << "\n"
1968 << " Expected result:\n( 0 1 0 )\n( 2 0 2 )\n( 0 8 9 )\n";
1969 throw std::runtime_error( oss.str() );
1970 }
1971
1972 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
1973 mat_(1,0) != 0 || mat_(1,1) != 1 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
1974 mat_(2,0) != 2 || mat_(2,1) != 0 || mat_(2,2) != 2 || mat_(2,3) != 0 ||
1975 mat_(3,0) != 0 || mat_(3,1) != 8 || mat_(3,2) != 9 || mat_(3,3) != -6 ||
1976 mat_(4,0) != 7 || mat_(4,1) != -8 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
1977 std::ostringstream oss;
1978 oss << " Test: " << test_ << "\n"
1979 << " Error: Addition assignment via iterator failed\n"
1980 << " Details:\n"
1981 << " Result:\n" << mat_ << "\n"
1982 << " Expected result:\n( 0 0 0 0 )\n"
1983 "( 0 1 0 0 )\n"
1984 "( 2 0 2 0 )\n"
1985 "( 0 8 9 -6 )\n"
1986 "( 7 -8 9 10 )\n";
1987 throw std::runtime_error( oss.str() );
1988 }
1989 }
1990
1991 // Testing subtraction assignment via Iterator
1992 {
1993 test_ = "Row-major subtraction assignment via Iterator";
1994
1995 int value = 4;
1996
1997 for( SMT::Iterator it=begin( sm, 1UL ); it!=end( sm, 1UL ); ++it ) {
1998 *it -= value++;
1999 }
2000
2001 if( sm(0,0) != 0 || sm(0,1) != 1 || sm(0,2) != 0 ||
2002 sm(1,0) != -2 || sm(1,1) != 0 || sm(1,2) != -3 ||
2003 sm(2,0) != 0 || sm(2,1) != 8 || sm(2,2) != 9 ) {
2004 std::ostringstream oss;
2005 oss << " Test: " << test_ << "\n"
2006 << " Error: Subtraction assignment via iterator failed\n"
2007 << " Details:\n"
2008 << " Result:\n" << sm << "\n"
2009 << " Expected result:\n( 0 1 0 )\n( -2 0 -3 )\n( 0 8 9 )\n";
2010 throw std::runtime_error( oss.str() );
2011 }
2012
2013 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
2014 mat_(1,0) != 0 || mat_(1,1) != 1 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
2015 mat_(2,0) != -2 || mat_(2,1) != 0 || mat_(2,2) != -3 || mat_(2,3) != 0 ||
2016 mat_(3,0) != 0 || mat_(3,1) != 8 || mat_(3,2) != 9 || mat_(3,3) != -6 ||
2017 mat_(4,0) != 7 || mat_(4,1) != -8 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
2018 std::ostringstream oss;
2019 oss << " Test: " << test_ << "\n"
2020 << " Error: Subtraction assignment via iterator failed\n"
2021 << " Details:\n"
2022 << " Result:\n" << mat_ << "\n"
2023 << " Expected result:\n( 0 0 0 0 )\n"
2024 "( 0 1 0 0 )\n"
2025 "( -2 0 -3 0 )\n"
2026 "( 0 8 9 -6 )\n"
2027 "( 7 -8 9 10 )\n";
2028 throw std::runtime_error( oss.str() );
2029 }
2030 }
2031
2032 // Testing multiplication assignment via Iterator
2033 {
2034 test_ = "Row-major multiplication assignment via Iterator";
2035
2036 int value = 1;
2037
2038 for( SMT::Iterator it=begin( sm, 1UL ); it!=end( sm, 1UL ); ++it ) {
2039 *it *= value++;
2040 }
2041
2042 if( sm(0,0) != 0 || sm(0,1) != 1 || sm(0,2) != 0 ||
2043 sm(1,0) != -2 || sm(1,1) != 0 || sm(1,2) != -6 ||
2044 sm(2,0) != 0 || sm(2,1) != 8 || sm(2,2) != 9 ) {
2045 std::ostringstream oss;
2046 oss << " Test: " << test_ << "\n"
2047 << " Error: Multiplication assignment via iterator failed\n"
2048 << " Details:\n"
2049 << " Result:\n" << sm << "\n"
2050 << " Expected result:\n( 0 1 0 )\n( -2 0 -6 )\n( 0 8 9 )\n";
2051 throw std::runtime_error( oss.str() );
2052 }
2053
2054 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
2055 mat_(1,0) != 0 || mat_(1,1) != 1 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
2056 mat_(2,0) != -2 || mat_(2,1) != 0 || mat_(2,2) != -6 || mat_(2,3) != 0 ||
2057 mat_(3,0) != 0 || mat_(3,1) != 8 || mat_(3,2) != 9 || mat_(3,3) != -6 ||
2058 mat_(4,0) != 7 || mat_(4,1) != -8 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
2059 std::ostringstream oss;
2060 oss << " Test: " << test_ << "\n"
2061 << " Error: Multiplication assignment via iterator failed\n"
2062 << " Details:\n"
2063 << " Result:\n" << mat_ << "\n"
2064 << " Expected result:\n( 0 0 0 0 )\n"
2065 "( 0 1 0 0 )\n"
2066 "( -2 0 -6 0 )\n"
2067 "( 0 8 9 -6 )\n"
2068 "( 7 -8 9 10 )\n";
2069 throw std::runtime_error( oss.str() );
2070 }
2071 }
2072
2073 // Testing division assignment via Iterator
2074 {
2075 test_ = "Row-major division assignment via Iterator";
2076
2077 for( SMT::Iterator it=begin( sm, 1UL ); it!=end( sm, 1UL ); ++it ) {
2078 *it /= 2;
2079 }
2080
2081 if( sm(0,0) != 0 || sm(0,1) != 1 || sm(0,2) != 0 ||
2082 sm(1,0) != -1 || sm(1,1) != 0 || sm(1,2) != -3 ||
2083 sm(2,0) != 0 || sm(2,1) != 8 || sm(2,2) != 9 ) {
2084 std::ostringstream oss;
2085 oss << " Test: " << test_ << "\n"
2086 << " Error: Division assignment via iterator failed\n"
2087 << " Details:\n"
2088 << " Result:\n" << sm << "\n"
2089 << " Expected result:\n( 0 1 0 )\n( -1 0 -3 )\n( 0 8 9 )\n";
2090 throw std::runtime_error( oss.str() );
2091 }
2092
2093 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
2094 mat_(1,0) != 0 || mat_(1,1) != 1 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
2095 mat_(2,0) != -1 || mat_(2,1) != 0 || mat_(2,2) != -3 || mat_(2,3) != 0 ||
2096 mat_(3,0) != 0 || mat_(3,1) != 8 || mat_(3,2) != 9 || mat_(3,3) != -6 ||
2097 mat_(4,0) != 7 || mat_(4,1) != -8 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
2098 std::ostringstream oss;
2099 oss << " Test: " << test_ << "\n"
2100 << " Error: Division assignment via iterator failed\n"
2101 << " Details:\n"
2102 << " Result:\n" << mat_ << "\n"
2103 << " Expected result:\n( 0 0 0 0 )\n"
2104 "( 0 1 0 0 )\n"
2105 "( -1 0 -3 0 )\n"
2106 "( 0 8 9 -6 )\n"
2107 "( 7 -8 9 10 )\n";
2108 throw std::runtime_error( oss.str() );
2109 }
2110 }
2111 }
2112
2113
2114 //=====================================================================================
2115 // Column-major submatrix tests
2116 //=====================================================================================
2117
2118 {
2119 initialize();
2120
2121 OSMT sm = blaze::submatrix( tmat_, 0UL, 1UL, 3UL, 3UL );
2122
2123 // Testing the Iterator default constructor
2124 {
2125 test_ = "Row-major Iterator default constructor";
2126
2127 OSMT::Iterator it{};
2128
2129 if( it != OSMT::Iterator() ) {
2130 std::ostringstream oss;
2131 oss << " Test: " << test_ << "\n"
2132 << " Error: Failed iterator default constructor\n";
2133 throw std::runtime_error( oss.str() );
2134 }
2135 }
2136
2137 // Testing the ConstIterator default constructor
2138 {
2139 test_ = "Row-major ConstIterator default constructor";
2140
2141 OSMT::ConstIterator it{};
2142
2143 if( it != OSMT::ConstIterator() ) {
2144 std::ostringstream oss;
2145 oss << " Test: " << test_ << "\n"
2146 << " Error: Failed iterator default constructor\n";
2147 throw std::runtime_error( oss.str() );
2148 }
2149 }
2150
2151 // Testing conversion from Iterator to ConstIterator
2152 {
2153 test_ = "Column-major Iterator/ConstIterator conversion";
2154
2155 OSMT::ConstIterator it( begin( sm, 1UL ) );
2156
2157 if( it == end( sm, 1UL ) || it->value() != -2 ) {
2158 std::ostringstream oss;
2159 oss << " Test: " << test_ << "\n"
2160 << " Error: Failed iterator conversion detected\n";
2161 throw std::runtime_error( oss.str() );
2162 }
2163 }
2164
2165 // Counting the number of elements in 0th column via Iterator (end-begin)
2166 {
2167 test_ = "Column-major Iterator subtraction (end-begin)";
2168
2169 const ptrdiff_t number( end( sm, 0UL ) - begin( sm, 0UL ) );
2170
2171 if( number != 1L ) {
2172 std::ostringstream oss;
2173 oss << " Test: " << test_ << "\n"
2174 << " Error: Invalid number of elements detected\n"
2175 << " Details:\n"
2176 << " Number of elements : " << number << "\n"
2177 << " Expected number of elements: 1\n";
2178 throw std::runtime_error( oss.str() );
2179 }
2180 }
2181
2182 // Counting the number of elements in 1st row via ConstIterator (end-begin)
2183 {
2184 test_ = "Column-major ConstIterator subtraction (end-begin)";
2185
2186 const ptrdiff_t number( cend( sm, 1UL ) - cbegin( sm, 1UL ) );
2187
2188 if( number != 2L ) {
2189 std::ostringstream oss;
2190 oss << " Test: " << test_ << "\n"
2191 << " Error: Invalid number of elements detected\n"
2192 << " Details:\n"
2193 << " Number of elements : " << number << "\n"
2194 << " Expected number of elements: 2\n";
2195 throw std::runtime_error( oss.str() );
2196 }
2197 }
2198
2199 // Testing read-only access via ConstIterator
2200 {
2201 test_ = "Column-major read-only access via ConstIterator";
2202
2203 OSMT::ConstIterator it ( cbegin( sm, 2UL ) );
2204 OSMT::ConstIterator end( cend( sm, 2UL ) );
2205
2206 if( it == end || it->value() != 4 ) {
2207 std::ostringstream oss;
2208 oss << " Test: " << test_ << "\n"
2209 << " Error: Invalid initial iterator detected\n";
2210 throw std::runtime_error( oss.str() );
2211 }
2212
2213 ++it;
2214
2215 if( it == end || it->value() != 5 ) {
2216 std::ostringstream oss;
2217 oss << " Test: " << test_ << "\n"
2218 << " Error: Iterator pre-increment failed\n";
2219 throw std::runtime_error( oss.str() );
2220 }
2221
2222 it++;
2223
2224 if( it != cend( sm, 2UL ) ) {
2225 std::ostringstream oss;
2226 oss << " Test: " << test_ << "\n"
2227 << " Error: Iterator post-increment failed\n";
2228 throw std::runtime_error( oss.str() );
2229 }
2230 }
2231
2232 // Testing assignment via Iterator
2233 {
2234 test_ = "Column-major assignment via Iterator";
2235
2236 int value = 8;
2237
2238 for( OSMT::Iterator it=begin( sm, 2UL ); it!=end( sm, 2UL ); ++it ) {
2239 *it = value++;
2240 }
2241
2242 if( sm(0,0) != 0 || sm(0,1) != -2 || sm(0,2) != 0 ||
2243 sm(1,0) != 1 || sm(1,1) != 0 || sm(1,2) != 8 ||
2244 sm(2,0) != 0 || sm(2,1) != -3 || sm(2,2) != 9 ) {
2245 std::ostringstream oss;
2246 oss << " Test: " << test_ << "\n"
2247 << " Error: Assignment via iterator failed\n"
2248 << " Details:\n"
2249 << " Result:\n" << sm << "\n"
2250 << " Expected result:\n( 0 -2 0 )\n( 1 0 8 )\n( 0 -3 9 )\n";
2251 throw std::runtime_error( oss.str() );
2252 }
2253
2254 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != -2 || tmat_(0,3) != 0 || tmat_(0,4) != 7 ||
2255 tmat_(1,0) != 0 || tmat_(1,1) != 1 || tmat_(1,2) != 0 || tmat_(1,3) != 8 || tmat_(1,4) != -8 ||
2256 tmat_(2,0) != 0 || tmat_(2,1) != 0 || tmat_(2,2) != -3 || tmat_(2,3) != 9 || tmat_(2,4) != 9 ||
2257 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
2258 std::ostringstream oss;
2259 oss << " Test: " << test_ << "\n"
2260 << " Error: Assignment via iterator failed\n"
2261 << " Details:\n"
2262 << " Result:\n" << tmat_ << "\n"
2263 << " Expected result:\n( 0 0 -2 0 7 )\n"
2264 "( 0 1 0 8 -8 )\n"
2265 "( 0 0 -3 9 9 )\n"
2266 "( 0 0 0 -6 10 )\n";
2267 throw std::runtime_error( oss.str() );
2268 }
2269 }
2270
2271 // Testing addition assignment via Iterator
2272 {
2273 test_ = "Column-major addition assignment via Iterator";
2274
2275 int value = 4;
2276
2277 for( OSMT::Iterator it=begin( sm, 1UL ); it!=end( sm, 1UL ); ++it ) {
2278 *it += value++;
2279 }
2280
2281 if( sm(0,0) != 0 || sm(0,1) != 2 || sm(0,2) != 0 ||
2282 sm(1,0) != 1 || sm(1,1) != 0 || sm(1,2) != 8 ||
2283 sm(2,0) != 0 || sm(2,1) != 2 || sm(2,2) != 9 ) {
2284 std::ostringstream oss;
2285 oss << " Test: " << test_ << "\n"
2286 << " Error: Addition assignment via iterator failed\n"
2287 << " Details:\n"
2288 << " Result:\n" << sm << "\n"
2289 << " Expected result:\n( 0 2 0 )\n( 1 0 8 )\n( 0 2 9 )\n";
2290 throw std::runtime_error( oss.str() );
2291 }
2292
2293 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != 2 || tmat_(0,3) != 0 || tmat_(0,4) != 7 ||
2294 tmat_(1,0) != 0 || tmat_(1,1) != 1 || tmat_(1,2) != 0 || tmat_(1,3) != 8 || tmat_(1,4) != -8 ||
2295 tmat_(2,0) != 0 || tmat_(2,1) != 0 || tmat_(2,2) != 2 || tmat_(2,3) != 9 || tmat_(2,4) != 9 ||
2296 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
2297 std::ostringstream oss;
2298 oss << " Test: " << test_ << "\n"
2299 << " Error: Addition assignment via iterator failed\n"
2300 << " Details:\n"
2301 << " Result:\n" << tmat_ << "\n"
2302 << " Expected result:\n( 0 0 2 0 7 )\n"
2303 "( 0 1 0 8 -8 )\n"
2304 "( 0 0 2 9 9 )\n"
2305 "( 0 0 0 -6 10 )\n";
2306 throw std::runtime_error( oss.str() );
2307 }
2308 }
2309
2310 // Testing subtraction assignment via Iterator
2311 {
2312 test_ = "Column-major subtraction assignment via Iterator";
2313
2314 int value = 4;
2315
2316 for( OSMT::Iterator it=begin( sm, 1UL ); it!=end( sm, 1UL ); ++it ) {
2317 *it -= value++;
2318 }
2319
2320 if( sm(0,0) != 0 || sm(0,1) != -2 || sm(0,2) != 0 ||
2321 sm(1,0) != 1 || sm(1,1) != 0 || sm(1,2) != 8 ||
2322 sm(2,0) != 0 || sm(2,1) != -3 || sm(2,2) != 9 ) {
2323 std::ostringstream oss;
2324 oss << " Test: " << test_ << "\n"
2325 << " Error: Subtraction assignment via iterator failed\n"
2326 << " Details:\n"
2327 << " Result:\n" << sm << "\n"
2328 << " Expected result:\n( 0 -2 0 )\n( 1 0 8 )\n( 0 -3 9 )\n";
2329 throw std::runtime_error( oss.str() );
2330 }
2331
2332 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != -2 || tmat_(0,3) != 0 || tmat_(0,4) != 7 ||
2333 tmat_(1,0) != 0 || tmat_(1,1) != 1 || tmat_(1,2) != 0 || tmat_(1,3) != 8 || tmat_(1,4) != -8 ||
2334 tmat_(2,0) != 0 || tmat_(2,1) != 0 || tmat_(2,2) != -3 || tmat_(2,3) != 9 || tmat_(2,4) != 9 ||
2335 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
2336 std::ostringstream oss;
2337 oss << " Test: " << test_ << "\n"
2338 << " Error: Subtraction assignment via iterator failed\n"
2339 << " Details:\n"
2340 << " Result:\n" << tmat_ << "\n"
2341 << " Expected result:\n( 0 0 -2 0 7 )\n"
2342 "( 0 1 0 8 -8 )\n"
2343 "( 0 0 -3 9 9 )\n"
2344 "( 0 0 0 -6 10 )\n";
2345 throw std::runtime_error( oss.str() );
2346 }
2347 }
2348
2349 // Testing multiplication assignment via Iterator
2350 {
2351 test_ = "Column-major multiplication assignment via Iterator";
2352
2353 int value = 1;
2354
2355 for( OSMT::Iterator it=begin( sm, 1UL ); it!=end( sm, 1UL ); ++it ) {
2356 *it *= value++;
2357 }
2358
2359 if( sm(0,0) != 0 || sm(0,1) != -2 || sm(0,2) != 0 ||
2360 sm(1,0) != 1 || sm(1,1) != 0 || sm(1,2) != 8 ||
2361 sm(2,0) != 0 || sm(2,1) != -6 || sm(2,2) != 9 ) {
2362 std::ostringstream oss;
2363 oss << " Test: " << test_ << "\n"
2364 << " Error: Multiplication assignment via iterator failed\n"
2365 << " Details:\n"
2366 << " Result:\n" << sm << "\n"
2367 << " Expected result:\n( 0 -2 0 )\n( 1 0 8 )\n( 0 -6 9 )\n";
2368 throw std::runtime_error( oss.str() );
2369 }
2370
2371 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != -2 || tmat_(0,3) != 0 || tmat_(0,4) != 7 ||
2372 tmat_(1,0) != 0 || tmat_(1,1) != 1 || tmat_(1,2) != 0 || tmat_(1,3) != 8 || tmat_(1,4) != -8 ||
2373 tmat_(2,0) != 0 || tmat_(2,1) != 0 || tmat_(2,2) != -6 || tmat_(2,3) != 9 || tmat_(2,4) != 9 ||
2374 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
2375 std::ostringstream oss;
2376 oss << " Test: " << test_ << "\n"
2377 << " Error: Multiplication assignment via iterator failed\n"
2378 << " Details:\n"
2379 << " Result:\n" << tmat_ << "\n"
2380 << " Expected result:\n( 0 0 -2 0 7 )\n"
2381 "( 0 1 0 8 -8 )\n"
2382 "( 0 0 -6 9 9 )\n"
2383 "( 0 0 0 -6 10 )\n";
2384 throw std::runtime_error( oss.str() );
2385 }
2386 }
2387
2388 // Testing division assignment via Iterator
2389 {
2390 test_ = "Column-major division assignment via Iterator";
2391
2392 for( OSMT::Iterator it=begin( sm, 1UL ); it!=end( sm, 1UL ); ++it ) {
2393 *it /= 2;
2394 }
2395
2396 if( sm(0,0) != 0 || sm(0,1) != -1 || sm(0,2) != 0 ||
2397 sm(1,0) != 1 || sm(1,1) != 0 || sm(1,2) != 8 ||
2398 sm(2,0) != 0 || sm(2,1) != -3 || sm(2,2) != 9 ) {
2399 std::ostringstream oss;
2400 oss << " Test: " << test_ << "\n"
2401 << " Error: Division assignment via iterator failed\n"
2402 << " Details:\n"
2403 << " Result:\n" << sm << "\n"
2404 << " Expected result:\n( 0 -1 0 )\n( 1 0 8 )\n( 0 -3 9 )\n";
2405 throw std::runtime_error( oss.str() );
2406 }
2407
2408 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != -1 || tmat_(0,3) != 0 || tmat_(0,4) != 7 ||
2409 tmat_(1,0) != 0 || tmat_(1,1) != 1 || tmat_(1,2) != 0 || tmat_(1,3) != 8 || tmat_(1,4) != -8 ||
2410 tmat_(2,0) != 0 || tmat_(2,1) != 0 || tmat_(2,2) != -3 || tmat_(2,3) != 9 || tmat_(2,4) != 9 ||
2411 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
2412 std::ostringstream oss;
2413 oss << " Test: " << test_ << "\n"
2414 << " Error: Division assignment via iterator failed\n"
2415 << " Details:\n"
2416 << " Result:\n" << tmat_ << "\n"
2417 << " Expected result:\n( 0 0 -1 0 7 )\n"
2418 "( 0 1 0 8 -8 )\n"
2419 "( 0 0 -3 9 9 )\n"
2420 "( 0 0 0 -6 10 )\n";
2421 throw std::runtime_error( oss.str() );
2422 }
2423 }
2424 }
2425 }
2426 //*************************************************************************************************
2427
2428
2429 //*************************************************************************************************
2430 /*!\brief Test of the \c nonZeros() member function of the Submatrix class template.
2431 //
2432 // \return void
2433 // \exception std::runtime_error Error detected.
2434 //
2435 // This function performs a test of the \c nonZeros() member function of the Submatrix
2436 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
2437 */
testNonZeros()2438 void SparseTest::testNonZeros()
2439 {
2440 //=====================================================================================
2441 // Row-major submatrix tests
2442 //=====================================================================================
2443
2444 {
2445 test_ = "Row-major Submatrix::nonZeros()";
2446
2447 initialize();
2448
2449 // Initialization check
2450 SMT sm = blaze::submatrix( mat_, 1UL, 1UL, 2UL, 3UL );
2451
2452 checkRows ( sm, 2UL );
2453 checkColumns ( sm, 3UL );
2454 checkNonZeros( sm, 2UL );
2455 checkNonZeros( sm, 0UL, 1UL );
2456 checkNonZeros( sm, 1UL, 1UL );
2457
2458 if( sm(0,0) != 1 || sm(0,1) != 0 || sm(0,2) != 0 ||
2459 sm(1,0) != 0 || sm(1,1) != -3 || sm(1,2) != 0 ) {
2460 std::ostringstream oss;
2461 oss << " Test: " << test_ << "\n"
2462 << " Error: Initialization failed\n"
2463 << " Details:\n"
2464 << " Result:\n" << sm << "\n"
2465 << " Expected result:\n( 1 0 0 )\n( 0 -3 0 )\n";
2466 throw std::runtime_error( oss.str() );
2467 }
2468
2469 // Changing the number of non-zeros via the sparse submatrix
2470 sm(1,1) = 0;
2471
2472 checkRows ( sm, 2UL );
2473 checkColumns ( sm, 3UL );
2474 checkNonZeros( sm, 1UL );
2475 checkNonZeros( sm, 0UL, 1UL );
2476 checkNonZeros( sm, 1UL, 0UL );
2477
2478 if( sm(0,0) != 1 || sm(0,1) != 0 || sm(0,2) != 0 ||
2479 sm(1,0) != 0 || sm(1,1) != 0 || sm(1,2) != 0 ) {
2480 std::ostringstream oss;
2481 oss << " Test: " << test_ << "\n"
2482 << " Error: Initialization failed\n"
2483 << " Details:\n"
2484 << " Result:\n" << sm << "\n"
2485 << " Expected result:\n( 1 0 0 )\n( 0 0 0 )\n";
2486 throw std::runtime_error( oss.str() );
2487 }
2488
2489 // Changing the number of non-zeros via the sparse matrix
2490 mat_(2,3) = 5;
2491
2492 checkRows ( sm, 2UL );
2493 checkColumns ( sm, 3UL );
2494 checkNonZeros( sm, 2UL );
2495 checkNonZeros( sm, 0UL, 1UL );
2496 checkNonZeros( sm, 1UL, 1UL );
2497
2498 if( sm(0,0) != 1 || sm(0,1) != 0 || sm(0,2) != 0 ||
2499 sm(1,0) != 0 || sm(1,1) != 0 || sm(1,2) != 5 ) {
2500 std::ostringstream oss;
2501 oss << " Test: " << test_ << "\n"
2502 << " Error: Initialization failed\n"
2503 << " Details:\n"
2504 << " Result:\n" << sm << "\n"
2505 << " Expected result:\n( 1 0 0 )\n( 0 0 5 )\n";
2506 throw std::runtime_error( oss.str() );
2507 }
2508 }
2509
2510
2511 //=====================================================================================
2512 // Column-major submatrix tests
2513 //=====================================================================================
2514
2515 {
2516 test_ = "Column-major Submatrix::nonZeros()";
2517
2518 initialize();
2519
2520 // Initialization check
2521 OSMT sm = blaze::submatrix( tmat_, 1UL, 1UL, 3UL, 2UL );
2522
2523 checkRows ( sm, 3UL );
2524 checkColumns ( sm, 2UL );
2525 checkNonZeros( sm, 2UL );
2526 checkNonZeros( sm, 0UL, 1UL );
2527 checkNonZeros( sm, 1UL, 1UL );
2528
2529 if( sm(0,0) != 1 || sm(0,1) != 0 ||
2530 sm(1,0) != 0 || sm(1,1) != -3 ||
2531 sm(2,0) != 0 || sm(2,1) != 0 ) {
2532 std::ostringstream oss;
2533 oss << " Test: " << test_ << "\n"
2534 << " Error: Initialization failed\n"
2535 << " Details:\n"
2536 << " Result:\n" << sm << "\n"
2537 << " Expected result:\n( 1 0 )\n( 0 -3 )\n( 0 0 )\n";
2538 throw std::runtime_error( oss.str() );
2539 }
2540
2541 // Changing the number of non-zeros via the sparse submatrix
2542 sm(1,1) = 0;
2543
2544 checkRows ( sm, 3UL );
2545 checkColumns ( sm, 2UL );
2546 checkNonZeros( sm, 1UL );
2547 checkNonZeros( sm, 0UL, 1UL );
2548 checkNonZeros( sm, 1UL, 0UL );
2549
2550 if( sm(0,0) != 1 || sm(0,1) != 0 ||
2551 sm(1,0) != 0 || sm(1,1) != 0 ||
2552 sm(2,0) != 0 || sm(2,1) != 0 ) {
2553 std::ostringstream oss;
2554 oss << " Test: " << test_ << "\n"
2555 << " Error: Initialization failed\n"
2556 << " Details:\n"
2557 << " Result:\n" << sm << "\n"
2558 << " Expected result:\n( 1 0 )\n( 0 0 )\n( 0 0 )\n";
2559 throw std::runtime_error( oss.str() );
2560 }
2561
2562 // Changing the number of non-zeros via the sparse matrix
2563 tmat_(3,2) = 5;
2564
2565 checkRows ( sm, 3UL );
2566 checkColumns ( sm, 2UL );
2567 checkNonZeros( sm, 2UL );
2568 checkNonZeros( sm, 0UL, 1UL );
2569 checkNonZeros( sm, 1UL, 1UL );
2570
2571 if( sm(0,0) != 1 || sm(0,1) != 0 ||
2572 sm(1,0) != 0 || sm(1,1) != 0 ||
2573 sm(2,0) != 0 || sm(2,1) != 5 ) {
2574 std::ostringstream oss;
2575 oss << " Test: " << test_ << "\n"
2576 << " Error: Initialization failed\n"
2577 << " Details:\n"
2578 << " Result:\n" << sm << "\n"
2579 << " Expected result:\n( 1 0 )\n( 0 0 )\n( 0 5 )\n";
2580 throw std::runtime_error( oss.str() );
2581 }
2582 }
2583 }
2584 //*************************************************************************************************
2585
2586
2587 //*************************************************************************************************
2588 /*!\brief Test of the \c reset() member function of the Submatrix class template.
2589 //
2590 // \return void
2591 // \exception std::runtime_error Error detected.
2592 //
2593 // This function performs a test of the \c reset() member function of the Submatrix
2594 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
2595 */
testReset()2596 void SparseTest::testReset()
2597 {
2598 using blaze::reset;
2599 using blaze::isDefault;
2600
2601
2602 //=====================================================================================
2603 // Row-major single element reset
2604 //=====================================================================================
2605
2606 {
2607 test_ = "Row-major reset() function";
2608
2609 initialize();
2610
2611 SMT sm = blaze::submatrix( mat_, 1UL, 0UL, 3UL, 2UL );
2612
2613 reset( sm(0,1) );
2614
2615 checkRows ( sm , 3UL );
2616 checkColumns ( sm , 2UL );
2617 checkNonZeros( sm , 2UL );
2618 checkRows ( mat_, 5UL );
2619 checkColumns ( mat_, 4UL );
2620 checkNonZeros( mat_, 9UL );
2621
2622 if( !isDefault( sm(0,1) ) ) {
2623 std::ostringstream oss;
2624 oss << " Test: " << test_ << "\n"
2625 << " Error: Reset operation failed\n"
2626 << " Details:\n"
2627 << " Result:\n" << sm << "\n"
2628 << " Expected result:\n( 0 0 )\n( -2 0 )\n( 0 4 )\n";
2629 throw std::runtime_error( oss.str() );
2630 }
2631
2632 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
2633 mat_(1,0) != 0 || mat_(1,1) != 0 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
2634 mat_(2,0) != -2 || mat_(2,1) != 0 || mat_(2,2) != -3 || mat_(2,3) != 0 ||
2635 mat_(3,0) != 0 || mat_(3,1) != 4 || mat_(3,2) != 5 || mat_(3,3) != -6 ||
2636 mat_(4,0) != 7 || mat_(4,1) != -8 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
2637 std::ostringstream oss;
2638 oss << " Test: " << test_ << "\n"
2639 << " Error: Reset operation failed\n"
2640 << " Details:\n"
2641 << " Result:\n" << mat_ << "\n"
2642 << " Expected result:\n( 0 0 0 0 )\n"
2643 "( 0 0 0 0 )\n"
2644 "( -2 0 -3 0 )\n"
2645 "( 0 4 5 -6 )\n"
2646 "( 7 -8 9 10 )\n";
2647 throw std::runtime_error( oss.str() );
2648 }
2649 }
2650
2651
2652 //=====================================================================================
2653 // Row-major reset
2654 //=====================================================================================
2655
2656 {
2657 test_ = "Row-major Submatrix::reset() (lvalue)";
2658
2659 initialize();
2660
2661 SMT sm = blaze::submatrix( mat_, 1UL, 0UL, 3UL, 2UL );
2662
2663 reset( sm );
2664
2665 checkRows ( sm , 3UL );
2666 checkColumns ( sm , 2UL );
2667 checkNonZeros( sm , 0UL );
2668 checkRows ( mat_, 5UL );
2669 checkColumns ( mat_, 4UL );
2670 checkNonZeros( mat_, 7UL );
2671
2672 if( !isDefault( sm ) ) {
2673 std::ostringstream oss;
2674 oss << " Test: " << test_ << "\n"
2675 << " Error: Reset operation failed\n"
2676 << " Details:\n"
2677 << " Result:\n" << sm << "\n"
2678 << " Expected result:\n( 0 0 )\n( 0 0 )\n( 0 0 )\n";
2679 throw std::runtime_error( oss.str() );
2680 }
2681
2682 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
2683 mat_(1,0) != 0 || mat_(1,1) != 0 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
2684 mat_(2,0) != 0 || mat_(2,1) != 0 || mat_(2,2) != -3 || mat_(2,3) != 0 ||
2685 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 5 || mat_(3,3) != -6 ||
2686 mat_(4,0) != 7 || mat_(4,1) != -8 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
2687 std::ostringstream oss;
2688 oss << " Test: " << test_ << "\n"
2689 << " Error: Reset operation failed\n"
2690 << " Details:\n"
2691 << " Result:\n" << mat_ << "\n"
2692 << " Expected result:\n( 0 0 0 0 )\n"
2693 "( 0 0 0 0 )\n"
2694 "( 0 0 -3 0 )\n"
2695 "( 0 0 5 -6 )\n"
2696 "( 7 -8 9 10 )\n";
2697 throw std::runtime_error( oss.str() );
2698 }
2699 }
2700
2701 {
2702 test_ = "Row-major Submatrix::reset() (rvalue)";
2703
2704 initialize();
2705
2706 reset( blaze::submatrix( mat_, 1UL, 0UL, 3UL, 2UL ) );
2707
2708 checkRows ( mat_, 5UL );
2709 checkColumns ( mat_, 4UL );
2710 checkNonZeros( mat_, 7UL );
2711
2712 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
2713 mat_(1,0) != 0 || mat_(1,1) != 0 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
2714 mat_(2,0) != 0 || mat_(2,1) != 0 || mat_(2,2) != -3 || mat_(2,3) != 0 ||
2715 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 5 || mat_(3,3) != -6 ||
2716 mat_(4,0) != 7 || mat_(4,1) != -8 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
2717 std::ostringstream oss;
2718 oss << " Test: " << test_ << "\n"
2719 << " Error: Reset operation failed\n"
2720 << " Details:\n"
2721 << " Result:\n" << mat_ << "\n"
2722 << " Expected result:\n( 0 0 0 0 )\n"
2723 "( 0 0 0 0 )\n"
2724 "( 0 0 -3 0 )\n"
2725 "( 0 0 5 -6 )\n"
2726 "( 7 -8 9 10 )\n";
2727 throw std::runtime_error( oss.str() );
2728 }
2729 }
2730
2731
2732 //=====================================================================================
2733 // Row-major row-wise reset
2734 //=====================================================================================
2735
2736 {
2737 test_ = "Row-major Submatrix::reset( size_t )";
2738
2739 initialize();
2740
2741 SMT sm = blaze::submatrix( mat_, 1UL, 0UL, 3UL, 2UL );
2742
2743 // Resetting the 0th row
2744 {
2745 reset( sm, 0UL );
2746
2747 checkRows ( sm , 3UL );
2748 checkColumns ( sm , 2UL );
2749 checkNonZeros( sm , 2UL );
2750 checkRows ( mat_, 5UL );
2751 checkColumns ( mat_, 4UL );
2752 checkNonZeros( mat_, 9UL );
2753
2754 if( sm(0,0) != 0 || sm(0,1) != 0 ||
2755 sm(1,0) != -2 || sm(1,1) != 0 ||
2756 sm(2,0) != 0 || sm(2,1) != 4 ) {
2757 std::ostringstream oss;
2758 oss << " Test: " << test_ << "\n"
2759 << " Error: Reset operation of 0th row failed\n"
2760 << " Details:\n"
2761 << " Result:\n" << sm << "\n"
2762 << " Expected result:\n( 0 0 )\n( -2 0 )\n( 0 4 )\n";
2763 throw std::runtime_error( oss.str() );
2764 }
2765 }
2766
2767 // Resetting the 1st row
2768 {
2769 reset( sm, 1UL );
2770
2771 checkRows ( sm , 3UL );
2772 checkColumns ( sm , 2UL );
2773 checkNonZeros( sm , 1UL );
2774 checkRows ( mat_, 5UL );
2775 checkColumns ( mat_, 4UL );
2776 checkNonZeros( mat_, 8UL );
2777
2778 if( sm(0,0) != 0 || sm(0,1) != 0 ||
2779 sm(1,0) != 0 || sm(1,1) != 0 ||
2780 sm(2,0) != 0 || sm(2,1) != 4 ) {
2781 std::ostringstream oss;
2782 oss << " Test: " << test_ << "\n"
2783 << " Error: Reset operation of 1st row failed\n"
2784 << " Details:\n"
2785 << " Result:\n" << sm << "\n"
2786 << " Expected result:\n( 0 0 )\n( 0 0 )\n( 0 4 )\n";
2787 throw std::runtime_error( oss.str() );
2788 }
2789 }
2790
2791 // Resetting the 2nd row
2792 {
2793 reset( sm, 2UL );
2794
2795 checkRows ( sm , 3UL );
2796 checkColumns ( sm , 2UL );
2797 checkNonZeros( sm , 0UL );
2798 checkRows ( mat_, 5UL );
2799 checkColumns ( mat_, 4UL );
2800 checkNonZeros( mat_, 7UL );
2801
2802 if( sm(0,0) != 0 || sm(0,1) != 0 ||
2803 sm(1,0) != 0 || sm(1,1) != 0 ||
2804 sm(2,0) != 0 || sm(2,1) != 0 ) {
2805 std::ostringstream oss;
2806 oss << " Test: " << test_ << "\n"
2807 << " Error: Reset operation of 2nd row failed\n"
2808 << " Details:\n"
2809 << " Result:\n" << sm << "\n"
2810 << " Expected result:\n( 0 0 )\n( 0 0 )\n( 0 0 )\n";
2811 throw std::runtime_error( oss.str() );
2812 }
2813 }
2814 }
2815
2816
2817 //=====================================================================================
2818 // Column-major single element reset
2819 //=====================================================================================
2820
2821 {
2822 test_ = "Column-major reset() function";
2823
2824 initialize();
2825
2826 OSMT sm = blaze::submatrix( tmat_, 0UL, 1UL, 2UL, 3UL );
2827
2828 reset( sm(1,0) );
2829
2830 checkRows ( sm , 2UL );
2831 checkColumns ( sm , 3UL );
2832 checkNonZeros( sm , 2UL );
2833 checkRows ( tmat_, 4UL );
2834 checkColumns ( tmat_, 5UL );
2835 checkNonZeros( tmat_, 9UL );
2836
2837 if( !isDefault( sm(1,0) ) ) {
2838 std::ostringstream oss;
2839 oss << " Test: " << test_ << "\n"
2840 << " Error: Reset operation failed\n"
2841 << " Details:\n"
2842 << " Result:\n" << sm << "\n"
2843 << " Expected result:\n( 0 -2 0 )\n( 0 0 4 )\n";
2844 throw std::runtime_error( oss.str() );
2845 }
2846
2847 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != -2 || tmat_(0,3) != 0 || tmat_(0,4) != 7 ||
2848 tmat_(1,0) != 0 || tmat_(1,1) != 0 || tmat_(1,2) != 0 || tmat_(1,3) != 4 || tmat_(1,4) != -8 ||
2849 tmat_(2,0) != 0 || tmat_(2,1) != 0 || tmat_(2,2) != -3 || tmat_(2,3) != 5 || tmat_(2,4) != 9 ||
2850 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
2851 std::ostringstream oss;
2852 oss << " Test: " << test_ << "\n"
2853 << " Error: Reset operation failed\n"
2854 << " Details:\n"
2855 << " Result:\n" << tmat_ << "\n"
2856 << " Expected result:\n( 0 0 -2 0 7 )\n"
2857 "( 0 0 0 4 -8 )\n"
2858 "( 0 0 -3 5 9 )\n"
2859 "( 0 0 0 -6 10 )\n";
2860 throw std::runtime_error( oss.str() );
2861 }
2862 }
2863
2864
2865 //=====================================================================================
2866 // Column-major reset
2867 //=====================================================================================
2868
2869 {
2870 test_ = "Column-major Submatrix::reset() (lvalue)";
2871
2872 initialize();
2873
2874 OSMT sm = blaze::submatrix( tmat_, 0UL, 1UL, 2UL, 3UL );
2875
2876 reset( sm );
2877
2878 checkRows ( sm , 2UL );
2879 checkColumns ( sm , 3UL );
2880 checkNonZeros( sm , 0UL );
2881 checkRows ( tmat_, 4UL );
2882 checkColumns ( tmat_, 5UL );
2883 checkNonZeros( tmat_, 7UL );
2884
2885 if( !isDefault( sm ) ) {
2886 std::ostringstream oss;
2887 oss << " Test: " << test_ << "\n"
2888 << " Error: Reset operation failed\n"
2889 << " Details:\n"
2890 << " Result:\n" << sm << "\n"
2891 << " Expected result:\n( 0 0 0 )\n( 0 0 0 )\n";
2892 throw std::runtime_error( oss.str() );
2893 }
2894
2895 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 || tmat_(0,4) != 7 ||
2896 tmat_(1,0) != 0 || tmat_(1,1) != 0 || tmat_(1,2) != 0 || tmat_(1,3) != 0 || tmat_(1,4) != -8 ||
2897 tmat_(2,0) != 0 || tmat_(2,1) != 0 || tmat_(2,2) != -3 || tmat_(2,3) != 5 || tmat_(2,4) != 9 ||
2898 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
2899 std::ostringstream oss;
2900 oss << " Test: " << test_ << "\n"
2901 << " Error: Reset operation failed\n"
2902 << " Details:\n"
2903 << " Result:\n" << tmat_ << "\n"
2904 << " Expected result:\n( 0 0 0 0 7 )\n"
2905 "( 0 0 0 0 -8 )\n"
2906 "( 0 0 -3 5 9 )\n"
2907 "( 0 0 0 -6 10 )\n";
2908 throw std::runtime_error( oss.str() );
2909 }
2910 }
2911
2912 {
2913 test_ = "Column-major Submatrix::reset() (rvalue)";
2914
2915 initialize();
2916
2917 reset( blaze::submatrix( tmat_, 0UL, 1UL, 2UL, 3UL ) );
2918
2919 checkRows ( tmat_, 4UL );
2920 checkColumns ( tmat_, 5UL );
2921 checkNonZeros( tmat_, 7UL );
2922
2923 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 || tmat_(0,4) != 7 ||
2924 tmat_(1,0) != 0 || tmat_(1,1) != 0 || tmat_(1,2) != 0 || tmat_(1,3) != 0 || tmat_(1,4) != -8 ||
2925 tmat_(2,0) != 0 || tmat_(2,1) != 0 || tmat_(2,2) != -3 || tmat_(2,3) != 5 || tmat_(2,4) != 9 ||
2926 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
2927 std::ostringstream oss;
2928 oss << " Test: " << test_ << "\n"
2929 << " Error: Reset operation failed\n"
2930 << " Details:\n"
2931 << " Result:\n" << tmat_ << "\n"
2932 << " Expected result:\n( 0 0 0 0 7 )\n"
2933 "( 0 0 0 0 -8 )\n"
2934 "( 0 0 -3 5 9 )\n"
2935 "( 0 0 0 -6 10 )\n";
2936 throw std::runtime_error( oss.str() );
2937 }
2938 }
2939
2940
2941 //=====================================================================================
2942 // Column-major row-wise reset
2943 //=====================================================================================
2944
2945 {
2946 test_ = "Column-major Submatrix::reset( size_t )";
2947
2948 initialize();
2949
2950 OSMT sm = blaze::submatrix( tmat_, 0UL, 1UL, 2UL, 3UL );
2951
2952 // Resetting the 0th column
2953 {
2954 reset( sm, 0UL );
2955
2956 checkRows ( sm , 2UL );
2957 checkColumns ( sm , 3UL );
2958 checkNonZeros( sm , 2UL );
2959 checkRows ( tmat_, 4UL );
2960 checkColumns ( tmat_, 5UL );
2961 checkNonZeros( tmat_, 9UL );
2962
2963 if( sm(0,0) != 0 || sm(0,1) != -2 || sm(0,2) != 0 ||
2964 sm(1,0) != 0 || sm(1,1) != 0 || sm(1,2) != 4 ) {
2965 std::ostringstream oss;
2966 oss << " Test: " << test_ << "\n"
2967 << " Error: Reset operation of 0th column failed\n"
2968 << " Details:\n"
2969 << " Result:\n" << sm << "\n"
2970 << " Expected result:\n( 0 -2 0 )\n( 0 0 4 )\n";
2971 throw std::runtime_error( oss.str() );
2972 }
2973 }
2974
2975 // Resetting the 1st column
2976 {
2977 reset( sm, 1UL );
2978
2979 checkRows ( sm , 2UL );
2980 checkColumns ( sm , 3UL );
2981 checkNonZeros( sm , 1UL );
2982 checkRows ( tmat_, 4UL );
2983 checkColumns ( tmat_, 5UL );
2984 checkNonZeros( tmat_, 8UL );
2985
2986 if( sm(0,0) != 0 || sm(0,1) != 0 || sm(0,2) != 0 ||
2987 sm(1,0) != 0 || sm(1,1) != 0 || sm(1,2) != 4 ) {
2988 std::ostringstream oss;
2989 oss << " Test: " << test_ << "\n"
2990 << " Error: Reset operation of 1st column failed\n"
2991 << " Details:\n"
2992 << " Result:\n" << sm << "\n"
2993 << " Expected result:\n( 0 0 0 )\n( 0 0 4 )\n";
2994 throw std::runtime_error( oss.str() );
2995 }
2996 }
2997
2998 // Resetting the 2nd column
2999 {
3000 reset( sm, 2UL );
3001
3002 checkRows ( sm , 2UL );
3003 checkColumns ( sm , 3UL );
3004 checkNonZeros( sm , 0UL );
3005 checkRows ( tmat_, 4UL );
3006 checkColumns ( tmat_, 5UL );
3007 checkNonZeros( tmat_, 7UL );
3008
3009 if( sm(0,0) != 0 || sm(0,1) != 0 || sm(0,2) != 0 ||
3010 sm(1,0) != 0 || sm(1,1) != 0 || sm(1,2) != 0 ) {
3011 std::ostringstream oss;
3012 oss << " Test: " << test_ << "\n"
3013 << " Error: Reset operation of 2nd column failed\n"
3014 << " Details:\n"
3015 << " Result:\n" << sm << "\n"
3016 << " Expected result:\n( 0 0 0 )\n( 0 0 0 )\n";
3017 throw std::runtime_error( oss.str() );
3018 }
3019 }
3020 }
3021 }
3022 //*************************************************************************************************
3023
3024
3025 //*************************************************************************************************
3026 /*!\brief Test of the \c clear() function with the Submatrix class template.
3027 //
3028 // \return void
3029 // \exception std::runtime_error Error detected.
3030 //
3031 // This function performs a test of the \c clear() function with the Submatrix specialization.
3032 // In case an error is detected, a \a std::runtime_error exception is thrown.
3033 */
testClear()3034 void SparseTest::testClear()
3035 {
3036 using blaze::clear;
3037 using blaze::isDefault;
3038
3039
3040 //=====================================================================================
3041 // Row-major single element clear
3042 //=====================================================================================
3043
3044 {
3045 test_ = "Row-major clear() function";
3046
3047 initialize();
3048
3049 SMT sm = blaze::submatrix( mat_, 1UL, 0UL, 3UL, 2UL );
3050
3051 clear( sm(0,1) );
3052
3053 checkRows ( sm , 3UL );
3054 checkColumns ( sm , 2UL );
3055 checkNonZeros( sm , 2UL );
3056 checkRows ( mat_, 5UL );
3057 checkColumns ( mat_, 4UL );
3058 checkNonZeros( mat_, 9UL );
3059
3060 if( !isDefault( sm(0,1) ) ) {
3061 std::ostringstream oss;
3062 oss << " Test: " << test_ << "\n"
3063 << " Error: Clear operation failed\n"
3064 << " Details:\n"
3065 << " Result:\n" << sm << "\n"
3066 << " Expected result:\n( 0 0 )\n( -2 0 )\n( 0 4 )\n";
3067 throw std::runtime_error( oss.str() );
3068 }
3069
3070 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
3071 mat_(1,0) != 0 || mat_(1,1) != 0 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
3072 mat_(2,0) != -2 || mat_(2,1) != 0 || mat_(2,2) != -3 || mat_(2,3) != 0 ||
3073 mat_(3,0) != 0 || mat_(3,1) != 4 || mat_(3,2) != 5 || mat_(3,3) != -6 ||
3074 mat_(4,0) != 7 || mat_(4,1) != -8 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
3075 std::ostringstream oss;
3076 oss << " Test: " << test_ << "\n"
3077 << " Error: Clear operation failed\n"
3078 << " Details:\n"
3079 << " Result:\n" << mat_ << "\n"
3080 << " Expected result:\n( 0 0 0 0 )\n"
3081 "( 0 0 0 0 )\n"
3082 "( -2 0 -3 0 )\n"
3083 "( 0 4 5 -6 )\n"
3084 "( 7 -8 9 10 )\n";
3085 throw std::runtime_error( oss.str() );
3086 }
3087 }
3088
3089
3090 //=====================================================================================
3091 // Row-major clear
3092 //=====================================================================================
3093
3094 {
3095 test_ = "Row-major clear() function (lvalue)";
3096
3097 initialize();
3098
3099 SMT sm = blaze::submatrix( mat_, 1UL, 0UL, 3UL, 2UL );
3100
3101 clear( sm );
3102
3103 checkRows ( sm , 3UL );
3104 checkColumns ( sm , 2UL );
3105 checkNonZeros( sm , 0UL );
3106 checkRows ( mat_, 5UL );
3107 checkColumns ( mat_, 4UL );
3108 checkNonZeros( mat_, 7UL );
3109
3110 if( !isDefault( sm ) ) {
3111 std::ostringstream oss;
3112 oss << " Test: " << test_ << "\n"
3113 << " Error: Clear operation failed\n"
3114 << " Details:\n"
3115 << " Result:\n" << sm << "\n"
3116 << " Expected result:\n( 0 0 )\n( 0 0 )\n( 0 0 )\n";
3117 throw std::runtime_error( oss.str() );
3118 }
3119
3120 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
3121 mat_(1,0) != 0 || mat_(1,1) != 0 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
3122 mat_(2,0) != 0 || mat_(2,1) != 0 || mat_(2,2) != -3 || mat_(2,3) != 0 ||
3123 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 5 || mat_(3,3) != -6 ||
3124 mat_(4,0) != 7 || mat_(4,1) != -8 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
3125 std::ostringstream oss;
3126 oss << " Test: " << test_ << "\n"
3127 << " Error: Clear operation failed\n"
3128 << " Details:\n"
3129 << " Result:\n" << mat_ << "\n"
3130 << " Expected result:\n( 0 0 0 0 )\n"
3131 "( 0 0 0 0 )\n"
3132 "( 0 0 -3 0 )\n"
3133 "( 0 0 5 -6 )\n"
3134 "( 7 -8 9 10 )\n";
3135 throw std::runtime_error( oss.str() );
3136 }
3137 }
3138
3139 {
3140 test_ = "Row-major clear() function (rvalue)";
3141
3142 initialize();
3143
3144 clear( blaze::submatrix( mat_, 1UL, 0UL, 3UL, 2UL ) );
3145
3146 checkRows ( mat_, 5UL );
3147 checkColumns ( mat_, 4UL );
3148 checkNonZeros( mat_, 7UL );
3149
3150 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
3151 mat_(1,0) != 0 || mat_(1,1) != 0 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
3152 mat_(2,0) != 0 || mat_(2,1) != 0 || mat_(2,2) != -3 || mat_(2,3) != 0 ||
3153 mat_(3,0) != 0 || mat_(3,1) != 0 || mat_(3,2) != 5 || mat_(3,3) != -6 ||
3154 mat_(4,0) != 7 || mat_(4,1) != -8 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
3155 std::ostringstream oss;
3156 oss << " Test: " << test_ << "\n"
3157 << " Error: Clear operation failed\n"
3158 << " Details:\n"
3159 << " Result:\n" << mat_ << "\n"
3160 << " Expected result:\n( 0 0 0 0 )\n"
3161 "( 0 0 0 0 )\n"
3162 "( 0 0 -3 0 )\n"
3163 "( 0 0 5 -6 )\n"
3164 "( 7 -8 9 10 )\n";
3165 throw std::runtime_error( oss.str() );
3166 }
3167 }
3168
3169
3170 //=====================================================================================
3171 // Column-major single element clear
3172 //=====================================================================================
3173
3174 {
3175 test_ = "Column-major clear() function";
3176
3177 initialize();
3178
3179 OSMT sm = blaze::submatrix( tmat_, 0UL, 1UL, 2UL, 3UL );
3180
3181 clear( sm(1,0) );
3182
3183 checkRows ( sm , 2UL );
3184 checkColumns ( sm , 3UL );
3185 checkNonZeros( sm , 2UL );
3186 checkRows ( tmat_, 4UL );
3187 checkColumns ( tmat_, 5UL );
3188 checkNonZeros( tmat_, 9UL );
3189
3190 if( !isDefault( sm(1,0) ) ) {
3191 std::ostringstream oss;
3192 oss << " Test: " << test_ << "\n"
3193 << " Error: Clear operation failed\n"
3194 << " Details:\n"
3195 << " Result:\n" << sm << "\n"
3196 << " Expected result:\n( 0 -2 0 )\n( 0 0 4 )\n";
3197 throw std::runtime_error( oss.str() );
3198 }
3199
3200 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != -2 || tmat_(0,3) != 0 || tmat_(0,4) != 7 ||
3201 tmat_(1,0) != 0 || tmat_(1,1) != 0 || tmat_(1,2) != 0 || tmat_(1,3) != 4 || tmat_(1,4) != -8 ||
3202 tmat_(2,0) != 0 || tmat_(2,1) != 0 || tmat_(2,2) != -3 || tmat_(2,3) != 5 || tmat_(2,4) != 9 ||
3203 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
3204 std::ostringstream oss;
3205 oss << " Test: " << test_ << "\n"
3206 << " Error: Clear operation failed\n"
3207 << " Details:\n"
3208 << " Result:\n" << tmat_ << "\n"
3209 << " Expected result:\n( 0 0 -2 0 7 )\n"
3210 "( 0 0 0 4 -8 )\n"
3211 "( 0 0 -3 5 9 )\n"
3212 "( 0 0 0 -6 10 )\n";
3213 throw std::runtime_error( oss.str() );
3214 }
3215 }
3216
3217
3218 //=====================================================================================
3219 // Column-major clear
3220 //=====================================================================================
3221
3222 {
3223 test_ = "Column-major clear() function (lvalue)";
3224
3225 initialize();
3226
3227 OSMT sm = blaze::submatrix( tmat_, 0UL, 1UL, 2UL, 3UL );
3228
3229 clear( sm );
3230
3231 checkRows ( sm , 2UL );
3232 checkColumns ( sm , 3UL );
3233 checkNonZeros( sm , 0UL );
3234 checkRows ( tmat_, 4UL );
3235 checkColumns ( tmat_, 5UL );
3236 checkNonZeros( tmat_, 7UL );
3237
3238 if( !isDefault( sm ) ) {
3239 std::ostringstream oss;
3240 oss << " Test: " << test_ << "\n"
3241 << " Error: Clear operation failed\n"
3242 << " Details:\n"
3243 << " Result:\n" << sm << "\n"
3244 << " Expected result:\n( 0 0 0 )\n( 0 0 0 )\n";
3245 throw std::runtime_error( oss.str() );
3246 }
3247
3248 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 || tmat_(0,4) != 7 ||
3249 tmat_(1,0) != 0 || tmat_(1,1) != 0 || tmat_(1,2) != 0 || tmat_(1,3) != 0 || tmat_(1,4) != -8 ||
3250 tmat_(2,0) != 0 || tmat_(2,1) != 0 || tmat_(2,2) != -3 || tmat_(2,3) != 5 || tmat_(2,4) != 9 ||
3251 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
3252 std::ostringstream oss;
3253 oss << " Test: " << test_ << "\n"
3254 << " Error: Clear operation failed\n"
3255 << " Details:\n"
3256 << " Result:\n" << tmat_ << "\n"
3257 << " Expected result:\n( 0 0 0 0 7 )\n"
3258 "( 0 0 0 0 -8 )\n"
3259 "( 0 0 -3 5 9 )\n"
3260 "( 0 0 0 -6 10 )\n";
3261 throw std::runtime_error( oss.str() );
3262 }
3263 }
3264
3265 {
3266 test_ = "Column-major clear() function (rvalue)";
3267
3268 initialize();
3269
3270 clear( blaze::submatrix( tmat_, 0UL, 1UL, 2UL, 3UL ) );
3271
3272 checkRows ( tmat_, 4UL );
3273 checkColumns ( tmat_, 5UL );
3274 checkNonZeros( tmat_, 7UL );
3275
3276 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != 0 || tmat_(0,3) != 0 || tmat_(0,4) != 7 ||
3277 tmat_(1,0) != 0 || tmat_(1,1) != 0 || tmat_(1,2) != 0 || tmat_(1,3) != 0 || tmat_(1,4) != -8 ||
3278 tmat_(2,0) != 0 || tmat_(2,1) != 0 || tmat_(2,2) != -3 || tmat_(2,3) != 5 || tmat_(2,4) != 9 ||
3279 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
3280 std::ostringstream oss;
3281 oss << " Test: " << test_ << "\n"
3282 << " Error: Clear operation failed\n"
3283 << " Details:\n"
3284 << " Result:\n" << tmat_ << "\n"
3285 << " Expected result:\n( 0 0 0 0 7 )\n"
3286 "( 0 0 0 0 -8 )\n"
3287 "( 0 0 -3 5 9 )\n"
3288 "( 0 0 0 -6 10 )\n";
3289 throw std::runtime_error( oss.str() );
3290 }
3291 }
3292 }
3293 //*************************************************************************************************
3294
3295
3296 //*************************************************************************************************
3297 /*!\brief Test of the \c reserve() member function of the Submatrix class template.
3298 //
3299 // \return void
3300 // \exception std::runtime_error Error detected.
3301 //
3302 // This function performs a test of the \c reserve() member function of the Submatrix
3303 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
3304 */
testReserve()3305 void SparseTest::testReserve()
3306 {
3307 //=====================================================================================
3308 // Row-major submatrix tests
3309 //=====================================================================================
3310
3311 {
3312 test_ = "Row-major Submatrix::reserve()";
3313
3314 MT mat( 3UL, 20UL );
3315
3316 SMT sm = blaze::submatrix( mat, 1UL, 0UL, 1UL, 20UL );
3317
3318 // Increasing the capacity of the matrix
3319 sm.reserve( 10UL );
3320
3321 checkRows ( sm, 1UL );
3322 checkColumns ( sm, 20UL );
3323 checkCapacity( sm, 10UL );
3324 checkNonZeros( sm, 0UL );
3325
3326 // Further increasing the capacity of the matrix
3327 sm.reserve( 20UL );
3328
3329 checkRows ( sm, 1UL );
3330 checkColumns ( sm, 20UL );
3331 checkCapacity( sm, 20UL );
3332 checkNonZeros( sm, 0UL );
3333 }
3334
3335 {
3336 test_ = "Row-major Submatrix::reserve( size_t )";
3337
3338 MT mat( 3UL, 20UL );
3339
3340 SMT sm = blaze::submatrix( mat, 1UL, 0UL, 1UL, 20UL );
3341
3342 // Increasing the capacity of the row
3343 sm.reserve( 0UL, 10UL );
3344
3345 checkRows ( sm, 1UL );
3346 checkColumns ( sm, 20UL );
3347 checkCapacity( sm, 10UL );
3348 checkNonZeros( sm, 0UL );
3349
3350 // Further increasing the capacity of the row
3351 sm.reserve( 0UL, 15UL );
3352
3353 checkRows ( sm, 1UL );
3354 checkColumns ( sm, 20UL );
3355 checkCapacity( sm, 15UL );
3356 checkNonZeros( sm, 0UL );
3357 }
3358
3359
3360 //=====================================================================================
3361 // Column-major submatrix tests
3362 //=====================================================================================
3363
3364 {
3365 test_ = "Column-major Submatrix::reserve()";
3366
3367 OMT mat( 3UL, 20UL );
3368
3369 OSMT sm = blaze::submatrix( mat, 1UL, 0UL, 1UL, 20UL );
3370
3371 // Increasing the capacity of the matrix
3372 sm.reserve( 10UL );
3373
3374 checkRows ( sm, 1UL );
3375 checkColumns ( sm, 20UL );
3376 checkCapacity( sm, 10UL );
3377 checkNonZeros( sm, 0UL );
3378
3379 // Further increasing the capacity of the matrix
3380 sm.reserve( 20UL );
3381
3382 checkRows ( sm, 1UL );
3383 checkColumns ( sm, 20UL );
3384 checkCapacity( sm, 20UL );
3385 checkNonZeros( sm, 0UL );
3386 }
3387
3388 {
3389 test_ = "Columnt-major Submatrix::reserve( size_t )";
3390
3391 OMT mat( 20UL, 3UL );
3392
3393 OSMT sm = blaze::submatrix( mat, 0UL, 1UL, 20UL, 1UL );
3394
3395 // Increasing the capacity of the column
3396 sm.reserve( 0UL, 10UL );
3397
3398 checkRows ( sm, 20UL );
3399 checkColumns ( sm, 1UL );
3400 checkCapacity( sm, 10UL );
3401 checkNonZeros( sm, 0UL );
3402
3403 // Further increasing the capacity of the column
3404 sm.reserve( 0UL, 15UL );
3405
3406 checkRows ( sm, 20UL );
3407 checkColumns ( sm, 1UL );
3408 checkCapacity( sm, 15UL );
3409 checkNonZeros( sm, 0UL );
3410 }
3411 }
3412 //*************************************************************************************************
3413
3414
3415 //*************************************************************************************************
3416 /*!\brief Test of the \c trim() member functions of the Submatrix class template.
3417 //
3418 // \return void
3419 // \exception std::runtime_error Error detected.
3420 //
3421 // This function performs a test of the \c trim() member functions of the Submatrix
3422 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
3423 */
testTrim()3424 void SparseTest::testTrim()
3425 {
3426 //=====================================================================================
3427 // Row-major matrix tests
3428 //=====================================================================================
3429
3430 {
3431 test_ = "Row-major Submatrix::trim()";
3432
3433 initialize();
3434
3435 SMT sm = blaze::submatrix( mat_, 2UL, 1UL, 2UL, 3UL );
3436
3437 // Increasing the row capacity of the matrix
3438 sm.reserve( 0UL, 10UL );
3439 sm.reserve( 1UL, 20UL );
3440
3441 checkRows ( sm , 2UL );
3442 checkColumns ( sm , 3UL );
3443 checkCapacity( sm , 30UL );
3444 checkCapacity( sm , 0UL, 10UL );
3445 checkCapacity( sm , 1UL, 20UL );
3446 checkCapacity( mat_, 30UL );
3447 checkCapacity( mat_, 2UL, 10UL );
3448 checkCapacity( mat_, 3UL, 20UL );
3449
3450 // Trimming the matrix
3451 sm.trim();
3452
3453 checkRows ( sm , 2UL );
3454 checkColumns ( sm , 3UL );
3455 checkCapacity( sm , 30UL );
3456 checkCapacity( sm , 0UL, sm.nonZeros( 0UL ) );
3457 checkCapacity( sm , 1UL, sm.nonZeros( 1UL ) );
3458 checkCapacity( mat_, 30UL );
3459 checkCapacity( mat_, 2UL, mat_.nonZeros( 2UL ) );
3460 checkCapacity( mat_, 3UL, mat_.nonZeros( 3UL ) );
3461 }
3462
3463 {
3464 test_ = "Row-major Submatrix::trim( size_t )";
3465
3466 initialize();
3467
3468 SMT sm = blaze::submatrix( mat_, 2UL, 1UL, 2UL, 3UL );
3469
3470 // Increasing the row capacity of the matrix
3471 sm.reserve( 0UL, 10UL );
3472 sm.reserve( 1UL, 20UL );
3473
3474 checkRows ( sm , 2UL );
3475 checkColumns ( sm , 3UL );
3476 checkCapacity( sm , 30UL );
3477 checkCapacity( sm , 0UL, 10UL );
3478 checkCapacity( sm , 1UL, 20UL );
3479 checkCapacity( mat_, 30UL );
3480 checkCapacity( mat_, 2UL, 10UL );
3481 checkCapacity( mat_, 3UL, 20UL );
3482
3483 // Trimming the 0th row
3484 sm.trim( 0UL );
3485
3486 checkRows ( sm , 2UL );
3487 checkColumns ( sm , 3UL );
3488 checkCapacity( sm , 30UL );
3489 checkCapacity( sm , 0UL, sm.nonZeros( 0UL ) );
3490 checkCapacity( sm , 1UL, 30UL - sm.nonZeros( 0UL ) );
3491 checkCapacity( mat_, 30UL );
3492 checkCapacity( mat_, 2UL, mat_.nonZeros( 2UL ) );
3493 checkCapacity( mat_, 3UL, 30UL - mat_.nonZeros( 2UL ) );
3494
3495 // Trimming the 1st row
3496 sm.trim( 1UL );
3497
3498 checkRows ( sm , 2UL );
3499 checkColumns ( sm , 3UL );
3500 checkCapacity( sm , 30UL );
3501 checkCapacity( sm , 0UL, sm.nonZeros( 0UL ) );
3502 checkCapacity( sm , 1UL, sm.nonZeros( 1UL ) );
3503 checkCapacity( mat_, 30UL );
3504 checkCapacity( mat_, 2UL, mat_.nonZeros( 2UL ) );
3505 checkCapacity( mat_, 3UL, mat_.nonZeros( 3UL ) );
3506 }
3507
3508
3509 //=====================================================================================
3510 // Column-major matrix tests
3511 //=====================================================================================
3512
3513 {
3514 test_ = "Column-major Submatrix::trim()";
3515
3516 initialize();
3517
3518 OSMT sm = blaze::submatrix( tmat_, 1UL, 2UL, 3UL, 2UL );
3519
3520 // Increasing the row capacity of the matrix
3521 sm.reserve( 0UL, 10UL );
3522 sm.reserve( 1UL, 20UL );
3523
3524 checkRows ( sm , 3UL );
3525 checkColumns ( sm , 2UL );
3526 checkCapacity( sm , 30UL );
3527 checkCapacity( sm , 0UL, 10UL );
3528 checkCapacity( sm , 1UL, 20UL );
3529 checkCapacity( tmat_, 30UL );
3530 checkCapacity( tmat_, 2UL, 10UL );
3531 checkCapacity( tmat_, 3UL, 20UL );
3532
3533 // Trimming the matrix
3534 sm.trim();
3535
3536 checkRows ( sm , 3UL );
3537 checkColumns ( sm , 2UL );
3538 checkCapacity( sm , 30UL );
3539 checkCapacity( sm , 0UL, sm.nonZeros( 0UL ) );
3540 checkCapacity( sm , 1UL, sm.nonZeros( 1UL ) );
3541 checkCapacity( tmat_, 30UL );
3542 checkCapacity( tmat_, 2UL, tmat_.nonZeros( 2UL ) );
3543 checkCapacity( tmat_, 3UL, tmat_.nonZeros( 3UL ) );
3544 }
3545
3546 {
3547 test_ = "Column-major Submatrix::trim( size_t )";
3548
3549 initialize();
3550
3551 OSMT sm = blaze::submatrix( tmat_, 1UL, 2UL, 3UL, 2UL );
3552
3553 // Increasing the row capacity of the matrix
3554 sm.reserve( 0UL, 10UL );
3555 sm.reserve( 1UL, 20UL );
3556
3557 checkRows ( sm , 3UL );
3558 checkColumns ( sm , 2UL );
3559 checkCapacity( sm , 30UL );
3560 checkCapacity( sm , 0UL, 10UL );
3561 checkCapacity( sm , 1UL, 20UL );
3562 checkCapacity( tmat_, 30UL );
3563 checkCapacity( tmat_, 2UL, 10UL );
3564 checkCapacity( tmat_, 3UL, 20UL );
3565
3566 // Trimming the 0th row
3567 sm.trim( 0UL );
3568
3569 checkRows ( sm , 3UL );
3570 checkColumns ( sm , 2UL );
3571 checkCapacity( sm , 30UL );
3572 checkCapacity( sm , 0UL, sm.nonZeros( 0UL ) );
3573 checkCapacity( sm , 1UL, 30UL - sm.nonZeros( 0UL ) );
3574 checkCapacity( tmat_, 30UL );
3575 checkCapacity( tmat_, 2UL, tmat_.nonZeros( 2UL ) );
3576 checkCapacity( tmat_, 3UL, 30UL - tmat_.nonZeros( 2UL ) );
3577
3578 // Trimming the 1st row
3579 sm.trim( 1UL );
3580
3581 checkRows ( sm , 3UL );
3582 checkColumns ( sm , 2UL );
3583 checkCapacity( sm , 30UL );
3584 checkCapacity( sm , 0UL, sm.nonZeros( 0UL ) );
3585 checkCapacity( sm , 1UL, sm.nonZeros( 1UL ) );
3586 checkCapacity( tmat_, 30UL );
3587 checkCapacity( tmat_, 2UL, tmat_.nonZeros( 2UL ) );
3588 checkCapacity( tmat_, 3UL, tmat_.nonZeros( 3UL ) );
3589 }
3590 }
3591 //*************************************************************************************************
3592
3593
3594 //*************************************************************************************************
3595 /*!\brief Test of the \c set() member function of the Submatrix class template.
3596 //
3597 // \return void
3598 // \exception std::runtime_error Error detected.
3599 //
3600 // This function performs a test of the \c set() member function of the Submatrix
3601 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
3602 */
testSet()3603 void SparseTest::testSet()
3604 {
3605 //=====================================================================================
3606 // Row-major submatrix tests
3607 //=====================================================================================
3608
3609 {
3610 test_ = "Row-major Submatrix::set()";
3611
3612 initialize();
3613
3614 SMT sm = blaze::submatrix( mat_, 0UL, 1UL, 2UL, 3UL );
3615
3616 // Setting a non-zero element at the end of the 0th row
3617 sm.set( 0UL, 2UL, 1 );
3618
3619 checkRows ( sm , 2UL );
3620 checkColumns ( sm , 3UL );
3621 checkNonZeros( sm , 2UL );
3622 checkRows ( mat_, 5UL );
3623 checkColumns ( mat_, 4UL );
3624 checkNonZeros( mat_, 11UL );
3625
3626 if( sm(0,0) != 0 || sm(0,1) != 0 || sm(0,2) != 1 ||
3627 sm(1,0) != 1 || sm(1,1) != 0 || sm(1,2) != 0 ) {
3628 std::ostringstream oss;
3629 oss << " Test: " << test_ << "\n"
3630 << " Error: Setting a non-zero element failed\n"
3631 << " Details:\n"
3632 << " Result:\n" << sm << "\n"
3633 << " Expected result:\n( 0 0 1 )\n( 1 0 0 )\n";
3634 throw std::runtime_error( oss.str() );
3635 }
3636
3637 // Setting a non-zero element at the beginning of the 0th row
3638 sm.set( 0UL, 0UL, 2 );
3639
3640 checkRows ( sm , 2UL );
3641 checkColumns ( sm , 3UL );
3642 checkNonZeros( sm , 3UL );
3643 checkRows ( mat_, 5UL );
3644 checkColumns ( mat_, 4UL );
3645 checkNonZeros( mat_, 12UL );
3646
3647 if( sm(0,0) != 2 || sm(0,1) != 0 || sm(0,2) != 1 ||
3648 sm(1,0) != 1 || sm(1,1) != 0 || sm(1,2) != 0 ) {
3649 std::ostringstream oss;
3650 oss << " Test: " << test_ << "\n"
3651 << " Error: Setting a non-zero element failed\n"
3652 << " Details:\n"
3653 << " Result:\n" << sm << "\n"
3654 << " Expected result:\n( 2 0 1 )\n( 1 0 0 )\n";
3655 throw std::runtime_error( oss.str() );
3656 }
3657
3658 // Setting a non-zero element at the center of the 0th row
3659 sm.set( 0UL, 1UL, 3 );
3660
3661 checkRows ( sm , 2UL );
3662 checkColumns ( sm , 3UL );
3663 checkNonZeros( sm , 4UL );
3664 checkRows ( mat_, 5UL );
3665 checkColumns ( mat_, 4UL );
3666 checkNonZeros( mat_, 13UL );
3667
3668 if( sm(0,0) != 2 || sm(0,1) != 3 || sm(0,2) != 1 ||
3669 sm(1,0) != 1 || sm(1,1) != 0 || sm(1,2) != 0 ) {
3670 std::ostringstream oss;
3671 oss << " Test: " << test_ << "\n"
3672 << " Error: Setting a non-zero element failed\n"
3673 << " Details:\n"
3674 << " Result:\n" << sm << "\n"
3675 << " Expected result:\n( 2 3 1 )\n( 1 0 0 )\n";
3676 throw std::runtime_error( oss.str() );
3677 }
3678
3679 // Setting an already existing element
3680 sm.set( 1UL, 0UL, 4 );
3681
3682 checkRows ( sm , 2UL );
3683 checkColumns ( sm , 3UL );
3684 checkNonZeros( sm , 4UL );
3685 checkRows ( mat_, 5UL );
3686 checkColumns ( mat_, 4UL );
3687 checkNonZeros( mat_, 13UL );
3688
3689 if( sm(0,0) != 2 || sm(0,1) != 3 || sm(0,2) != 1 ||
3690 sm(1,0) != 4 || sm(1,1) != 0 || sm(1,2) != 0 ) {
3691 std::ostringstream oss;
3692 oss << " Test: " << test_ << "\n"
3693 << " Error: Setting a non-zero element failed\n"
3694 << " Details:\n"
3695 << " Result:\n" << sm << "\n"
3696 << " Expected result:\n( 2 3 1 )\n( 4 0 0 )\n";
3697 throw std::runtime_error( oss.str() );
3698 }
3699 }
3700
3701
3702 //=====================================================================================
3703 // Column-major submatrix tests
3704 //=====================================================================================
3705
3706 {
3707 test_ = "Column-major Submatrix::set()";
3708
3709 initialize();
3710
3711 OSMT sm = blaze::submatrix( tmat_, 1UL, 0UL, 3UL, 2UL );
3712
3713 // Setting a non-zero element at the end of the 0th column
3714 sm.set( 2UL, 0UL, 1 );
3715
3716 checkRows ( sm , 3UL );
3717 checkColumns ( sm , 2UL );
3718 checkNonZeros( sm , 2UL );
3719 checkRows ( tmat_, 4UL );
3720 checkColumns ( tmat_, 5UL );
3721 checkNonZeros( tmat_, 11UL );
3722
3723 if( sm(0,0) != 0 || sm(0,1) != 1 ||
3724 sm(1,0) != 0 || sm(1,1) != 0 ||
3725 sm(2,0) != 1 || sm(2,1) != 0 ) {
3726 std::ostringstream oss;
3727 oss << " Test: " << test_ << "\n"
3728 << " Error: Setting a non-zero element failed\n"
3729 << " Details:\n"
3730 << " Result:\n" << sm << "\n"
3731 << " Expected result:\n( 0 1 )\n( 0 0 )\n( 0 0 )\n";
3732 throw std::runtime_error( oss.str() );
3733 }
3734
3735 // Setting a non-zero element at the beginning of the 0th column
3736 sm.set( 0UL, 0UL, 2 );
3737
3738 checkRows ( sm , 3UL );
3739 checkColumns ( sm , 2UL );
3740 checkNonZeros( sm , 3UL );
3741 checkRows ( tmat_, 4UL );
3742 checkColumns ( tmat_, 5UL );
3743 checkNonZeros( tmat_, 12UL );
3744
3745 if( sm(0,0) != 2 || sm(0,1) != 1 ||
3746 sm(1,0) != 0 || sm(1,1) != 0 ||
3747 sm(2,0) != 1 || sm(2,1) != 0 ) {
3748 std::ostringstream oss;
3749 oss << " Test: " << test_ << "\n"
3750 << " Error: Setting a non-zero element failed\n"
3751 << " Details:\n"
3752 << " Result:\n" << sm << "\n"
3753 << " Expected result:\n( 2 1 )\n( 0 0 )\n( 1 0 )\n";
3754 throw std::runtime_error( oss.str() );
3755 }
3756
3757 // Setting a non-zero element at the center of the 0th column
3758 sm.set( 1UL, 0UL, 3 );
3759
3760 checkRows ( sm , 3UL );
3761 checkColumns ( sm , 2UL );
3762 checkNonZeros( sm , 4UL );
3763 checkRows ( tmat_, 4UL );
3764 checkColumns ( tmat_, 5UL );
3765 checkNonZeros( tmat_, 13UL );
3766
3767 if( sm(0,0) != 2 || sm(0,1) != 1 ||
3768 sm(1,0) != 3 || sm(1,1) != 0 ||
3769 sm(2,0) != 1 || sm(2,1) != 0 ) {
3770 std::ostringstream oss;
3771 oss << " Test: " << test_ << "\n"
3772 << " Error: Setting a non-zero element failed\n"
3773 << " Details:\n"
3774 << " Result:\n" << sm << "\n"
3775 << " Expected result:\n( 2 1 )\n( 3 0 )\n( 1 0 )\n";
3776 throw std::runtime_error( oss.str() );
3777 }
3778
3779 // Setting an already existing element
3780 sm.set( 0UL, 1UL, 4 );
3781
3782 checkRows ( sm , 3UL );
3783 checkColumns ( sm , 2UL );
3784 checkNonZeros( sm , 4UL );
3785 checkRows ( tmat_, 4UL );
3786 checkColumns ( tmat_, 5UL );
3787 checkNonZeros( tmat_, 13UL );
3788
3789 if( sm(0,0) != 2 || sm(0,1) != 4 ||
3790 sm(1,0) != 3 || sm(1,1) != 0 ||
3791 sm(2,0) != 1 || sm(2,1) != 0 ) {
3792 std::ostringstream oss;
3793 oss << " Test: " << test_ << "\n"
3794 << " Error: Setting a non-zero element failed\n"
3795 << " Details:\n"
3796 << " Result:\n" << sm << "\n"
3797 << " Expected result:\n( 2 4 )\n( 3 0 )\n( 1 0 )\n";
3798 throw std::runtime_error( oss.str() );
3799 }
3800 }
3801 }
3802 //*************************************************************************************************
3803
3804
3805 //*************************************************************************************************
3806 /*!\brief Test of the \c insert() member function of the Submatrix class template.
3807 //
3808 // \return void
3809 // \exception std::runtime_error Error detected.
3810 //
3811 // This function performs a test of the \c insert() member function of the Submatrix
3812 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
3813 */
testInsert()3814 void SparseTest::testInsert()
3815 {
3816 //=====================================================================================
3817 // Row-major submatrix tests
3818 //=====================================================================================
3819
3820 {
3821 test_ = "Row-major Submatrix::insert()";
3822
3823 initialize();
3824
3825 SMT sm = blaze::submatrix( mat_, 0UL, 1UL, 2UL, 3UL );
3826
3827 // Inserting a non-zero element at the end of the 0th row
3828 sm.insert( 0UL, 2UL, 1 );
3829
3830 checkRows ( sm , 2UL );
3831 checkColumns ( sm , 3UL );
3832 checkNonZeros( sm , 2UL );
3833 checkRows ( mat_, 5UL );
3834 checkColumns ( mat_, 4UL );
3835 checkNonZeros( mat_, 11UL );
3836
3837 if( sm(0,0) != 0 || sm(0,1) != 0 || sm(0,2) != 1 ||
3838 sm(1,0) != 1 || sm(1,1) != 0 || sm(1,2) != 0 ) {
3839 std::ostringstream oss;
3840 oss << " Test: " << test_ << "\n"
3841 << " Error: Inserting a non-zero element failed\n"
3842 << " Details:\n"
3843 << " Result:\n" << sm << "\n"
3844 << " Expected result:\n( 0 0 1 )\n( 1 0 0 )\n";
3845 throw std::runtime_error( oss.str() );
3846 }
3847
3848 // Inserting a non-zero element at the beginning of the 0th row
3849 sm.insert( 0UL, 0UL, 2 );
3850
3851 checkRows ( sm , 2UL );
3852 checkColumns ( sm , 3UL );
3853 checkNonZeros( sm , 3UL );
3854 checkRows ( mat_, 5UL );
3855 checkColumns ( mat_, 4UL );
3856 checkNonZeros( mat_, 12UL );
3857
3858 if( sm(0,0) != 2 || sm(0,1) != 0 || sm(0,2) != 1 ||
3859 sm(1,0) != 1 || sm(1,1) != 0 || sm(1,2) != 0 ) {
3860 std::ostringstream oss;
3861 oss << " Test: " << test_ << "\n"
3862 << " Error: Inserting a non-zero element failed\n"
3863 << " Details:\n"
3864 << " Result:\n" << sm << "\n"
3865 << " Expected result:\n( 2 0 1 )\n( 1 0 0 )\n";
3866 throw std::runtime_error( oss.str() );
3867 }
3868
3869 // Inserting a non-zero element at the center of the 0th row
3870 sm.insert( 0UL, 1UL, 3 );
3871
3872 checkRows ( sm , 2UL );
3873 checkColumns ( sm , 3UL );
3874 checkNonZeros( sm , 4UL );
3875 checkRows ( mat_, 5UL );
3876 checkColumns ( mat_, 4UL );
3877 checkNonZeros( mat_, 13UL );
3878
3879 if( sm(0,0) != 2 || sm(0,1) != 3 || sm(0,2) != 1 ||
3880 sm(1,0) != 1 || sm(1,1) != 0 || sm(1,2) != 0 ) {
3881 std::ostringstream oss;
3882 oss << " Test: " << test_ << "\n"
3883 << " Error: Inserting a non-zero element failed\n"
3884 << " Details:\n"
3885 << " Result:\n" << sm << "\n"
3886 << " Expected result:\n( 2 3 1 )\n( 1 0 0 )\n";
3887 throw std::runtime_error( oss.str() );
3888 }
3889
3890 // Trying to insert an already existing element
3891 try {
3892 sm.insert( 1UL, 0UL, 4 );
3893
3894 std::ostringstream oss;
3895 oss << " Test: " << test_ << "\n"
3896 << " Error: Inserting an existing element succeeded\n"
3897 << " Details:\n"
3898 << " Result:\n" << sm << "\n"
3899 << " Expected result:\n( 2 3 1 )\n( 4 0 0 )\n";
3900 throw std::runtime_error( oss.str() );
3901 }
3902 catch( std::invalid_argument& ) {}
3903 }
3904
3905
3906 //=====================================================================================
3907 // Column-major submatrix tests
3908 //=====================================================================================
3909
3910 {
3911 test_ = "Column-major Submatrix::insert()";
3912
3913 initialize();
3914
3915 OSMT sm = blaze::submatrix( tmat_, 1UL, 0UL, 3UL, 2UL );
3916
3917 // Inserting a non-zero element at the end of the 0th column
3918 sm.insert( 2UL, 0UL, 1 );
3919
3920 checkRows ( sm , 3UL );
3921 checkColumns ( sm , 2UL );
3922 checkNonZeros( sm , 2UL );
3923 checkRows ( tmat_, 4UL );
3924 checkColumns ( tmat_, 5UL );
3925 checkNonZeros( tmat_, 11UL );
3926
3927 if( sm(0,0) != 0 || sm(0,1) != 1 ||
3928 sm(1,0) != 0 || sm(1,1) != 0 ||
3929 sm(2,0) != 1 || sm(2,1) != 0 ) {
3930 std::ostringstream oss;
3931 oss << " Test: " << test_ << "\n"
3932 << " Error: Inserting a non-zero element failed\n"
3933 << " Details:\n"
3934 << " Result:\n" << sm << "\n"
3935 << " Expected result:\n( 0 1 )\n( 0 0 )\n( 0 0 )\n";
3936 throw std::runtime_error( oss.str() );
3937 }
3938
3939 // Inserting a non-zero element at the beginning of the 0th column
3940 sm.insert( 0UL, 0UL, 2 );
3941
3942 checkRows ( sm , 3UL );
3943 checkColumns ( sm , 2UL );
3944 checkNonZeros( sm , 3UL );
3945 checkRows ( tmat_, 4UL );
3946 checkColumns ( tmat_, 5UL );
3947 checkNonZeros( tmat_, 12UL );
3948
3949 if( sm(0,0) != 2 || sm(0,1) != 1 ||
3950 sm(1,0) != 0 || sm(1,1) != 0 ||
3951 sm(2,0) != 1 || sm(2,1) != 0 ) {
3952 std::ostringstream oss;
3953 oss << " Test: " << test_ << "\n"
3954 << " Error: Inserting a non-zero element failed\n"
3955 << " Details:\n"
3956 << " Result:\n" << sm << "\n"
3957 << " Expected result:\n( 2 1 )\n( 0 0 )\n( 1 0 )\n";
3958 throw std::runtime_error( oss.str() );
3959 }
3960
3961 // Inserting a non-zero element at the center of the 0th column
3962 sm.insert( 1UL, 0UL, 3 );
3963
3964 checkRows ( sm , 3UL );
3965 checkColumns ( sm , 2UL );
3966 checkNonZeros( sm , 4UL );
3967 checkRows ( tmat_, 4UL );
3968 checkColumns ( tmat_, 5UL );
3969 checkNonZeros( tmat_, 13UL );
3970
3971 if( sm(0,0) != 2 || sm(0,1) != 1 ||
3972 sm(1,0) != 3 || sm(1,1) != 0 ||
3973 sm(2,0) != 1 || sm(2,1) != 0 ) {
3974 std::ostringstream oss;
3975 oss << " Test: " << test_ << "\n"
3976 << " Error: Inserting a non-zero element failed\n"
3977 << " Details:\n"
3978 << " Result:\n" << sm << "\n"
3979 << " Expected result:\n( 2 1 )\n( 3 0 )\n( 1 0 )\n";
3980 throw std::runtime_error( oss.str() );
3981 }
3982
3983 // Trying to insert an already existing element
3984 try {
3985 sm.insert( 0UL, 1UL, 4 );
3986
3987 std::ostringstream oss;
3988 oss << " Test: " << test_ << "\n"
3989 << " Error: Inserting an existing element succeeded\n"
3990 << " Details:\n"
3991 << " Result:\n" << sm << "\n"
3992 << " Expected result:\n( 2 4 )\n( 3 0 )\n( 1 0 )\n";
3993 throw std::runtime_error( oss.str() );
3994 }
3995 catch( std::invalid_argument& ) {}
3996 }
3997 }
3998 //*************************************************************************************************
3999
4000
4001 //*************************************************************************************************
4002 /*!\brief Test of the \c append() member function of the Submatrix class template.
4003 //
4004 // \return void
4005 // \exception std::runtime_error Error detected.
4006 //
4007 // This function performs a test of the \c append() member function of the Submatrix
4008 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
4009 */
testAppend()4010 void SparseTest::testAppend()
4011 {
4012 //=====================================================================================
4013 // Row-major submatrix tests
4014 //=====================================================================================
4015
4016 {
4017 test_ = "Row-major Submatrix::append()";
4018
4019 // Appending with pre-allocation in each row
4020 {
4021 mat_.reset();
4022
4023 // Initialization check
4024 SMT sm = blaze::submatrix( mat_, 0UL, 0UL, 4UL, 4UL );
4025 sm.reserve( 0UL, 2UL );
4026 sm.reserve( 2UL, 1UL );
4027 sm.reserve( 3UL, 2UL );
4028
4029 checkRows ( sm, 4UL );
4030 checkColumns ( sm, 4UL );
4031 checkCapacity( sm, 5UL );
4032 checkNonZeros( sm, 0UL );
4033 checkNonZeros( sm, 0UL, 0UL );
4034 checkNonZeros( sm, 1UL, 0UL );
4035 checkNonZeros( sm, 2UL, 0UL );
4036 checkNonZeros( sm, 3UL, 0UL );
4037
4038 // Appending one non-zero element
4039 sm.append( 2UL, 1UL, 1 );
4040
4041 checkRows ( sm, 4UL );
4042 checkColumns ( sm, 4UL );
4043 checkCapacity( sm, 5UL );
4044 checkNonZeros( sm, 1UL );
4045 checkNonZeros( sm, 0UL, 0UL );
4046 checkNonZeros( sm, 1UL, 0UL );
4047 checkNonZeros( sm, 2UL, 1UL );
4048 checkNonZeros( sm, 3UL, 0UL );
4049
4050 if( sm(2,1) != 1 ) {
4051 std::ostringstream oss;
4052 oss << " Test: " << test_ << "\n"
4053 << " Error: Append operation failed\n"
4054 << " Details:\n"
4055 << " Result:\n" << sm << "\n"
4056 << " Expected result:\n( 0 0 0 0 )\n( 0 0 0 0 )\n( 0 1 0 0 )\n( 0 0 0 0 )\n";
4057 throw std::runtime_error( oss.str() );
4058 }
4059
4060 // Appending two more non-zero elements
4061 sm.append( 0UL, 0UL, 2 );
4062 sm.append( 0UL, 3UL, 3 );
4063
4064 checkRows ( sm, 4UL );
4065 checkColumns ( sm, 4UL );
4066 checkCapacity( sm, 5UL );
4067 checkNonZeros( sm, 3UL );
4068 checkNonZeros( sm, 0UL, 2UL );
4069 checkNonZeros( sm, 1UL, 0UL );
4070 checkNonZeros( sm, 2UL, 1UL );
4071 checkNonZeros( sm, 3UL, 0UL );
4072
4073 if( sm(2,1) != 1 || sm(0,0) != 2 || sm(0,3) != 3 ) {
4074 std::ostringstream oss;
4075 oss << " Test: " << test_ << "\n"
4076 << " Error: Append operation failed\n"
4077 << " Details:\n"
4078 << " Result:\n" << sm << "\n"
4079 << " Expected result:\n( 2 0 0 3 )\n( 0 0 0 0 )\n( 0 1 0 0 )\n( 0 0 0 0 )\n";
4080 throw std::runtime_error( oss.str() );
4081 }
4082
4083 // Appending two more non-zero elements
4084 sm.append( 3UL, 1UL, 4 );
4085 sm.append( 3UL, 2UL, 5 );
4086
4087 checkRows ( sm, 4UL );
4088 checkColumns ( sm, 4UL );
4089 checkCapacity( sm, 5UL );
4090 checkNonZeros( sm, 5UL );
4091 checkNonZeros( sm, 0UL, 2UL );
4092 checkNonZeros( sm, 1UL, 0UL );
4093 checkNonZeros( sm, 2UL, 1UL );
4094 checkNonZeros( sm, 3UL, 2UL );
4095
4096 if( sm(2,1) != 1 || sm(0,0) != 2 || sm(0,3) != 3 ||
4097 sm(3,1) != 4 || sm(3,2) != 5 ) {
4098 std::ostringstream oss;
4099 oss << " Test: " << test_ << "\n"
4100 << " Error: Append operation failed\n"
4101 << " Details:\n"
4102 << " Result:\n" << sm << "\n"
4103 << " Expected result:\n( 2 0 0 3 )\n( 0 0 0 0 )\n( 0 1 0 0 )\n( 0 4 5 0 )\n";
4104 throw std::runtime_error( oss.str() );
4105 }
4106 }
4107
4108 // Appending with row finalization
4109 {
4110 mat_.reset();
4111
4112 // Initialization check
4113 SMT sm = blaze::submatrix( mat_, 0UL, 0UL, 4UL, 4UL );
4114 sm.reserve( 0UL, 2UL );
4115 sm.reserve( 2UL, 1UL );
4116 sm.reserve( 3UL, 2UL );
4117
4118 // Appending one non-zero element
4119 sm.append( 0UL, 1UL, 1 );
4120 sm.finalize( 0UL );
4121
4122 checkRows ( sm, 4UL );
4123 checkColumns ( sm, 4UL );
4124 checkCapacity( sm, 5UL );
4125 checkNonZeros( sm, 1UL );
4126 checkNonZeros( sm, 0UL, 1UL );
4127 checkNonZeros( sm, 1UL, 0UL );
4128 checkNonZeros( sm, 2UL, 0UL );
4129 checkNonZeros( sm, 3UL, 0UL );
4130
4131 if( sm(0,1) != 1 ) {
4132 std::ostringstream oss;
4133 oss << " Test: " << test_ << "\n"
4134 << " Error: Append operation failed\n"
4135 << " Details:\n"
4136 << " Result:\n" << sm << "\n"
4137 << " Expected result:\n( 0 1 0 0 )\n( 0 0 0 0 )\n( 0 0 0 0 )\n( 0 0 0 0 )\n";
4138 throw std::runtime_error( oss.str() );
4139 }
4140
4141 // Appending two more non-zero elements
4142 sm.append( 1UL, 1UL, 2 );
4143 sm.append( 1UL, 3UL, 3 );
4144 sm.finalize( 1UL );
4145
4146 checkRows ( sm, 4UL );
4147 checkColumns ( sm, 4UL );
4148 checkCapacity( sm, 5UL );
4149 checkNonZeros( sm, 3UL );
4150 checkNonZeros( sm, 0UL, 1UL );
4151 checkNonZeros( sm, 1UL, 2UL );
4152 checkNonZeros( sm, 2UL, 0UL );
4153 checkNonZeros( sm, 3UL, 0UL );
4154
4155 if( sm(0,1) != 1 || sm(1,1) != 2 || sm(1,3) != 3 ) {
4156 std::ostringstream oss;
4157 oss << " Test: " << test_ << "\n"
4158 << " Error: Append operation failed\n"
4159 << " Details:\n"
4160 << " Result:\n" << sm << "\n"
4161 << " Expected result:\n( 0 1 0 0 )\n( 0 2 0 3 )\n( 0 0 0 0 )\n( 0 0 0 0 )\n";
4162 throw std::runtime_error( oss.str() );
4163 }
4164
4165 // Appending two more non-zero elements
4166 sm.append( 3UL, 0UL, 4 );
4167 sm.append( 3UL, 1UL, 5 );
4168 sm.finalize( 1UL );
4169
4170 checkRows ( sm, 4UL );
4171 checkColumns ( sm, 4UL );
4172 checkCapacity( sm, 5UL );
4173 checkNonZeros( sm, 5UL );
4174 checkNonZeros( sm, 0UL, 1UL );
4175 checkNonZeros( sm, 1UL, 2UL );
4176 checkNonZeros( sm, 2UL, 0UL );
4177 checkNonZeros( sm, 3UL, 2UL );
4178
4179 if( sm(0,1) != 1 || sm(1,1) != 2 || sm(1,3) != 3 ||
4180 sm(3,0) != 4 || sm(3,1) != 5 ) {
4181 std::ostringstream oss;
4182 oss << " Test: " << test_ << "\n"
4183 << " Error: Append operation failed\n"
4184 << " Details:\n"
4185 << " Result:\n" << sm << "\n"
4186 << " Expected result:\n( 0 1 0 0 )\n( 0 2 0 3 )\n( 0 0 0 0 )\n( 4 5 0 0 )\n";
4187 throw std::runtime_error( oss.str() );
4188 }
4189 }
4190 }
4191
4192
4193 //=====================================================================================
4194 // Column-major submatrix tests
4195 //=====================================================================================
4196
4197 {
4198 test_ = "Column-major Submatrix::append()";
4199
4200 // Appending with pre-allocation in each row
4201 {
4202 tmat_.reset();
4203
4204 // Initialization check
4205 OSMT sm = blaze::submatrix( tmat_, 0UL, 0UL, 4UL, 4UL );
4206 sm.reserve( 0UL, 2UL );
4207 sm.reserve( 2UL, 1UL );
4208 sm.reserve( 3UL, 2UL );
4209
4210 checkRows ( sm, 4UL );
4211 checkColumns ( sm, 4UL );
4212 checkCapacity( sm, 5UL );
4213 checkNonZeros( sm, 0UL );
4214 checkNonZeros( sm, 0UL, 0UL );
4215 checkNonZeros( sm, 1UL, 0UL );
4216 checkNonZeros( sm, 2UL, 0UL );
4217 checkNonZeros( sm, 3UL, 0UL );
4218
4219 // Appending one non-zero element
4220 sm.append( 1UL, 2UL, 1 );
4221
4222 checkRows ( sm, 4UL );
4223 checkColumns ( sm, 4UL );
4224 checkCapacity( sm, 5UL );
4225 checkNonZeros( sm, 1UL );
4226 checkNonZeros( sm, 0UL, 0UL );
4227 checkNonZeros( sm, 1UL, 0UL );
4228 checkNonZeros( sm, 2UL, 1UL );
4229 checkNonZeros( sm, 3UL, 0UL );
4230
4231 if( sm(1,2) != 1 ) {
4232 std::ostringstream oss;
4233 oss << " Test: " << test_ << "\n"
4234 << " Error: Append operation failed\n"
4235 << " Details:\n"
4236 << " Result:\n" << sm << "\n"
4237 << " Expected result:\n( 0 0 0 0 )\n( 0 0 1 0 )\n( 0 0 0 0 )\n( 0 0 0 0 )\n";
4238 throw std::runtime_error( oss.str() );
4239 }
4240
4241 // Appending two more non-zero elements
4242 sm.append( 0UL, 0UL, 2 );
4243 sm.append( 3UL, 0UL, 3 );
4244
4245 checkRows ( sm, 4UL );
4246 checkColumns ( sm, 4UL );
4247 checkCapacity( sm, 5UL );
4248 checkNonZeros( sm, 3UL );
4249 checkNonZeros( sm, 0UL, 2UL );
4250 checkNonZeros( sm, 1UL, 0UL );
4251 checkNonZeros( sm, 2UL, 1UL );
4252 checkNonZeros( sm, 3UL, 0UL );
4253
4254 if( sm(1,2) != 1 || sm(0,0) != 2 || sm(3,0) != 3 ) {
4255 std::ostringstream oss;
4256 oss << " Test: " << test_ << "\n"
4257 << " Error: Append operation failed\n"
4258 << " Details:\n"
4259 << " Result:\n" << sm << "\n"
4260 << " Expected result:\n( 2 0 0 0 )\n( 0 0 1 0 )\n( 0 0 0 0 )\n( 3 0 0 0 )\n";
4261 throw std::runtime_error( oss.str() );
4262 }
4263
4264 // Appending two more non-zero elements
4265 sm.append( 1UL, 3UL, 4 );
4266 sm.append( 2UL, 3UL, 5 );
4267
4268 checkRows ( sm, 4UL );
4269 checkColumns ( sm, 4UL );
4270 checkCapacity( sm, 5UL );
4271 checkNonZeros( sm, 5UL );
4272 checkNonZeros( sm, 0UL, 2UL );
4273 checkNonZeros( sm, 1UL, 0UL );
4274 checkNonZeros( sm, 2UL, 1UL );
4275 checkNonZeros( sm, 3UL, 2UL );
4276
4277 if( sm(1,2) != 1 || sm(0,0) != 2 || sm(3,0) != 3 ||
4278 sm(1,3) != 4 || sm(2,3) != 5 ) {
4279 std::ostringstream oss;
4280 oss << " Test: " << test_ << "\n"
4281 << " Error: Append operation failed\n"
4282 << " Details:\n"
4283 << " Result:\n" << sm << "\n"
4284 << " Expected result:\n( 2 0 0 0 )\n( 0 0 1 4 )\n( 0 0 0 5 )\n( 3 0 0 0 )\n";
4285 throw std::runtime_error( oss.str() );
4286 }
4287 }
4288
4289 // Appending with row finalization
4290 {
4291 tmat_.reset();
4292
4293 // Initialization check
4294 OSMT sm = blaze::submatrix( tmat_, 0UL, 0UL, 4UL, 4UL );
4295 sm.reserve( 0UL, 2UL );
4296 sm.reserve( 2UL, 1UL );
4297 sm.reserve( 3UL, 2UL );
4298
4299 // Appending one non-zero element
4300 sm.append( 1UL, 0UL, 1 );
4301 sm.finalize( 0UL );
4302
4303 checkRows ( sm, 4UL );
4304 checkColumns ( sm, 4UL );
4305 checkCapacity( sm, 5UL );
4306 checkNonZeros( sm, 1UL );
4307 checkNonZeros( sm, 0UL, 1UL );
4308 checkNonZeros( sm, 1UL, 0UL );
4309 checkNonZeros( sm, 2UL, 0UL );
4310 checkNonZeros( sm, 3UL, 0UL );
4311
4312 if( sm(1,0) != 1 ) {
4313 std::ostringstream oss;
4314 oss << " Test: " << test_ << "\n"
4315 << " Error: Append operation failed\n"
4316 << " Details:\n"
4317 << " Result:\n" << sm << "\n"
4318 << " Expected result:\n( 0 0 0 0 )\n( 1 0 0 0 )\n( 0 0 0 0 )\n( 0 0 0 0 )\n";
4319 throw std::runtime_error( oss.str() );
4320 }
4321
4322 // Appending two more non-zero elements
4323 sm.append( 1UL, 1UL, 2 );
4324 sm.append( 3UL, 1UL, 3 );
4325 sm.finalize( 1UL );
4326
4327 checkRows ( sm, 4UL );
4328 checkColumns ( sm, 4UL );
4329 checkCapacity( sm, 5UL );
4330 checkNonZeros( sm, 3UL );
4331 checkNonZeros( sm, 0UL, 1UL );
4332 checkNonZeros( sm, 1UL, 2UL );
4333 checkNonZeros( sm, 2UL, 0UL );
4334 checkNonZeros( sm, 3UL, 0UL );
4335
4336 if( sm(1,0) != 1 || sm(1,1) != 2 || sm(3,1) != 3 ) {
4337 std::ostringstream oss;
4338 oss << " Test: " << test_ << "\n"
4339 << " Error: Append operation failed\n"
4340 << " Details:\n"
4341 << " Result:\n" << sm << "\n"
4342 << " Expected result:\n( 0 0 0 0 )\n( 1 2 0 0 )\n( 0 0 0 0 )\n( 0 3 0 0 )\n";
4343 throw std::runtime_error( oss.str() );
4344 }
4345
4346 // Appending two more non-zero elements
4347 sm.append( 0UL, 3UL, 4 );
4348 sm.append( 1UL, 3UL, 5 );
4349 sm.finalize( 1UL );
4350
4351 checkRows ( sm, 4UL );
4352 checkColumns ( sm, 4UL );
4353 checkCapacity( sm, 5UL );
4354 checkNonZeros( sm, 5UL );
4355 checkNonZeros( sm, 0UL, 1UL );
4356 checkNonZeros( sm, 1UL, 2UL );
4357 checkNonZeros( sm, 2UL, 0UL );
4358 checkNonZeros( sm, 3UL, 2UL );
4359
4360 if( sm(1,0) != 1 || sm(1,1) != 2 || sm(3,1) != 3 ||
4361 sm(0,3) != 4 || sm(1,3) != 5 ) {
4362 std::ostringstream oss;
4363 oss << " Test: " << test_ << "\n"
4364 << " Error: Append operation failed\n"
4365 << " Details:\n"
4366 << " Result:\n" << sm << "\n"
4367 << " Expected result:\n( 0 0 0 4 )\n( 1 2 0 5 )\n( 0 0 0 0 )\n( 0 3 0 0 )\n";
4368 throw std::runtime_error( oss.str() );
4369 }
4370 }
4371 }
4372 }
4373 //*************************************************************************************************
4374
4375
4376 //*************************************************************************************************
4377 /*!\brief Test of the \c erase() member function of the Submatrix class template.
4378 //
4379 // \return void
4380 // \exception std::runtime_error Error detected.
4381 //
4382 // This function performs a test of the \c erase() member function of the Submatrix
4383 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
4384 */
testErase()4385 void SparseTest::testErase()
4386 {
4387 //=====================================================================================
4388 // Row-major index-based erase function
4389 //=====================================================================================
4390
4391 {
4392 test_ = "Row-major Submatrix::erase( size_t, size_t )";
4393
4394 initialize();
4395
4396 SMT sm = blaze::submatrix( mat_, 3UL, 1UL, 2UL, 3UL );
4397
4398 // Erasing the non-zero element at the end of the 1st row
4399 sm.erase( 1UL, 2UL );
4400
4401 checkRows ( sm , 2UL );
4402 checkColumns ( sm , 3UL );
4403 checkNonZeros( sm , 5UL );
4404 checkRows ( mat_, 5UL );
4405 checkColumns ( mat_, 4UL );
4406 checkNonZeros( mat_, 9UL );
4407
4408 if( sm(0,0) != 4 || sm(0,1) != 5 || sm(0,2) != -6 ||
4409 sm(1,0) != -8 || sm(1,1) != 9 || sm(1,2) != 0 ) {
4410 std::ostringstream oss;
4411 oss << " Test: " << test_ << "\n"
4412 << " Error: Erasing a non-zero element failed\n"
4413 << " Details:\n"
4414 << " Result:\n" << sm << "\n"
4415 << " Expected result:\n( 4 5 -6 )\n( -8 9 0 )\n";
4416 throw std::runtime_error( oss.str() );
4417 }
4418
4419 // Erasing the non-zero element at the beginning of the 1st row
4420 sm.erase( 1UL, 0UL );
4421
4422 checkRows ( sm , 2UL );
4423 checkColumns ( sm , 3UL );
4424 checkNonZeros( sm , 4UL );
4425 checkRows ( mat_, 5UL );
4426 checkColumns ( mat_, 4UL );
4427 checkNonZeros( mat_, 8UL );
4428
4429 if( sm(0,0) != 4 || sm(0,1) != 5 || sm(0,2) != -6 ||
4430 sm(1,0) != 0 || sm(1,1) != 9 || sm(1,2) != 0 ) {
4431 std::ostringstream oss;
4432 oss << " Test: " << test_ << "\n"
4433 << " Error: Erasing a non-zero element failed\n"
4434 << " Details:\n"
4435 << " Result:\n" << sm << "\n"
4436 << " Expected result:\n( 4 5 -6 )\n( 0 9 0 )\n";
4437 throw std::runtime_error( oss.str() );
4438 }
4439
4440 // Erasing the non-zero element at the beginning of the 1st row
4441 sm.erase( 1UL, 1UL );
4442
4443 checkRows ( sm , 2UL );
4444 checkColumns ( sm , 3UL );
4445 checkNonZeros( sm , 3UL );
4446 checkRows ( mat_, 5UL );
4447 checkColumns ( mat_, 4UL );
4448 checkNonZeros( mat_, 7UL );
4449
4450 if( sm(0,0) != 4 || sm(0,1) != 5 || sm(0,2) != -6 ||
4451 sm(1,0) != 0 || sm(1,1) != 0 || sm(1,2) != 0 ) {
4452 std::ostringstream oss;
4453 oss << " Test: " << test_ << "\n"
4454 << " Error: Erasing a non-zero element failed\n"
4455 << " Details:\n"
4456 << " Result:\n" << sm << "\n"
4457 << " Expected result:\n( 4 5 -6 )\n( 0 0 0 )\n";
4458 throw std::runtime_error( oss.str() );
4459 }
4460
4461 // Trying to erase an already erased element
4462 sm.erase( 1UL, 2UL );
4463
4464 checkRows ( sm , 2UL );
4465 checkColumns ( sm , 3UL );
4466 checkNonZeros( sm , 3UL );
4467 checkRows ( mat_, 5UL );
4468 checkColumns ( mat_, 4UL );
4469 checkNonZeros( mat_, 7UL );
4470
4471 if( sm(0,0) != 4 || sm(0,1) != 5 || sm(0,2) != -6 ||
4472 sm(1,0) != 0 || sm(1,1) != 0 || sm(1,2) != 0 ) {
4473 std::ostringstream oss;
4474 oss << " Test: " << test_ << "\n"
4475 << " Error: Erasing a zero element failed\n"
4476 << " Details:\n"
4477 << " Result:\n" << sm << "\n"
4478 << " Expected result:\n( 4 5 -6 )\n( 0 0 0 )\n";
4479 throw std::runtime_error( oss.str() );
4480 }
4481 }
4482
4483
4484 //=====================================================================================
4485 // Row-major iterator-based erase function
4486 //=====================================================================================
4487
4488 {
4489 test_ = "Row-major Submatrix::erase( size_t, Iterator )";
4490
4491 initialize();
4492
4493 SMT sm = blaze::submatrix( mat_, 3UL, 1UL, 2UL, 3UL );
4494
4495 // Erasing the non-zero element at the end of the 1st row
4496 {
4497 SMT::Iterator pos = sm.erase( 1UL, sm.find( 1UL, 2UL ) );
4498
4499 checkRows ( sm , 2UL );
4500 checkColumns ( sm , 3UL );
4501 checkNonZeros( sm , 5UL );
4502 checkRows ( mat_, 5UL );
4503 checkColumns ( mat_, 4UL );
4504 checkNonZeros( mat_, 9UL );
4505
4506 if( pos != sm.end( 1UL ) ) {
4507 std::ostringstream oss;
4508 oss << " Test: " << test_ << "\n"
4509 << " Error: Invalid iterator returned\n"
4510 << " Details:\n"
4511 << " Expected result: the end() iterator\n";
4512 throw std::runtime_error( oss.str() );
4513 }
4514
4515 if( sm(0,0) != 4 || sm(0,1) != 5 || sm(0,2) != -6 ||
4516 sm(1,0) != -8 || sm(1,1) != 9 || sm(1,2) != 0 ) {
4517 std::ostringstream oss;
4518 oss << " Test: " << test_ << "\n"
4519 << " Error: Erasing a non-zero element failed\n"
4520 << " Details:\n"
4521 << " Result:\n" << sm << "\n"
4522 << " Expected result:\n( 4 5 -6 )\n( -8 9 0 )\n";
4523 throw std::runtime_error( oss.str() );
4524 }
4525 }
4526
4527 // Erasing the non-zero element at the beginning of the 1st row
4528 {
4529 SMT::Iterator pos = sm.erase( 1UL, sm.find( 1UL, 0UL ) );
4530
4531 checkRows ( sm , 2UL );
4532 checkColumns ( sm , 3UL );
4533 checkNonZeros( sm , 4UL );
4534 checkRows ( mat_, 5UL );
4535 checkColumns ( mat_, 4UL );
4536 checkNonZeros( mat_, 8UL );
4537
4538 if( pos->value() != 9 || pos->index() != 1 ) {
4539 std::ostringstream oss;
4540 oss << " Test: " << test_ << "\n"
4541 << " Error: Invalid iterator returned\n"
4542 << " Details:\n"
4543 << " Value: " << pos->value() << "\n"
4544 << " Index: " << pos->index() << "\n"
4545 << " Expected value: 9\n"
4546 << " Expected index: 1\n";
4547 throw std::runtime_error( oss.str() );
4548 }
4549
4550 if( sm(0,0) != 4 || sm(0,1) != 5 || sm(0,2) != -6 ||
4551 sm(1,0) != 0 || sm(1,1) != 9 || sm(1,2) != 0 ) {
4552 std::ostringstream oss;
4553 oss << " Test: " << test_ << "\n"
4554 << " Error: Erasing a non-zero element failed\n"
4555 << " Details:\n"
4556 << " Result:\n" << sm << "\n"
4557 << " Expected result:\n( 4 5 -6 )\n( 0 9 0 )\n";
4558 throw std::runtime_error( oss.str() );
4559 }
4560 }
4561
4562 // Erasing the non-zero element at the beginning of the 1st row
4563 {
4564 SMT::Iterator pos = sm.erase( 1UL, sm.find( 1UL, 1UL ) );
4565
4566 checkRows ( sm , 2UL );
4567 checkColumns ( sm , 3UL );
4568 checkNonZeros( sm , 3UL );
4569 checkRows ( mat_, 5UL );
4570 checkColumns ( mat_, 4UL );
4571 checkNonZeros( mat_, 7UL );
4572
4573 if( pos != sm.end( 1UL ) ) {
4574 std::ostringstream oss;
4575 oss << " Test: " << test_ << "\n"
4576 << " Error: Invalid iterator returned\n"
4577 << " Details:\n"
4578 << " Expected result: the end() iterator\n";
4579 throw std::runtime_error( oss.str() );
4580 }
4581
4582 if( sm(0,0) != 4 || sm(0,1) != 5 || sm(0,2) != -6 ||
4583 sm(1,0) != 0 || sm(1,1) != 0 || sm(1,2) != 0 ) {
4584 std::ostringstream oss;
4585 oss << " Test: " << test_ << "\n"
4586 << " Error: Erasing a non-zero element failed\n"
4587 << " Details:\n"
4588 << " Result:\n" << sm << "\n"
4589 << " Expected result:\n( 4 5 -6 )\n( 0 0 0 )\n";
4590 throw std::runtime_error( oss.str() );
4591 }
4592 }
4593
4594 // Trying to erase an already erased element
4595 {
4596 SMT::Iterator pos = sm.erase( 1UL, sm.find( 1UL, 2UL ) );
4597
4598 checkRows ( sm , 2UL );
4599 checkColumns ( sm , 3UL );
4600 checkNonZeros( sm , 3UL );
4601 checkRows ( mat_, 5UL );
4602 checkColumns ( mat_, 4UL );
4603 checkNonZeros( mat_, 7UL );
4604
4605 if( pos != sm.end( 1UL ) ) {
4606 std::ostringstream oss;
4607 oss << " Test: " << test_ << "\n"
4608 << " Error: Invalid iterator returned\n"
4609 << " Details:\n"
4610 << " Expected result: the end() iterator\n";
4611 throw std::runtime_error( oss.str() );
4612 }
4613
4614 if( sm(0,0) != 4 || sm(0,1) != 5 || sm(0,2) != -6 ||
4615 sm(1,0) != 0 || sm(1,1) != 0 || sm(1,2) != 0 ) {
4616 std::ostringstream oss;
4617 oss << " Test: " << test_ << "\n"
4618 << " Error: Erasing a zero element failed\n"
4619 << " Details:\n"
4620 << " Result:\n" << sm << "\n"
4621 << " Expected result:\n( 4 5 -6 )\n( 0 0 0 )\n";
4622 throw std::runtime_error( oss.str() );
4623 }
4624 }
4625 }
4626
4627
4628 //=====================================================================================
4629 // Row-major iterator-range-based erase function
4630 //=====================================================================================
4631
4632 {
4633 test_ = "Row-major Submatrix::erase( size_t, Iterator, Iterator )";
4634
4635 initialize();
4636
4637 SMT sm = blaze::submatrix( mat_, 3UL, 0UL, 2UL, 4UL );
4638
4639 // Erasing the 0th row
4640 {
4641 SMT::Iterator pos = sm.erase( 0UL, sm.begin( 0UL ), sm.end( 0UL ) );
4642
4643 checkRows ( sm , 2UL );
4644 checkColumns ( sm , 4UL );
4645 checkNonZeros( sm , 4UL );
4646 checkRows ( mat_, 5UL );
4647 checkColumns ( mat_, 4UL );
4648 checkNonZeros( mat_, 7UL );
4649
4650 if( pos != sm.end( 0UL ) ) {
4651 std::ostringstream oss;
4652 oss << " Test: " << test_ << "\n"
4653 << " Error: Invalid iterator returned\n"
4654 << " Details:\n"
4655 << " Expected result: the end() iterator\n";
4656 throw std::runtime_error( oss.str() );
4657 }
4658
4659 if( sm(0,0) != 0 || sm(0,1) != 0 || sm(0,2) != 0 || sm(0,3) != 0 ||
4660 sm(1,0) != 7 || sm(1,1) != -8 || sm(1,2) != 9 || sm(1,3) != 10 ) {
4661 std::ostringstream oss;
4662 oss << " Test: " << test_ << "\n"
4663 << " Error: Erasing the 0th row failed\n"
4664 << " Details:\n"
4665 << " Result:\n" << sm << "\n"
4666 << " Expected result:\n( 0 0 0 0 )\n( 7 -8 9 10 )\n";
4667 throw std::runtime_error( oss.str() );
4668 }
4669 }
4670
4671 // Erasing the first half of the 1st row
4672 {
4673 SMT::Iterator pos = sm.erase( 1UL, sm.begin( 1UL ), sm.find( 1UL, 2UL ) );
4674
4675 checkRows ( sm , 2UL );
4676 checkColumns ( sm , 4UL );
4677 checkNonZeros( sm , 2UL );
4678 checkRows ( mat_, 5UL );
4679 checkColumns ( mat_, 4UL );
4680 checkNonZeros( mat_, 5UL );
4681
4682 if( pos->value() != 9 || pos->index() != 2 ) {
4683 std::ostringstream oss;
4684 oss << " Test: " << test_ << "\n"
4685 << " Error: Invalid iterator returned\n"
4686 << " Details:\n"
4687 << " Value: " << pos->value() << "\n"
4688 << " Index: " << pos->index() << "\n"
4689 << " Expected value: 9\n"
4690 << " Expected index: 2\n";
4691 throw std::runtime_error( oss.str() );
4692 }
4693
4694 if( sm(0,0) != 0 || sm(0,1) != 0 || sm(0,2) != 0 || sm(0,3) != 0 ||
4695 sm(1,0) != 0 || sm(1,1) != 0 || sm(1,2) != 9 || sm(1,3) != 10 ) {
4696 std::ostringstream oss;
4697 oss << " Test: " << test_ << "\n"
4698 << " Error: Erasing the first half of the 1st row failed\n"
4699 << " Details:\n"
4700 << " Result:\n" << sm << "\n"
4701 << " Expected result:\n( 0 0 0 0 )\n( 0 0 9 10 )\n";
4702 throw std::runtime_error( oss.str() );
4703 }
4704 }
4705
4706 // Erasing the second half of the 1st row
4707 {
4708 SMT::Iterator pos = sm.erase( 1UL, sm.find( 1UL, 2UL ), sm.end( 1UL ) );
4709
4710 checkRows ( sm , 2UL );
4711 checkColumns ( sm , 4UL );
4712 checkNonZeros( sm , 0UL );
4713 checkRows ( mat_, 5UL );
4714 checkColumns ( mat_, 4UL );
4715 checkNonZeros( mat_, 3UL );
4716
4717 if( pos != sm.end( 1UL ) ) {
4718 std::ostringstream oss;
4719 oss << " Test: " << test_ << "\n"
4720 << " Error: Invalid iterator returned\n"
4721 << " Details:\n"
4722 << " Expected result: the end() iterator\n";
4723 throw std::runtime_error( oss.str() );
4724 }
4725
4726 if( sm(0,0) != 0 || sm(0,1) != 0 || sm(0,2) != 0 || sm(0,3) != 0 ||
4727 sm(1,0) != 0 || sm(1,1) != 0 || sm(1,2) != 0 || sm(1,3) != 0 ) {
4728 std::ostringstream oss;
4729 oss << " Test: " << test_ << "\n"
4730 << " Error: Erasing the second half of the 1st row failed\n"
4731 << " Details:\n"
4732 << " Result:\n" << sm << "\n"
4733 << " Expected result:\n( 0 0 0 0 )\n( 0 0 0 0 )\n";
4734 throw std::runtime_error( oss.str() );
4735 }
4736 }
4737
4738 // Trying to erase an empty range
4739 {
4740 SMT::Iterator pos = sm.erase( 1UL, sm.begin( 1UL ), sm.begin( 1UL ) );
4741
4742 checkRows ( sm , 2UL );
4743 checkColumns ( sm , 4UL );
4744 checkNonZeros( sm , 0UL );
4745 checkRows ( mat_, 5UL );
4746 checkColumns ( mat_, 4UL );
4747 checkNonZeros( mat_, 3UL );
4748
4749 if( pos != sm.begin( 1UL ) ) {
4750 std::ostringstream oss;
4751 oss << " Test: " << test_ << "\n"
4752 << " Error: Invalid iterator returned\n"
4753 << " Details:\n"
4754 << " Expected result: the given end() iterator\n";
4755 throw std::runtime_error( oss.str() );
4756 }
4757
4758 if( sm(0,0) != 0 || sm(0,1) != 0 || sm(0,2) != 0 || sm(0,3) != 0 ||
4759 sm(1,0) != 0 || sm(1,1) != 0 || sm(1,2) != 0 || sm(1,3) != 0 ) {
4760 std::ostringstream oss;
4761 oss << " Test: " << test_ << "\n"
4762 << " Error: Erasing an empty range failed\n"
4763 << " Details:\n"
4764 << " Result:\n" << sm << "\n"
4765 << " Expected result:\n( 0 0 0 0 )\n( 0 0 0 0 )\n";
4766 throw std::runtime_error( oss.str() );
4767 }
4768 }
4769 }
4770
4771
4772 //=====================================================================================
4773 // Row-major erase function with predicate
4774 //=====================================================================================
4775
4776 {
4777 test_ = "Row-major Submatrix::erase( Predicate )";
4778
4779 initialize();
4780
4781 SMT sm = blaze::submatrix( mat_, 3UL, 1UL, 2UL, 3UL );
4782
4783 // Erasing a selection of elements
4784 sm.erase( []( int value ) { return value == 4 || value == 10; } );
4785
4786 checkRows ( sm , 2UL );
4787 checkColumns ( sm , 3UL );
4788 checkNonZeros( sm , 4UL );
4789 checkRows ( mat_, 5UL );
4790 checkColumns ( mat_, 4UL );
4791 checkNonZeros( mat_, 8UL );
4792
4793 if( sm(0,0) != 0 || sm(0,1) != 5 || sm(0,2) != -6 ||
4794 sm(1,0) != -8 || sm(1,1) != 9 || sm(1,2) != 0 ) {
4795 std::ostringstream oss;
4796 oss << " Test: " << test_ << "\n"
4797 << " Error: Erasing a selection of elements failed\n"
4798 << " Details:\n"
4799 << " Result:\n" << sm << "\n"
4800 << " Expected result:\n( 0 5 -6 )\n( -8 9 0 )\n";
4801 throw std::runtime_error( oss.str() );
4802 }
4803
4804 // Trying to erase all elements with value 1
4805 sm.erase( []( int value ){ return value == 1; } );
4806
4807 checkRows ( sm , 2UL );
4808 checkColumns ( sm , 3UL );
4809 checkNonZeros( sm , 4UL );
4810 checkRows ( mat_, 5UL );
4811 checkColumns ( mat_, 4UL );
4812 checkNonZeros( mat_, 8UL );
4813
4814 if( sm(0,0) != 0 || sm(0,1) != 5 || sm(0,2) != -6 ||
4815 sm(1,0) != -8 || sm(1,1) != 9 || sm(1,2) != 0 ) {
4816 std::ostringstream oss;
4817 oss << " Test: " << test_ << "\n"
4818 << " Error: Erasing all elements with value 1 failed\n"
4819 << " Details:\n"
4820 << " Result:\n" << sm << "\n"
4821 << " Expected result:\n( 0 5 -6 )\n( -8 9 0 )\n";
4822 throw std::runtime_error( oss.str() );
4823 }
4824 }
4825
4826
4827 //=====================================================================================
4828 // Row-major iterator-range-based erase function with predicate
4829 //=====================================================================================
4830
4831 {
4832 test_ = "Row-major Submatrix::erase( size_t, Iterator, Iterator, Predicate )";
4833
4834 initialize();
4835
4836 SMT sm = blaze::submatrix( mat_, 3UL, 1UL, 2UL, 3UL );
4837
4838 // Erasing a selection of elements
4839 sm.erase( 0UL, sm.begin( 0UL ), sm.find( 0UL, 2UL ),
4840 []( int value ) { return value == 4 || value == 5; } );
4841
4842 checkRows ( sm , 2UL );
4843 checkColumns ( sm , 3UL );
4844 checkNonZeros( sm , 4UL );
4845 checkRows ( mat_, 5UL );
4846 checkColumns ( mat_, 4UL );
4847 checkNonZeros( mat_, 8UL );
4848
4849 if( sm(0,0) != 0 || sm(0,1) != 0 || sm(0,2) != -6 ||
4850 sm(1,0) != -8 || sm(1,1) != 9 || sm(1,2) != 10 ) {
4851 std::ostringstream oss;
4852 oss << " Test: " << test_ << "\n"
4853 << " Error: Erasing a selection of elements failed\n"
4854 << " Details:\n"
4855 << " Result:\n" << sm << "\n"
4856 << " Expected result:\n( 0 0 -6 )\n( -8 9 10 )\n";
4857 throw std::runtime_error( oss.str() );
4858 }
4859
4860 // Trying to erase from an empty range
4861 sm.erase( 1UL, sm.begin( 1UL ), sm.begin( 1UL ), []( int ){ return true; } );
4862
4863 checkRows ( sm , 2UL );
4864 checkColumns ( sm , 3UL );
4865 checkNonZeros( sm , 4UL );
4866 checkRows ( mat_, 5UL );
4867 checkColumns ( mat_, 4UL );
4868 checkNonZeros( mat_, 8UL );
4869
4870 if( sm(0,0) != 0 || sm(0,1) != 0 || sm(0,2) != -6 ||
4871 sm(1,0) != -8 || sm(1,1) != 9 || sm(1,2) != 10 ) {
4872 std::ostringstream oss;
4873 oss << " Test: " << test_ << "\n"
4874 << " Error: Erasing from an empty range failed\n"
4875 << " Details:\n"
4876 << " Result:\n" << sm << "\n"
4877 << " Expected result:\n( 0 0 -6 )\n( -8 9 10 )\n";
4878 throw std::runtime_error( oss.str() );
4879 }
4880 }
4881
4882
4883 //=====================================================================================
4884 // Column-major index-based erase function
4885 //=====================================================================================
4886
4887 {
4888 test_ = "Column-major Submatrix::erase( size_t, size_t )";
4889
4890 initialize();
4891
4892 OSMT sm = blaze::submatrix( tmat_, 1UL, 3UL, 3UL, 2UL );
4893
4894 // Erasing the non-zero element at the end of the 1st column
4895 sm.erase( 2UL, 1UL );
4896
4897 checkRows ( sm , 3UL );
4898 checkColumns ( sm , 2UL );
4899 checkNonZeros( sm , 5UL );
4900 checkRows ( tmat_, 4UL );
4901 checkColumns ( tmat_, 5UL );
4902 checkNonZeros( tmat_, 9UL );
4903
4904 if( sm(0,0) != 4 || sm(0,1) != -8 ||
4905 sm(1,0) != 5 || sm(1,1) != 9 ||
4906 sm(2,0) != -6 || sm(2,1) != 0 ) {
4907 std::ostringstream oss;
4908 oss << " Test: " << test_ << "\n"
4909 << " Error: Erasing a non-zero element failed\n"
4910 << " Details:\n"
4911 << " Result:\n" << sm << "\n"
4912 << " Expected result:\n( 4 -8 )\n( 5 9 )\n( -6 0 )\n";
4913 throw std::runtime_error( oss.str() );
4914 }
4915
4916 // Erasing the non-zero element at the beginning of the 1st column
4917 sm.erase( 0UL, 1UL );
4918
4919 checkRows ( sm , 3UL );
4920 checkColumns ( sm , 2UL );
4921 checkNonZeros( sm , 4UL );
4922 checkRows ( tmat_, 4UL );
4923 checkColumns ( tmat_, 5UL );
4924 checkNonZeros( tmat_, 8UL );
4925
4926 if( sm(0,0) != 4 || sm(0,1) != 0 ||
4927 sm(1,0) != 5 || sm(1,1) != 9 ||
4928 sm(2,0) != -6 || sm(2,1) != 0 ) {
4929 std::ostringstream oss;
4930 oss << " Test: " << test_ << "\n"
4931 << " Error: Erasing a non-zero element failed\n"
4932 << " Details:\n"
4933 << " Result:\n" << sm << "\n"
4934 << " Expected result:\n( 4 0 )\n( 5 9 )\n( -6 0 )\n";
4935 throw std::runtime_error( oss.str() );
4936 }
4937
4938 // Erasing the non-zero element at the beginning of the 1st column
4939 sm.erase( 1UL, 1UL );
4940
4941 checkRows ( sm , 3UL );
4942 checkColumns ( sm , 2UL );
4943 checkNonZeros( sm , 3UL );
4944 checkRows ( tmat_, 4UL );
4945 checkColumns ( tmat_, 5UL );
4946 checkNonZeros( tmat_, 7UL );
4947
4948 if( sm(0,0) != 4 || sm(0,1) != 0 ||
4949 sm(1,0) != 5 || sm(1,1) != 0 ||
4950 sm(2,0) != -6 || sm(2,1) != 0 ) {
4951 std::ostringstream oss;
4952 oss << " Test: " << test_ << "\n"
4953 << " Error: Erasing a non-zero element failed\n"
4954 << " Details:\n"
4955 << " Result:\n" << sm << "\n"
4956 << " Expected result:\n( 4 0 )\n( 5 0 )\n( -6 0 )\n";
4957 throw std::runtime_error( oss.str() );
4958 }
4959
4960 // Trying to erase an already erased element
4961 sm.erase( 2UL, 1UL );
4962
4963 checkRows ( sm , 3UL );
4964 checkColumns ( sm , 2UL );
4965 checkNonZeros( sm , 3UL );
4966 checkRows ( tmat_, 4UL );
4967 checkColumns ( tmat_, 5UL );
4968 checkNonZeros( tmat_, 7UL );
4969
4970 if( sm(0,0) != 4 || sm(0,1) != 0 ||
4971 sm(1,0) != 5 || sm(1,1) != 0 ||
4972 sm(2,0) != -6 || sm(2,1) != 0 ) {
4973 std::ostringstream oss;
4974 oss << " Test: " << test_ << "\n"
4975 << " Error: Erasing a zero element failed\n"
4976 << " Details:\n"
4977 << " Result:\n" << sm << "\n"
4978 << " Expected result:\n( 4 0 )\n( 5 0 )\n( -6 0 )\n";
4979 throw std::runtime_error( oss.str() );
4980 }
4981 }
4982
4983
4984 //=====================================================================================
4985 // Column-major iterator-based erase function
4986 //=====================================================================================
4987
4988 {
4989 test_ = "Column-major Submatrix::erase( size_t, Iterator )";
4990
4991 initialize();
4992
4993 OSMT sm = blaze::submatrix( tmat_, 1UL, 3UL, 3UL, 2UL );
4994
4995 // Erasing the non-zero element at the end of the 1st column
4996 {
4997 OSMT::Iterator pos = sm.erase( 1UL, sm.find( 2UL, 1UL ) );
4998
4999 checkRows ( sm , 3UL );
5000 checkColumns ( sm , 2UL );
5001 checkNonZeros( sm , 5UL );
5002 checkRows ( tmat_, 4UL );
5003 checkColumns ( tmat_, 5UL );
5004 checkNonZeros( tmat_, 9UL );
5005
5006 if( pos != sm.end( 1UL ) ) {
5007 std::ostringstream oss;
5008 oss << " Test: " << test_ << "\n"
5009 << " Error: Invalid iterator returned\n"
5010 << " Details:\n"
5011 << " Expected result: the end() iterator\n";
5012 throw std::runtime_error( oss.str() );
5013 }
5014
5015 if( sm(0,0) != 4 || sm(0,1) != -8 ||
5016 sm(1,0) != 5 || sm(1,1) != 9 ||
5017 sm(2,0) != -6 || sm(2,1) != 0 ) {
5018 std::ostringstream oss;
5019 oss << " Test: " << test_ << "\n"
5020 << " Error: Erasing a non-zero element failed\n"
5021 << " Details:\n"
5022 << " Result:\n" << sm << "\n"
5023 << " Expected result:\n( 4 -8 )\n( 5 9 )\n( -6 0 )\n";
5024 throw std::runtime_error( oss.str() );
5025 }
5026 }
5027
5028 // Erasing the non-zero element at the beginning of the 1st column
5029 {
5030 OSMT::Iterator pos = sm.erase( 1UL, sm.find( 0UL, 1UL ) );
5031
5032 checkRows ( sm , 3UL );
5033 checkColumns ( sm , 2UL );
5034 checkNonZeros( sm , 4UL );
5035 checkRows ( tmat_, 4UL );
5036 checkColumns ( tmat_, 5UL );
5037 checkNonZeros( tmat_, 8UL );
5038
5039 if( pos->value() != 9 || pos->index() != 1 ) {
5040 std::ostringstream oss;
5041 oss << " Test: " << test_ << "\n"
5042 << " Error: Invalid iterator returned\n"
5043 << " Details:\n"
5044 << " Value: " << pos->value() << "\n"
5045 << " Index: " << pos->index() << "\n"
5046 << " Expected value: 9\n"
5047 << " Expected index: 1\n";
5048 throw std::runtime_error( oss.str() );
5049 }
5050
5051 if( sm(0,0) != 4 || sm(0,1) != 0 ||
5052 sm(1,0) != 5 || sm(1,1) != 9 ||
5053 sm(2,0) != -6 || sm(2,1) != 0 ) {
5054 std::ostringstream oss;
5055 oss << " Test: " << test_ << "\n"
5056 << " Error: Erasing a non-zero element failed\n"
5057 << " Details:\n"
5058 << " Result:\n" << sm << "\n"
5059 << " Expected result:\n( 4 0 )\n( 5 9 )\n( -6 0 )\n";
5060 throw std::runtime_error( oss.str() );
5061 }
5062 }
5063
5064 // Erasing the non-zero element at the beginning of the 1st column
5065 {
5066 OSMT::Iterator pos = sm.erase( 1UL, sm.find( 1UL, 1UL ) );
5067
5068 checkRows ( sm , 3UL );
5069 checkColumns ( sm , 2UL );
5070 checkNonZeros( sm , 3UL );
5071 checkRows ( tmat_, 4UL );
5072 checkColumns ( tmat_, 5UL );
5073 checkNonZeros( tmat_, 7UL );
5074
5075 if( pos != sm.end( 1UL ) ) {
5076 std::ostringstream oss;
5077 oss << " Test: " << test_ << "\n"
5078 << " Error: Invalid iterator returned\n"
5079 << " Details:\n"
5080 << " Expected result: the end() iterator\n";
5081 throw std::runtime_error( oss.str() );
5082 }
5083
5084 if( sm(0,0) != 4 || sm(0,1) != 0 ||
5085 sm(1,0) != 5 || sm(1,1) != 0 ||
5086 sm(2,0) != -6 || sm(2,1) != 0 ) {
5087 std::ostringstream oss;
5088 oss << " Test: " << test_ << "\n"
5089 << " Error: Erasing a non-zero element failed\n"
5090 << " Details:\n"
5091 << " Result:\n" << sm << "\n"
5092 << " Expected result:\n( 4 0 )\n( 5 0 )\n( -6 0 )\n";
5093 throw std::runtime_error( oss.str() );
5094 }
5095 }
5096
5097 // Trying to erase an already erased element
5098 {
5099 OSMT::Iterator pos = sm.erase( 1UL, sm.find( 2UL, 1UL ) );
5100
5101 checkRows ( sm , 3UL );
5102 checkColumns ( sm , 2UL );
5103 checkNonZeros( sm , 3UL );
5104 checkRows ( tmat_, 4UL );
5105 checkColumns ( tmat_, 5UL );
5106 checkNonZeros( tmat_, 7UL );
5107
5108 if( pos != sm.end( 1UL ) ) {
5109 std::ostringstream oss;
5110 oss << " Test: " << test_ << "\n"
5111 << " Error: Invalid iterator returned\n"
5112 << " Details:\n"
5113 << " Expected result: the end() iterator\n";
5114 throw std::runtime_error( oss.str() );
5115 }
5116
5117 if( sm(0,0) != 4 || sm(0,1) != 0 ||
5118 sm(1,0) != 5 || sm(1,1) != 0 ||
5119 sm(2,0) != -6 || sm(2,1) != 0 ) {
5120 std::ostringstream oss;
5121 oss << " Test: " << test_ << "\n"
5122 << " Error: Erasing a zero element failed\n"
5123 << " Details:\n"
5124 << " Result:\n" << sm << "\n"
5125 << " Expected result:\n( 4 0 )\n( 5 0 )\n( -6 0 )\n";
5126 throw std::runtime_error( oss.str() );
5127 }
5128 }
5129 }
5130
5131
5132 //=====================================================================================
5133 // Column-major iterator-range-based erase function
5134 //=====================================================================================
5135
5136 {
5137 test_ = "Column-major Submatrix::erase( size_t, Iterator, Iterator )";
5138
5139 initialize();
5140
5141 OSMT sm = blaze::submatrix( tmat_, 0UL, 3UL, 4UL, 2UL );
5142
5143 // Erasing the 0th column
5144 {
5145 OSMT::Iterator pos = sm.erase( 0UL, sm.begin( 0UL ), sm.end( 0UL ) );
5146
5147 checkRows ( sm , 4UL );
5148 checkColumns ( sm , 2UL );
5149 checkNonZeros( sm , 4UL );
5150 checkRows ( tmat_, 4UL );
5151 checkColumns ( tmat_, 5UL );
5152 checkNonZeros( tmat_, 7UL );
5153
5154 if( pos != sm.end( 0UL ) ) {
5155 std::ostringstream oss;
5156 oss << " Test: " << test_ << "\n"
5157 << " Error: Invalid iterator returned\n"
5158 << " Details:\n"
5159 << " Expected result: the end() iterator\n";
5160 throw std::runtime_error( oss.str() );
5161 }
5162
5163 if( sm(0,0) != 0 || sm(0,1) != 7 ||
5164 sm(1,0) != 0 || sm(1,1) != -8 ||
5165 sm(2,0) != 0 || sm(2,1) != 9 ||
5166 sm(3,0) != 0 || sm(3,1) != 10 ) {
5167 std::ostringstream oss;
5168 oss << " Test: " << test_ << "\n"
5169 << " Error: Erasing the 0th column failed\n"
5170 << " Details:\n"
5171 << " Result:\n" << sm << "\n"
5172 << " Expected result:\n( 0 7 )\n( 0 -8 )\n( 0 9 )\n( 0 10 )\n";
5173 throw std::runtime_error( oss.str() );
5174 }
5175 }
5176
5177 // Erasing the first half of the 1st column
5178 {
5179 OSMT::Iterator pos = sm.erase( 1UL, sm.begin( 1UL ), sm.find( 2UL, 1UL ) );
5180
5181 checkRows ( sm , 4UL );
5182 checkColumns ( sm , 2UL );
5183 checkNonZeros( sm , 2UL );
5184 checkRows ( tmat_, 4UL );
5185 checkColumns ( tmat_, 5UL );
5186 checkNonZeros( tmat_, 5UL );
5187
5188 if( pos->value() != 9 || pos->index() != 2 ) {
5189 std::ostringstream oss;
5190 oss << " Test: " << test_ << "\n"
5191 << " Error: Invalid iterator returned\n"
5192 << " Details:\n"
5193 << " Value: " << pos->value() << "\n"
5194 << " Index: " << pos->index() << "\n"
5195 << " Expected value: 9\n"
5196 << " Expected index: 2\n";
5197 throw std::runtime_error( oss.str() );
5198 }
5199
5200 if( sm(0,0) != 0 || sm(0,1) != 0 ||
5201 sm(1,0) != 0 || sm(1,1) != 0 ||
5202 sm(2,0) != 0 || sm(2,1) != 9 ||
5203 sm(3,0) != 0 || sm(3,1) != 10 ) {
5204 std::ostringstream oss;
5205 oss << " Test: " << test_ << "\n"
5206 << " Error: Erasing the 0th column failed\n"
5207 << " Details:\n"
5208 << " Result:\n" << sm << "\n"
5209 << " Expected result:\n( 0 0 )\n( 0 0 )\n( 0 9 )\n( 0 10 )\n";
5210 throw std::runtime_error( oss.str() );
5211 }
5212 }
5213
5214 // Erasing the second half of the 1st column
5215 {
5216 OSMT::Iterator pos = sm.erase( 1UL, sm.find( 2UL, 1UL ), sm.end( 1UL ) );
5217
5218 checkRows ( sm , 4UL );
5219 checkColumns ( sm , 2UL );
5220 checkNonZeros( sm , 0UL );
5221 checkRows ( tmat_, 4UL );
5222 checkColumns ( tmat_, 5UL );
5223 checkNonZeros( tmat_, 3UL );
5224
5225 if( pos != sm.end( 1UL ) ) {
5226 std::ostringstream oss;
5227 oss << " Test: " << test_ << "\n"
5228 << " Error: Invalid iterator returned\n"
5229 << " Details:\n"
5230 << " Expected result: the end() iterator\n";
5231 throw std::runtime_error( oss.str() );
5232 }
5233
5234 if( sm(0,0) != 0 || sm(0,1) != 0 ||
5235 sm(1,0) != 0 || sm(1,1) != 0 ||
5236 sm(2,0) != 0 || sm(2,1) != 0 ||
5237 sm(3,0) != 0 || sm(3,1) != 0 ) {
5238 std::ostringstream oss;
5239 oss << " Test: " << test_ << "\n"
5240 << " Error: Erasing the 0th column failed\n"
5241 << " Details:\n"
5242 << " Result:\n" << sm << "\n"
5243 << " Expected result:\n( 0 0 )\n( 0 0 )\n( 0 0 )\n( 0 0 )\n";
5244 throw std::runtime_error( oss.str() );
5245 }
5246 }
5247
5248 // Trying to erase an empty range
5249 {
5250 OSMT::Iterator pos = sm.erase( 1UL, sm.begin( 1UL ), sm.begin( 1UL ) );
5251
5252 checkRows ( sm , 4UL );
5253 checkColumns ( sm , 2UL );
5254 checkNonZeros( sm , 0UL );
5255 checkRows ( tmat_, 4UL );
5256 checkColumns ( tmat_, 5UL );
5257 checkNonZeros( tmat_, 3UL );
5258
5259 if( pos != sm.begin( 1UL ) ) {
5260 std::ostringstream oss;
5261 oss << " Test: " << test_ << "\n"
5262 << " Error: Invalid iterator returned\n"
5263 << " Details:\n"
5264 << " Expected result: the given end() iterator\n";
5265 throw std::runtime_error( oss.str() );
5266 }
5267
5268 if( sm(0,0) != 0 || sm(0,1) != 0 ||
5269 sm(1,0) != 0 || sm(1,1) != 0 ||
5270 sm(2,0) != 0 || sm(2,1) != 0 ||
5271 sm(3,0) != 0 || sm(3,1) != 0 ) {
5272 std::ostringstream oss;
5273 oss << " Test: " << test_ << "\n"
5274 << " Error: Erasing the 0th column failed\n"
5275 << " Details:\n"
5276 << " Result:\n" << sm << "\n"
5277 << " Expected result:\n( 0 0 )\n( 0 0 )\n( 0 0 )\n( 0 0 )\n";
5278 throw std::runtime_error( oss.str() );
5279 }
5280 }
5281 }
5282
5283
5284 //=====================================================================================
5285 // Column-major erase function with predicate
5286 //=====================================================================================
5287
5288 {
5289 test_ = "Column-major Submatrix::erase( Predicate )";
5290
5291 initialize();
5292
5293 OSMT sm = blaze::submatrix( tmat_, 1UL, 3UL, 3UL, 2UL );
5294
5295 // Erasing a selection of values
5296 sm.erase( []( int value ) { return value == 4 || value == 10; } );
5297
5298 checkRows ( sm , 3UL );
5299 checkColumns ( sm , 2UL );
5300 checkNonZeros( sm , 4UL );
5301 checkRows ( tmat_, 4UL );
5302 checkColumns ( tmat_, 5UL );
5303 checkNonZeros( tmat_, 8UL );
5304
5305 if( sm(0,0) != 0 || sm(0,1) != -8 ||
5306 sm(1,0) != 5 || sm(1,1) != 9 ||
5307 sm(2,0) != -6 || sm(2,1) != 0 ) {
5308 std::ostringstream oss;
5309 oss << " Test: " << test_ << "\n"
5310 << " Error: Erasing a selection of elements failed\n"
5311 << " Details:\n"
5312 << " Result:\n" << sm << "\n"
5313 << " Expected result:\n( 0 -8 )\n( 5 9 )\n( -6 0 )\n";
5314 throw std::runtime_error( oss.str() );
5315 }
5316
5317 // Trying to erase all elements with value 1
5318 sm.erase( []( int value ){ return value == 1; } );
5319
5320 checkRows ( sm , 3UL );
5321 checkColumns ( sm , 2UL );
5322 checkNonZeros( sm , 4UL );
5323 checkRows ( tmat_, 4UL );
5324 checkColumns ( tmat_, 5UL );
5325 checkNonZeros( tmat_, 8UL );
5326
5327 if( sm(0,0) != 0 || sm(0,1) != -8 ||
5328 sm(1,0) != 5 || sm(1,1) != 9 ||
5329 sm(2,0) != -6 || sm(2,1) != 0 ) {
5330 std::ostringstream oss;
5331 oss << " Test: " << test_ << "\n"
5332 << " Error: Erasing all elements with value 1 failed\n"
5333 << " Details:\n"
5334 << " Result:\n" << sm << "\n"
5335 << " Expected result:\n( 0 -8 )\n( 5 9 )\n( -6 0 )\n";
5336 throw std::runtime_error( oss.str() );
5337 }
5338 }
5339
5340
5341 //=====================================================================================
5342 // Column-major iterator-range-based erase function with predicate
5343 //=====================================================================================
5344
5345 {
5346 test_ = "Column-major Submatrix::erase( size_t, Iterator, Iterator, Predicate )";
5347
5348 initialize();
5349
5350 OSMT sm = blaze::submatrix( tmat_, 1UL, 3UL, 3UL, 2UL );
5351
5352 // Erasing a selection of elements
5353 sm.erase( 0UL, sm.begin( 0UL ), sm.find( 2UL, 0UL ),
5354 []( int value ) { return value == 4 || value == 5; } );
5355
5356 checkRows ( sm , 3UL );
5357 checkColumns ( sm , 2UL );
5358 checkNonZeros( sm , 4UL );
5359 checkRows ( tmat_, 4UL );
5360 checkColumns ( tmat_, 5UL );
5361 checkNonZeros( tmat_, 8UL );
5362
5363 if( sm(0,0) != 0 || sm(0,1) != -8 ||
5364 sm(1,0) != 0 || sm(1,1) != 9 ||
5365 sm(2,0) != -6 || sm(2,1) != 10 ) {
5366 std::ostringstream oss;
5367 oss << " Test: " << test_ << "\n"
5368 << " Error: Erasing a selection of elements failed\n"
5369 << " Details:\n"
5370 << " Result:\n" << sm << "\n"
5371 << " Expected result:\n( 0 -8 )\n( 0 9 )\n( -6 10 )\n";
5372 throw std::runtime_error( oss.str() );
5373 }
5374
5375 // Trying to erase from an empty range
5376 sm.erase( 1UL, sm.begin( 1UL ), sm.begin( 1UL ), []( int ){ return true; } );
5377
5378 checkRows ( sm , 3UL );
5379 checkColumns ( sm , 2UL );
5380 checkNonZeros( sm , 4UL );
5381 checkRows ( tmat_, 4UL );
5382 checkColumns ( tmat_, 5UL );
5383 checkNonZeros( tmat_, 8UL );
5384
5385 if( sm(0,0) != 0 || sm(0,1) != -8 ||
5386 sm(1,0) != 0 || sm(1,1) != 9 ||
5387 sm(2,0) != -6 || sm(2,1) != 10 ) {
5388 std::ostringstream oss;
5389 oss << " Test: " << test_ << "\n"
5390 << " Error: Erasing from an empty range failed\n"
5391 << " Details:\n"
5392 << " Result:\n" << sm << "\n"
5393 << " Expected result:\n( 0 -8 )\n( 0 9 )\n( -6 10 )\n";
5394 throw std::runtime_error( oss.str() );
5395 }
5396 }
5397 }
5398 //*************************************************************************************************
5399
5400
5401 //*************************************************************************************************
5402 /*!\brief Test of the \c find() member function of the Submatrix class template.
5403 //
5404 // \return void
5405 // \exception std::runtime_error Error detected.
5406 //
5407 // This function performs a test of the \c find() member function of the Submatrix
5408 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
5409 */
testFind()5410 void SparseTest::testFind()
5411 {
5412 //=====================================================================================
5413 // Row-major submatrix tests
5414 //=====================================================================================
5415
5416 {
5417 test_ = "Row-major Submatrix::find()";
5418
5419 using ConstIterator = SMT::ConstIterator;
5420
5421 initialize();
5422
5423 SMT sm = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 2UL );
5424
5425 checkRows ( sm, 3UL );
5426 checkColumns ( sm, 2UL );
5427 checkNonZeros( sm, 4UL );
5428 checkNonZeros( sm, 0UL, 1UL );
5429 checkNonZeros( sm, 1UL, 1UL );
5430 checkNonZeros( sm, 2UL, 2UL );
5431
5432 // Searching for the first element
5433 {
5434 ConstIterator pos( sm.find( 0UL, 0UL ) );
5435
5436 if( pos == sm.end( 0UL ) ) {
5437 std::ostringstream oss;
5438 oss << " Test: " << test_ << "\n"
5439 << " Error: Element could not be found\n"
5440 << " Details:\n"
5441 << " Required position = (0,0)\n"
5442 << " Current submatrix:\n" << sm << "\n";
5443 throw std::runtime_error( oss.str() );
5444 }
5445 else if( pos->index() != 0 || pos->value() != 1 ) {
5446 std::ostringstream oss;
5447 oss << " Test: " << test_ << "\n"
5448 << " Error: Wrong element found\n"
5449 << " Details:\n"
5450 << " Required index = 0\n"
5451 << " Found index = " << pos->index() << "\n"
5452 << " Expected value = 1\n"
5453 << " Value at index = " << pos->value() << "\n"
5454 << " Current submatrix:\n" << sm << "\n";
5455 throw std::runtime_error( oss.str() );
5456 }
5457 }
5458
5459 // Searching for the second element
5460 {
5461 ConstIterator pos( sm.find( 1UL, 1UL ) );
5462
5463 if( pos == sm.end( 1UL ) ) {
5464 std::ostringstream oss;
5465 oss << " Test: " << test_ << "\n"
5466 << " Error: Element could not be found\n"
5467 << " Details:\n"
5468 << " Required position = (1,1)\n"
5469 << " Current submatrix:\n" << sm << "\n";
5470 throw std::runtime_error( oss.str() );
5471 }
5472 else if( pos->index() != 1 || pos->value() != -3 ) {
5473 std::ostringstream oss;
5474 oss << " Test: " << test_ << "\n"
5475 << " Error: Wrong element found\n"
5476 << " Details:\n"
5477 << " Required index = 1\n"
5478 << " Found index = " << pos->index() << "\n"
5479 << " Expected value = -3\n"
5480 << " Value at index = " << pos->value() << "\n"
5481 << " Current submatrix:\n" << sm << "\n";
5482 throw std::runtime_error( oss.str() );
5483 }
5484 }
5485
5486 // Searching for a non-existing non-zero element
5487 {
5488 ConstIterator pos( sm.find( 1UL, 0UL ) );
5489
5490 if( pos != sm.end( 1UL ) ) {
5491 std::ostringstream oss;
5492 oss << " Test: " << test_ << "\n"
5493 << " Error: Non-existing element could be found\n"
5494 << " Details:\n"
5495 << " Required index = 0\n"
5496 << " Found index = " << pos->index() << "\n"
5497 << " Expected value = 0\n"
5498 << " Value at index = " << pos->value() << "\n"
5499 << " Current submatrix:\n" << sm << "\n";
5500 throw std::runtime_error( oss.str() );
5501 }
5502 }
5503 }
5504
5505
5506 //=====================================================================================
5507 // Column-major submatrix tests
5508 //=====================================================================================
5509
5510 {
5511 test_ = "Column-major Submatrix::find()";
5512
5513 using ConstIterator = OSMT::ConstIterator;
5514
5515 initialize();
5516
5517 OSMT sm = blaze::submatrix( tmat_, 1UL, 1UL, 2UL, 3UL );
5518
5519 checkRows ( sm, 2UL );
5520 checkColumns ( sm, 3UL );
5521 checkNonZeros( sm, 4UL );
5522 checkNonZeros( sm, 0UL, 1UL );
5523 checkNonZeros( sm, 1UL, 1UL );
5524 checkNonZeros( sm, 2UL, 2UL );
5525
5526 // Searching for the first element
5527 {
5528 ConstIterator pos( sm.find( 0UL, 0UL ) );
5529
5530 if( pos == sm.end( 0UL ) ) {
5531 std::ostringstream oss;
5532 oss << " Test: " << test_ << "\n"
5533 << " Error: Element could not be found\n"
5534 << " Details:\n"
5535 << " Required position = (0,0)\n"
5536 << " Current submatrix:\n" << sm << "\n";
5537 throw std::runtime_error( oss.str() );
5538 }
5539 else if( pos->index() != 0 || pos->value() != 1 ) {
5540 std::ostringstream oss;
5541 oss << " Test: " << test_ << "\n"
5542 << " Error: Wrong element found\n"
5543 << " Details:\n"
5544 << " Required index = 0\n"
5545 << " Found index = " << pos->index() << "\n"
5546 << " Expected value = 1\n"
5547 << " Value at index = " << pos->value() << "\n"
5548 << " Current submatrix:\n" << sm << "\n";
5549 throw std::runtime_error( oss.str() );
5550 }
5551 }
5552
5553 // Searching for the second element
5554 {
5555 ConstIterator pos( sm.find( 1UL, 2UL ) );
5556
5557 if( pos == sm.end( 2UL ) ) {
5558 std::ostringstream oss;
5559 oss << " Test: " << test_ << "\n"
5560 << " Error: Element could not be found\n"
5561 << " Details:\n"
5562 << " Required position = (1,2)\n"
5563 << " Current submatrix:\n" << sm << "\n";
5564 throw std::runtime_error( oss.str() );
5565 }
5566 else if( pos->index() != 1 || pos->value() != 5 ) {
5567 std::ostringstream oss;
5568 oss << " Test: " << test_ << "\n"
5569 << " Error: Wrong element found\n"
5570 << " Details:\n"
5571 << " Required index = 1\n"
5572 << " Found index = " << pos->index() << "\n"
5573 << " Expected value = 5\n"
5574 << " Value at index = " << pos->value() << "\n"
5575 << " Current submatrix:\n" << sm << "\n";
5576 throw std::runtime_error( oss.str() );
5577 }
5578 }
5579
5580 // Searching for a non-existing non-zero element
5581 {
5582 ConstIterator pos( sm.find( 1UL, 0UL ) );
5583
5584 if( pos != sm.end( 0UL ) ) {
5585 std::ostringstream oss;
5586 oss << " Test: " << test_ << "\n"
5587 << " Error: Non-existing element could be found\n"
5588 << " Details:\n"
5589 << " Required index = 0\n"
5590 << " Found index = " << pos->index() << "\n"
5591 << " Expected value = 0\n"
5592 << " Value at index = " << pos->value() << "\n"
5593 << " Current submatrix:\n" << sm << "\n";
5594 throw std::runtime_error( oss.str() );
5595 }
5596 }
5597 }
5598 }
5599 //*************************************************************************************************
5600
5601
5602 //*************************************************************************************************
5603 /*!\brief Test of the \c lowerBound() member function of the Submatrix class template.
5604 //
5605 // \return void
5606 // \exception std::runtime_error Error detected.
5607 //
5608 // This function performs a test of the \c lowerBound() member function of the Submatrix
5609 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
5610 */
testLowerBound()5611 void SparseTest::testLowerBound()
5612 {
5613 //=====================================================================================
5614 // Row-major submatrix tests
5615 //=====================================================================================
5616
5617 {
5618 test_ = "Row-major Submatrix::lowerBound()";
5619
5620 using ConstIterator = SMT::ConstIterator;
5621
5622 SMT sm = blaze::submatrix( mat_, 1UL, 0UL, 1UL, 4UL );
5623
5624 checkRows ( sm, 1UL );
5625 checkColumns ( sm, 4UL );
5626 checkNonZeros( sm, 1UL );
5627 checkNonZeros( sm, 0UL, 1UL );
5628
5629 // Determining the lower bound for position (0,0)
5630 {
5631 ConstIterator pos( sm.lowerBound( 0UL, 0UL ) );
5632
5633 if( pos == sm.end( 0UL ) ) {
5634 std::ostringstream oss;
5635 oss << " Test: " << test_ << "\n"
5636 << " Error: Lower bound could not be determined\n"
5637 << " Details:\n"
5638 << " Required position = (0,0)\n"
5639 << " Current submatrix:\n" << sm << "\n";
5640 throw std::runtime_error( oss.str() );
5641 }
5642 else if( pos->index() != 1 || pos->value() != 1 ) {
5643 std::ostringstream oss;
5644 oss << " Test: " << test_ << "\n"
5645 << " Error: Wrong element found\n"
5646 << " Details:\n"
5647 << " Required index = 1\n"
5648 << " Found index = " << pos->index() << "\n"
5649 << " Expected value = 1\n"
5650 << " Value at index = " << pos->value() << "\n"
5651 << " Current submatrix:\n" << sm << "\n";
5652 throw std::runtime_error( oss.str() );
5653 }
5654 }
5655
5656 // Determining the lower bound for position (0,1)
5657 {
5658 ConstIterator pos( sm.lowerBound( 0UL, 1UL ) );
5659
5660 if( pos == sm.end( 0UL ) ) {
5661 std::ostringstream oss;
5662 oss << " Test: " << test_ << "\n"
5663 << " Error: Lower bound could not be determined\n"
5664 << " Details:\n"
5665 << " Required position = (0,1)\n"
5666 << " Current submatrix:\n" << sm << "\n";
5667 throw std::runtime_error( oss.str() );
5668 }
5669 else if( pos->index() != 1 || pos->value() != 1 ) {
5670 std::ostringstream oss;
5671 oss << " Test: " << test_ << "\n"
5672 << " Error: Wrong element found\n"
5673 << " Details:\n"
5674 << " Required index = 1\n"
5675 << " Found index = " << pos->index() << "\n"
5676 << " Expected value = 1\n"
5677 << " Value at index = " << pos->value() << "\n"
5678 << " Current submatrix:\n" << sm << "\n";
5679 throw std::runtime_error( oss.str() );
5680 }
5681 }
5682
5683 // Determining the lower bound for position (0,2)
5684 {
5685 ConstIterator pos( sm.lowerBound( 0UL, 2UL ) );
5686
5687 if( pos != sm.end( 0UL ) ) {
5688 std::ostringstream oss;
5689 oss << " Test: " << test_ << "\n"
5690 << " Error: Lower bound could not be determined\n"
5691 << " Details:\n"
5692 << " Required position = (0,2)\n"
5693 << " Current submatrix:\n" << sm << "\n";
5694 throw std::runtime_error( oss.str() );
5695 }
5696 }
5697 }
5698
5699
5700 //=====================================================================================
5701 // Column-major submatrix tests
5702 //=====================================================================================
5703
5704 {
5705 test_ = "Column-major Submatrix::lowerBound()";
5706
5707 using ConstIterator = OSMT::ConstIterator;
5708
5709 OSMT sm = blaze::submatrix( tmat_, 0UL, 1UL, 4UL, 1UL );
5710
5711 checkRows ( sm, 4UL );
5712 checkColumns ( sm, 1UL );
5713 checkNonZeros( sm, 1UL );
5714 checkNonZeros( sm, 0UL, 1UL );
5715
5716 // Determining the lower bound for position (0,0)
5717 {
5718 ConstIterator pos( sm.lowerBound( 0UL, 0UL ) );
5719
5720 if( pos == sm.end( 0UL ) ) {
5721 std::ostringstream oss;
5722 oss << " Test: " << test_ << "\n"
5723 << " Error: Lower bound could not be determined\n"
5724 << " Details:\n"
5725 << " Required position = (0,0)\n"
5726 << " Current submatrix:\n" << sm << "\n";
5727 throw std::runtime_error( oss.str() );
5728 }
5729 else if( pos->index() != 1 || pos->value() != 1 ) {
5730 std::ostringstream oss;
5731 oss << " Test: " << test_ << "\n"
5732 << " Error: Wrong element found\n"
5733 << " Details:\n"
5734 << " Required index = 1\n"
5735 << " Found index = " << pos->index() << "\n"
5736 << " Expected value = 1\n"
5737 << " Value at index = " << pos->value() << "\n"
5738 << " Current submatrix:\n" << sm << "\n";
5739 throw std::runtime_error( oss.str() );
5740 }
5741 }
5742
5743 // Determining the lower bound for position (1,0)
5744 {
5745 ConstIterator pos( sm.lowerBound( 1UL, 0UL ) );
5746
5747 if( pos == sm.end( 0UL ) ) {
5748 std::ostringstream oss;
5749 oss << " Test: " << test_ << "\n"
5750 << " Error: Lower bound could not be determined\n"
5751 << " Details:\n"
5752 << " Required position = (1,0)\n"
5753 << " Current submatrix:\n" << sm << "\n";
5754 throw std::runtime_error( oss.str() );
5755 }
5756 else if( pos->index() != 1 || pos->value() != 1 ) {
5757 std::ostringstream oss;
5758 oss << " Test: " << test_ << "\n"
5759 << " Error: Wrong element found\n"
5760 << " Details:\n"
5761 << " Required index = 1\n"
5762 << " Found index = " << pos->index() << "\n"
5763 << " Expected value = 1\n"
5764 << " Value at index = " << pos->value() << "\n"
5765 << " Current submatrix:\n" << sm << "\n";
5766 throw std::runtime_error( oss.str() );
5767 }
5768 }
5769
5770 // Determining the lower bound for position (2,0)
5771 {
5772 ConstIterator pos( sm.lowerBound( 2UL, 0UL ) );
5773
5774 if( pos != sm.end( 0UL ) ) {
5775 std::ostringstream oss;
5776 oss << " Test: " << test_ << "\n"
5777 << " Error: Lower bound could not be determined\n"
5778 << " Details:\n"
5779 << " Required position = (2,0)\n"
5780 << " Current submatrix:\n" << sm << "\n";
5781 throw std::runtime_error( oss.str() );
5782 }
5783 }
5784 }
5785 }
5786 //*************************************************************************************************
5787
5788
5789 //*************************************************************************************************
5790 /*!\brief Test of the \c upperBound() member function of the Submatrix class template.
5791 //
5792 // \return void
5793 // \exception std::runtime_error Error detected.
5794 //
5795 // This function performs a test of the \c upperBound() member function of the Submatrix
5796 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
5797 */
testUpperBound()5798 void SparseTest::testUpperBound()
5799 {
5800 //=====================================================================================
5801 // Row-major submatrix tests
5802 //=====================================================================================
5803
5804 {
5805 test_ = "Row-major Submatrix::upperBound()";
5806
5807 using ConstIterator = SMT::ConstIterator;
5808
5809 SMT sm = blaze::submatrix( mat_, 1UL, 0UL, 1UL, 4UL );
5810
5811 checkRows ( sm, 1UL );
5812 checkColumns ( sm, 4UL );
5813 checkNonZeros( sm, 1UL );
5814 checkNonZeros( sm, 0UL, 1UL );
5815
5816 // Determining the upper bound for position (0,0)
5817 {
5818 ConstIterator pos( sm.upperBound( 0UL, 0UL ) );
5819
5820 if( pos == sm.end( 0UL ) ) {
5821 std::ostringstream oss;
5822 oss << " Test: " << test_ << "\n"
5823 << " Error: Upper bound could not be determined\n"
5824 << " Details:\n"
5825 << " Required position = (0,0)\n"
5826 << " Current submatrix:\n" << sm << "\n";
5827 throw std::runtime_error( oss.str() );
5828 }
5829 else if( pos->index() != 1 || pos->value() != 1 ) {
5830 std::ostringstream oss;
5831 oss << " Test: " << test_ << "\n"
5832 << " Error: Wrong element found\n"
5833 << " Details:\n"
5834 << " Required index = 1\n"
5835 << " Found index = " << pos->index() << "\n"
5836 << " Expected value = 1\n"
5837 << " Value at index = " << pos->value() << "\n"
5838 << " Current submatrix:\n" << sm << "\n";
5839 throw std::runtime_error( oss.str() );
5840 }
5841 }
5842
5843 // Determining the upper bound for position (0,1)
5844 {
5845 ConstIterator pos( sm.upperBound( 0UL, 1UL ) );
5846
5847 if( pos != sm.end( 0UL ) ) {
5848 std::ostringstream oss;
5849 oss << " Test: " << test_ << "\n"
5850 << " Error: Upper bound could not be determined\n"
5851 << " Details:\n"
5852 << " Required position = (0,1)\n"
5853 << " Current submatrix:\n" << sm << "\n";
5854 throw std::runtime_error( oss.str() );
5855 }
5856 }
5857
5858 // Determining the upper bound for position (0,2)
5859 {
5860 ConstIterator pos( sm.upperBound( 0UL, 2UL ) );
5861
5862 if( pos != sm.end( 0UL ) ) {
5863 std::ostringstream oss;
5864 oss << " Test: " << test_ << "\n"
5865 << " Error: Upper bound could not be determined\n"
5866 << " Details:\n"
5867 << " Required position = (0,2)\n"
5868 << " Current submatrix:\n" << sm << "\n";
5869 throw std::runtime_error( oss.str() );
5870 }
5871 }
5872 }
5873
5874
5875 //=====================================================================================
5876 // Column-major submatrix tests
5877 //=====================================================================================
5878
5879 {
5880 test_ = "Column-major Submatrix::upperBound()";
5881
5882 using ConstIterator = OSMT::ConstIterator;
5883
5884 OSMT sm = blaze::submatrix( tmat_, 0UL, 1UL, 4UL, 1UL );
5885
5886 checkRows ( sm, 4UL );
5887 checkColumns ( sm, 1UL );
5888 checkNonZeros( sm, 1UL );
5889 checkNonZeros( sm, 0UL, 1UL );
5890
5891 // Determining the upper bound for position (0,0)
5892 {
5893 ConstIterator pos( sm.upperBound( 0UL, 0UL ) );
5894
5895 if( pos == sm.end( 0UL ) ) {
5896 std::ostringstream oss;
5897 oss << " Test: " << test_ << "\n"
5898 << " Error: Upper bound could not be determined\n"
5899 << " Details:\n"
5900 << " Required position = (0,0)\n"
5901 << " Current submatrix:\n" << sm << "\n";
5902 throw std::runtime_error( oss.str() );
5903 }
5904 else if( pos->index() != 1 || pos->value() != 1 ) {
5905 std::ostringstream oss;
5906 oss << " Test: " << test_ << "\n"
5907 << " Error: Wrong element found\n"
5908 << " Details:\n"
5909 << " Required index = 1\n"
5910 << " Found index = " << pos->index() << "\n"
5911 << " Expected value = 1\n"
5912 << " Value at index = " << pos->value() << "\n"
5913 << " Current submatrix:\n" << sm << "\n";
5914 throw std::runtime_error( oss.str() );
5915 }
5916 }
5917
5918 // Determining the upper bound for position (1,0)
5919 {
5920 ConstIterator pos( sm.upperBound( 1UL, 0UL ) );
5921
5922 if( pos != sm.end( 0UL ) ) {
5923 std::ostringstream oss;
5924 oss << " Test: " << test_ << "\n"
5925 << " Error: Upper bound could not be determined\n"
5926 << " Details:\n"
5927 << " Required position = (1,0)\n"
5928 << " Current submatrix:\n" << sm << "\n";
5929 throw std::runtime_error( oss.str() );
5930 }
5931 }
5932
5933 // Determining the upper bound for position (2,0)
5934 {
5935 ConstIterator pos( sm.upperBound( 2UL, 0UL ) );
5936
5937 if( pos != sm.end( 0UL ) ) {
5938 std::ostringstream oss;
5939 oss << " Test: " << test_ << "\n"
5940 << " Error: Upper bound could not be determined\n"
5941 << " Details:\n"
5942 << " Required position = (2,0)\n"
5943 << " Current submatrix:\n" << sm << "\n";
5944 throw std::runtime_error( oss.str() );
5945 }
5946 }
5947 }
5948 }
5949 //*************************************************************************************************
5950
5951
5952 //*************************************************************************************************
5953 /*!\brief Test of the \c transpose() member functions of the Submatrix class template.
5954 //
5955 // \return void
5956 // \exception std::runtime_error Error detected.
5957 //
5958 // This function performs a test of the \c transpose() member function of the Submatrix
5959 // specialization. Additionally, it performs a test of self-transpose via the \c trans()
5960 // function. In case an error is detected, a \a std::runtime_error exception is thrown.
5961 */
testTranspose()5962 void SparseTest::testTranspose()
5963 {
5964 //=====================================================================================
5965 // Row-major submatrix tests
5966 //=====================================================================================
5967
5968 {
5969 test_ = "Row-major self-transpose via transpose()";
5970
5971 initialize();
5972
5973 SMT sm = blaze::submatrix( mat_, 1UL, 0UL, 3UL, 3UL );
5974
5975 transpose( sm );
5976
5977 checkRows ( sm , 3UL );
5978 checkColumns ( sm , 3UL );
5979 checkNonZeros( sm , 5UL );
5980 checkRows ( mat_, 5UL );
5981 checkColumns ( mat_, 4UL );
5982 checkNonZeros( mat_, 10UL );
5983
5984 if( sm(0,0) != 0 || sm(0,1) != -2 || sm(0,2) != 0 ||
5985 sm(1,0) != 1 || sm(1,1) != 0 || sm(1,2) != 4 ||
5986 sm(2,0) != 0 || sm(2,1) != -3 || sm(2,2) != 5 ) {
5987 std::ostringstream oss;
5988 oss << " Test: " << test_ << "\n"
5989 << " Error: Transpose operation failed\n"
5990 << " Details:\n"
5991 << " Result:\n" << sm << "\n"
5992 << " Expected result:\n( 0 -2 0 )\n( 1 0 4 )\n( 0 -3 5 )\n";
5993 throw std::runtime_error( oss.str() );
5994 }
5995
5996 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
5997 mat_(1,0) != 0 || mat_(1,1) != -2 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
5998 mat_(2,0) != 1 || mat_(2,1) != 0 || mat_(2,2) != 4 || mat_(2,3) != 0 ||
5999 mat_(3,0) != 0 || mat_(3,1) != -3 || mat_(3,2) != 5 || mat_(3,3) != -6 ||
6000 mat_(4,0) != 7 || mat_(4,1) != -8 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
6001 std::ostringstream oss;
6002 oss << " Test: " << test_ << "\n"
6003 << " Error: Transpose operation failed\n"
6004 << " Details:\n"
6005 << " Result:\n" << mat_ << "\n"
6006 << " Expected result:\n( 0 0 0 0 )\n"
6007 "( 0 -2 0 0 )\n"
6008 "( 1 0 4 0 )\n"
6009 "( 0 -3 5 -6 )\n"
6010 "( 7 -8 9 10 )\n";
6011 throw std::runtime_error( oss.str() );
6012 }
6013 }
6014
6015 {
6016 test_ = "Row-major self-transpose via trans()";
6017
6018 initialize();
6019
6020 SMT sm = blaze::submatrix( mat_, 1UL, 0UL, 3UL, 3UL );
6021
6022 sm = trans( sm );
6023
6024 checkRows ( sm , 3UL );
6025 checkColumns ( sm , 3UL );
6026 checkNonZeros( sm , 5UL );
6027 checkRows ( mat_, 5UL );
6028 checkColumns ( mat_, 4UL );
6029 checkNonZeros( mat_, 10UL );
6030
6031 if( sm(0,0) != 0 || sm(0,1) != -2 || sm(0,2) != 0 ||
6032 sm(1,0) != 1 || sm(1,1) != 0 || sm(1,2) != 4 ||
6033 sm(2,0) != 0 || sm(2,1) != -3 || sm(2,2) != 5 ) {
6034 std::ostringstream oss;
6035 oss << " Test: " << test_ << "\n"
6036 << " Error: Transpose operation failed\n"
6037 << " Details:\n"
6038 << " Result:\n" << sm << "\n"
6039 << " Expected result:\n( 0 -2 0 )\n( 1 0 4 )\n( 0 -3 5 )\n";
6040 throw std::runtime_error( oss.str() );
6041 }
6042
6043 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
6044 mat_(1,0) != 0 || mat_(1,1) != -2 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
6045 mat_(2,0) != 1 || mat_(2,1) != 0 || mat_(2,2) != 4 || mat_(2,3) != 0 ||
6046 mat_(3,0) != 0 || mat_(3,1) != -3 || mat_(3,2) != 5 || mat_(3,3) != -6 ||
6047 mat_(4,0) != 7 || mat_(4,1) != -8 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
6048 std::ostringstream oss;
6049 oss << " Test: " << test_ << "\n"
6050 << " Error: Transpose operation failed\n"
6051 << " Details:\n"
6052 << " Result:\n" << mat_ << "\n"
6053 << " Expected result:\n( 0 0 0 0 )\n"
6054 "( 0 -2 0 0 )\n"
6055 "( 1 0 4 0 )\n"
6056 "( 0 -3 5 -6 )\n"
6057 "( 7 -8 9 10 )\n";
6058 throw std::runtime_error( oss.str() );
6059 }
6060 }
6061
6062
6063 //=====================================================================================
6064 // Column-major submatrix tests
6065 //=====================================================================================
6066
6067 {
6068 test_ = "Column-major self-transpose via transpose()";
6069
6070 initialize();
6071
6072 OSMT sm = blaze::submatrix( tmat_, 0UL, 1UL, 3UL, 3UL );
6073
6074 transpose( sm );
6075
6076 checkRows ( sm , 3UL );
6077 checkColumns ( sm , 3UL );
6078 checkNonZeros( sm , 5UL );
6079 checkRows ( tmat_, 4UL );
6080 checkColumns ( tmat_, 5UL );
6081 checkNonZeros( tmat_, 10UL );
6082
6083 if( sm(0,0) != 0 || sm(0,1) != 1 || sm(0,2) != 0 ||
6084 sm(1,0) != -2 || sm(1,1) != 0 || sm(1,2) != -3 ||
6085 sm(2,0) != 0 || sm(2,1) != 4 || sm(2,2) != 5 ) {
6086 std::ostringstream oss;
6087 oss << " Test: " << test_ << "\n"
6088 << " Error: Transpose operation failed\n"
6089 << " Details:\n"
6090 << " Result:\n" << sm << "\n"
6091 << " Expected result:\n( 0 1 0 )\n( -2 0 -3 )\n( 0 4 5 )\n";
6092 throw std::runtime_error( oss.str() );
6093 }
6094
6095 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != 1 || tmat_(0,3) != 0 || tmat_(0,4) != 7 ||
6096 tmat_(1,0) != 0 || tmat_(1,1) != -2 || tmat_(1,2) != 0 || tmat_(1,3) != -3 || tmat_(1,4) != -8 ||
6097 tmat_(2,0) != 0 || tmat_(2,1) != 0 || tmat_(2,2) != 4 || tmat_(2,3) != 5 || tmat_(2,4) != 9 ||
6098 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
6099 std::ostringstream oss;
6100 oss << " Test: " << test_ << "\n"
6101 << " Error: Transpose operation failed\n"
6102 << " Details:\n"
6103 << " Result:\n" << tmat_ << "\n"
6104 << " Expected result:\n( 0 0 1 0 7 )\n"
6105 "( 0 -2 0 -3 -8 )\n"
6106 "( 0 0 4 5 9 )\n"
6107 "( 0 0 0 -6 10 )\n";
6108 throw std::runtime_error( oss.str() );
6109 }
6110 }
6111
6112 {
6113 test_ = "Column-major self-transpose via trans()";
6114
6115 initialize();
6116
6117 OSMT sm = blaze::submatrix( tmat_, 0UL, 1UL, 3UL, 3UL );
6118
6119 sm = trans( sm );
6120
6121 checkRows ( sm , 3UL );
6122 checkColumns ( sm , 3UL );
6123 checkNonZeros( sm , 5UL );
6124 checkRows ( tmat_, 4UL );
6125 checkColumns ( tmat_, 5UL );
6126 checkNonZeros( tmat_, 10UL );
6127
6128 if( sm(0,0) != 0 || sm(0,1) != 1 || sm(0,2) != 0 ||
6129 sm(1,0) != -2 || sm(1,1) != 0 || sm(1,2) != -3 ||
6130 sm(2,0) != 0 || sm(2,1) != 4 || sm(2,2) != 5 ) {
6131 std::ostringstream oss;
6132 oss << " Test: " << test_ << "\n"
6133 << " Error: Transpose operation failed\n"
6134 << " Details:\n"
6135 << " Result:\n" << sm << "\n"
6136 << " Expected result:\n( 0 1 0 )\n( -2 0 -3 )\n( 0 4 5 )\n";
6137 throw std::runtime_error( oss.str() );
6138 }
6139
6140 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != 1 || tmat_(0,3) != 0 || tmat_(0,4) != 7 ||
6141 tmat_(1,0) != 0 || tmat_(1,1) != -2 || tmat_(1,2) != 0 || tmat_(1,3) != -3 || tmat_(1,4) != -8 ||
6142 tmat_(2,0) != 0 || tmat_(2,1) != 0 || tmat_(2,2) != 4 || tmat_(2,3) != 5 || tmat_(2,4) != 9 ||
6143 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
6144 std::ostringstream oss;
6145 oss << " Test: " << test_ << "\n"
6146 << " Error: Transpose operation failed\n"
6147 << " Details:\n"
6148 << " Result:\n" << tmat_ << "\n"
6149 << " Expected result:\n( 0 0 1 0 7 )\n"
6150 "( 0 -2 0 -3 -8 )\n"
6151 "( 0 0 4 5 9 )\n"
6152 "( 0 0 0 -6 10 )\n";
6153 throw std::runtime_error( oss.str() );
6154 }
6155 }
6156 }
6157 //*************************************************************************************************
6158
6159
6160 //*************************************************************************************************
6161 /*!\brief Test of the \c ctranspose() member functions of the Submatrix class template.
6162 //
6163 // \return void
6164 // \exception std::runtime_error Error detected.
6165 //
6166 // This function performs a test of the \c ctranspose() member function of the Submatrix
6167 // specialization. Additionally, it performs a test of self-transpose via the \c ctrans()
6168 // function. In case an error is detected, a \a std::runtime_error exception is thrown.
6169 */
testCTranspose()6170 void SparseTest::testCTranspose()
6171 {
6172 //=====================================================================================
6173 // Row-major submatrix tests
6174 //=====================================================================================
6175
6176 {
6177 test_ = "Row-major self-transpose via ctranspose()";
6178
6179 initialize();
6180
6181 SMT sm = blaze::submatrix( mat_, 1UL, 0UL, 3UL, 3UL );
6182
6183 ctranspose( sm );
6184
6185 checkRows ( sm , 3UL );
6186 checkColumns ( sm , 3UL );
6187 checkNonZeros( sm , 5UL );
6188 checkRows ( mat_, 5UL );
6189 checkColumns ( mat_, 4UL );
6190 checkNonZeros( mat_, 10UL );
6191
6192 if( sm(0,0) != 0 || sm(0,1) != -2 || sm(0,2) != 0 ||
6193 sm(1,0) != 1 || sm(1,1) != 0 || sm(1,2) != 4 ||
6194 sm(2,0) != 0 || sm(2,1) != -3 || sm(2,2) != 5 ) {
6195 std::ostringstream oss;
6196 oss << " Test: " << test_ << "\n"
6197 << " Error: Transpose operation failed\n"
6198 << " Details:\n"
6199 << " Result:\n" << sm << "\n"
6200 << " Expected result:\n( 0 -2 0 )\n( 1 0 4 )\n( 0 -3 5 )\n";
6201 throw std::runtime_error( oss.str() );
6202 }
6203
6204 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
6205 mat_(1,0) != 0 || mat_(1,1) != -2 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
6206 mat_(2,0) != 1 || mat_(2,1) != 0 || mat_(2,2) != 4 || mat_(2,3) != 0 ||
6207 mat_(3,0) != 0 || mat_(3,1) != -3 || mat_(3,2) != 5 || mat_(3,3) != -6 ||
6208 mat_(4,0) != 7 || mat_(4,1) != -8 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
6209 std::ostringstream oss;
6210 oss << " Test: " << test_ << "\n"
6211 << " Error: Transpose operation failed\n"
6212 << " Details:\n"
6213 << " Result:\n" << mat_ << "\n"
6214 << " Expected result:\n( 0 0 0 0 )\n"
6215 "( 0 -2 0 0 )\n"
6216 "( 1 0 4 0 )\n"
6217 "( 0 -3 5 -6 )\n"
6218 "( 7 -8 9 10 )\n";
6219 throw std::runtime_error( oss.str() );
6220 }
6221 }
6222
6223 {
6224 test_ = "Row-major self-transpose via ctrans()";
6225
6226 initialize();
6227
6228 SMT sm = blaze::submatrix( mat_, 1UL, 0UL, 3UL, 3UL );
6229
6230 sm = ctrans( sm );
6231
6232 checkRows ( sm , 3UL );
6233 checkColumns ( sm , 3UL );
6234 checkNonZeros( sm , 5UL );
6235 checkRows ( mat_, 5UL );
6236 checkColumns ( mat_, 4UL );
6237 checkNonZeros( mat_, 10UL );
6238
6239 if( sm(0,0) != 0 || sm(0,1) != -2 || sm(0,2) != 0 ||
6240 sm(1,0) != 1 || sm(1,1) != 0 || sm(1,2) != 4 ||
6241 sm(2,0) != 0 || sm(2,1) != -3 || sm(2,2) != 5 ) {
6242 std::ostringstream oss;
6243 oss << " Test: " << test_ << "\n"
6244 << " Error: Transpose operation failed\n"
6245 << " Details:\n"
6246 << " Result:\n" << sm << "\n"
6247 << " Expected result:\n( 0 -2 0 )\n( 1 0 4 )\n( 0 -3 5 )\n";
6248 throw std::runtime_error( oss.str() );
6249 }
6250
6251 if( mat_(0,0) != 0 || mat_(0,1) != 0 || mat_(0,2) != 0 || mat_(0,3) != 0 ||
6252 mat_(1,0) != 0 || mat_(1,1) != -2 || mat_(1,2) != 0 || mat_(1,3) != 0 ||
6253 mat_(2,0) != 1 || mat_(2,1) != 0 || mat_(2,2) != 4 || mat_(2,3) != 0 ||
6254 mat_(3,0) != 0 || mat_(3,1) != -3 || mat_(3,2) != 5 || mat_(3,3) != -6 ||
6255 mat_(4,0) != 7 || mat_(4,1) != -8 || mat_(4,2) != 9 || mat_(4,3) != 10 ) {
6256 std::ostringstream oss;
6257 oss << " Test: " << test_ << "\n"
6258 << " Error: Transpose operation failed\n"
6259 << " Details:\n"
6260 << " Result:\n" << mat_ << "\n"
6261 << " Expected result:\n( 0 0 0 0 )\n"
6262 "( 0 -2 0 0 )\n"
6263 "( 1 0 4 0 )\n"
6264 "( 0 -3 5 -6 )\n"
6265 "( 7 -8 9 10 )\n";
6266 throw std::runtime_error( oss.str() );
6267 }
6268 }
6269
6270
6271 //=====================================================================================
6272 // Column-major submatrix tests
6273 //=====================================================================================
6274
6275 {
6276 test_ = "Column-major self-transpose via ctranspose()";
6277
6278 initialize();
6279
6280 OSMT sm = blaze::submatrix( tmat_, 0UL, 1UL, 3UL, 3UL );
6281
6282 ctranspose( sm );
6283
6284 checkRows ( sm , 3UL );
6285 checkColumns ( sm , 3UL );
6286 checkNonZeros( sm , 5UL );
6287 checkRows ( tmat_, 4UL );
6288 checkColumns ( tmat_, 5UL );
6289 checkNonZeros( tmat_, 10UL );
6290
6291 if( sm(0,0) != 0 || sm(0,1) != 1 || sm(0,2) != 0 ||
6292 sm(1,0) != -2 || sm(1,1) != 0 || sm(1,2) != -3 ||
6293 sm(2,0) != 0 || sm(2,1) != 4 || sm(2,2) != 5 ) {
6294 std::ostringstream oss;
6295 oss << " Test: " << test_ << "\n"
6296 << " Error: Transpose operation failed\n"
6297 << " Details:\n"
6298 << " Result:\n" << sm << "\n"
6299 << " Expected result:\n( 0 1 0 )\n( -2 0 -3 )\n( 0 4 5 )\n";
6300 throw std::runtime_error( oss.str() );
6301 }
6302
6303 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != 1 || tmat_(0,3) != 0 || tmat_(0,4) != 7 ||
6304 tmat_(1,0) != 0 || tmat_(1,1) != -2 || tmat_(1,2) != 0 || tmat_(1,3) != -3 || tmat_(1,4) != -8 ||
6305 tmat_(2,0) != 0 || tmat_(2,1) != 0 || tmat_(2,2) != 4 || tmat_(2,3) != 5 || tmat_(2,4) != 9 ||
6306 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
6307 std::ostringstream oss;
6308 oss << " Test: " << test_ << "\n"
6309 << " Error: Transpose operation failed\n"
6310 << " Details:\n"
6311 << " Result:\n" << tmat_ << "\n"
6312 << " Expected result:\n( 0 0 1 0 7 )\n"
6313 "( 0 -2 0 -3 -8 )\n"
6314 "( 0 0 4 5 9 )\n"
6315 "( 0 0 0 -6 10 )\n";
6316 throw std::runtime_error( oss.str() );
6317 }
6318 }
6319
6320 {
6321 test_ = "Column-major self-transpose via ctrans()";
6322
6323 initialize();
6324
6325 OSMT sm = blaze::submatrix( tmat_, 0UL, 1UL, 3UL, 3UL );
6326
6327 sm = ctrans( sm );
6328
6329 checkRows ( sm , 3UL );
6330 checkColumns ( sm , 3UL );
6331 checkNonZeros( sm , 5UL );
6332 checkRows ( tmat_, 4UL );
6333 checkColumns ( tmat_, 5UL );
6334 checkNonZeros( tmat_, 10UL );
6335
6336 if( sm(0,0) != 0 || sm(0,1) != 1 || sm(0,2) != 0 ||
6337 sm(1,0) != -2 || sm(1,1) != 0 || sm(1,2) != -3 ||
6338 sm(2,0) != 0 || sm(2,1) != 4 || sm(2,2) != 5 ) {
6339 std::ostringstream oss;
6340 oss << " Test: " << test_ << "\n"
6341 << " Error: Transpose operation failed\n"
6342 << " Details:\n"
6343 << " Result:\n" << sm << "\n"
6344 << " Expected result:\n( 0 1 0 )\n( -2 0 -3 )\n( 0 4 5 )\n";
6345 throw std::runtime_error( oss.str() );
6346 }
6347
6348 if( tmat_(0,0) != 0 || tmat_(0,1) != 0 || tmat_(0,2) != 1 || tmat_(0,3) != 0 || tmat_(0,4) != 7 ||
6349 tmat_(1,0) != 0 || tmat_(1,1) != -2 || tmat_(1,2) != 0 || tmat_(1,3) != -3 || tmat_(1,4) != -8 ||
6350 tmat_(2,0) != 0 || tmat_(2,1) != 0 || tmat_(2,2) != 4 || tmat_(2,3) != 5 || tmat_(2,4) != 9 ||
6351 tmat_(3,0) != 0 || tmat_(3,1) != 0 || tmat_(3,2) != 0 || tmat_(3,3) != -6 || tmat_(3,4) != 10 ) {
6352 std::ostringstream oss;
6353 oss << " Test: " << test_ << "\n"
6354 << " Error: Transpose operation failed\n"
6355 << " Details:\n"
6356 << " Result:\n" << tmat_ << "\n"
6357 << " Expected result:\n( 0 0 1 0 7 )\n"
6358 "( 0 -2 0 -3 -8 )\n"
6359 "( 0 0 4 5 9 )\n"
6360 "( 0 0 0 -6 10 )\n";
6361 throw std::runtime_error( oss.str() );
6362 }
6363 }
6364 }
6365 //*************************************************************************************************
6366
6367
6368 //*************************************************************************************************
6369 /*!\brief Test of the \c isDefault() function with the Submatrix class template.
6370 //
6371 // \return void
6372 // \exception std::runtime_error Error detected.
6373 //
6374 // This function performs a test of the \c isDefault() function with the Submatrix
6375 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
6376 */
testIsDefault()6377 void SparseTest::testIsDefault()
6378 {
6379 using blaze::isDefault;
6380
6381
6382 //=====================================================================================
6383 // Row-major submatrix tests
6384 //=====================================================================================
6385
6386 {
6387 test_ = "Row-major isDefault() function";
6388
6389 initialize();
6390
6391 // isDefault with default submatrix
6392 {
6393 SMT sm = blaze::submatrix( mat_, 0UL, 0UL, 1UL, 4UL );
6394
6395 if( isDefault( sm(0,1) ) != true ) {
6396 std::ostringstream oss;
6397 oss << " Test: " << test_ << "\n"
6398 << " Error: Invalid isDefault evaluation\n"
6399 << " Details:\n"
6400 << " Submatrix element: " << sm(0,1) << "\n";
6401 throw std::runtime_error( oss.str() );
6402 }
6403
6404 if( isDefault( sm ) != true ) {
6405 std::ostringstream oss;
6406 oss << " Test: " << test_ << "\n"
6407 << " Error: Invalid isDefault evaluation\n"
6408 << " Details:\n"
6409 << " Submatrix:\n" << sm << "\n";
6410 throw std::runtime_error( oss.str() );
6411 }
6412 }
6413
6414 // isDefault with non-default submatrix
6415 {
6416 SMT sm = blaze::submatrix( mat_, 1UL, 0UL, 1UL, 4UL );
6417
6418 if( isDefault( sm ) != false ) {
6419 std::ostringstream oss;
6420 oss << " Test: " << test_ << "\n"
6421 << " Error: Invalid isDefault evaluation\n"
6422 << " Details:\n"
6423 << " Submatrix:\n" << sm << "\n";
6424 throw std::runtime_error( oss.str() );
6425 }
6426 }
6427 }
6428
6429
6430 //=====================================================================================
6431 // Column-major submatrix tests
6432 //=====================================================================================
6433
6434 {
6435 test_ = "Column-major isDefault() function";
6436
6437 initialize();
6438
6439 // isDefault with default submatrix
6440 {
6441 OSMT sm = blaze::submatrix( tmat_, 0UL, 0UL, 4UL, 1UL );
6442
6443 if( isDefault( sm(1,0) ) != true ) {
6444 std::ostringstream oss;
6445 oss << " Test: " << test_ << "\n"
6446 << " Error: Invalid isDefault evaluation\n"
6447 << " Details:\n"
6448 << " Submatrix element: " << sm(1,0) << "\n";
6449 throw std::runtime_error( oss.str() );
6450 }
6451
6452 if( isDefault( sm ) != true ) {
6453 std::ostringstream oss;
6454 oss << " Test: " << test_ << "\n"
6455 << " Error: Invalid isDefault evaluation\n"
6456 << " Details:\n"
6457 << " Submatrix:\n" << sm << "\n";
6458 throw std::runtime_error( oss.str() );
6459 }
6460 }
6461
6462 // isDefault with non-default submatrix
6463 {
6464 OSMT sm = blaze::submatrix( tmat_, 0UL, 1UL, 4UL, 1UL );
6465
6466 if( isDefault( sm ) != false ) {
6467 std::ostringstream oss;
6468 oss << " Test: " << test_ << "\n"
6469 << " Error: Invalid isDefault evaluation\n"
6470 << " Details:\n"
6471 << " Submatrix:\n" << sm << "\n";
6472 throw std::runtime_error( oss.str() );
6473 }
6474 }
6475 }
6476 }
6477 //*************************************************************************************************
6478
6479
6480 //*************************************************************************************************
6481 /*!\brief Test of the \c isSame() function with the Submatrix class template.
6482 //
6483 // \return void
6484 // \exception std::runtime_error Error detected.
6485 //
6486 // This function performs a test of the \c isSame() function with the Submatrix specialization.
6487 // In case an error is detected, a \a std::runtime_error exception is thrown.
6488 */
testIsSame()6489 void SparseTest::testIsSame()
6490 {
6491 //=====================================================================================
6492 // Row-major matrix-based tests
6493 //=====================================================================================
6494
6495 {
6496 test_ = "Row-major isSame() function (matrix-based)";
6497
6498 // isSame with matrix and matching submatrix
6499 {
6500 SMT sm = blaze::submatrix( mat_, 0UL, 0UL, 5UL, 4UL );
6501
6502 if( blaze::isSame( sm, mat_ ) == false ) {
6503 std::ostringstream oss;
6504 oss << " Test: " << test_ << "\n"
6505 << " Error: Invalid isSame evaluation\n"
6506 << " Details:\n"
6507 << " Matrix:\n" << mat_ << "\n"
6508 << " Submatrix:\n" << sm << "\n";
6509 throw std::runtime_error( oss.str() );
6510 }
6511
6512 if( blaze::isSame( mat_, sm ) == false ) {
6513 std::ostringstream oss;
6514 oss << " Test: " << test_ << "\n"
6515 << " Error: Invalid isSame evaluation\n"
6516 << " Details:\n"
6517 << " Matrix:\n" << mat_ << "\n"
6518 << " Submatrix:\n" << sm << "\n";
6519 throw std::runtime_error( oss.str() );
6520 }
6521 }
6522
6523 // isSame with matrix and non-matching submatrix (different number of rows)
6524 {
6525 SMT sm = blaze::submatrix( mat_, 0UL, 0UL, 4UL, 4UL );
6526
6527 if( blaze::isSame( sm, mat_ ) == true ) {
6528 std::ostringstream oss;
6529 oss << " Test: " << test_ << "\n"
6530 << " Error: Invalid isSame evaluation\n"
6531 << " Details:\n"
6532 << " Matrix:\n" << mat_ << "\n"
6533 << " Submatrix:\n" << sm << "\n";
6534 throw std::runtime_error( oss.str() );
6535 }
6536
6537 if( blaze::isSame( mat_, sm ) == true ) {
6538 std::ostringstream oss;
6539 oss << " Test: " << test_ << "\n"
6540 << " Error: Invalid isSame evaluation\n"
6541 << " Details:\n"
6542 << " Matrix:\n" << mat_ << "\n"
6543 << " Submatrix:\n" << sm << "\n";
6544 throw std::runtime_error( oss.str() );
6545 }
6546 }
6547
6548 // isSame with matrix and non-matching submatrix (different number of columns)
6549 {
6550 SMT sm = blaze::submatrix( mat_, 0UL, 0UL, 5UL, 3UL );
6551
6552 if( blaze::isSame( sm, mat_ ) == true ) {
6553 std::ostringstream oss;
6554 oss << " Test: " << test_ << "\n"
6555 << " Error: Invalid isSame evaluation\n"
6556 << " Details:\n"
6557 << " Matrix:\n" << mat_ << "\n"
6558 << " Submatrix:\n" << sm << "\n";
6559 throw std::runtime_error( oss.str() );
6560 }
6561
6562 if( blaze::isSame( mat_, sm ) == true ) {
6563 std::ostringstream oss;
6564 oss << " Test: " << test_ << "\n"
6565 << " Error: Invalid isSame evaluation\n"
6566 << " Details:\n"
6567 << " Matrix:\n" << mat_ << "\n"
6568 << " Submatrix:\n" << sm << "\n";
6569 throw std::runtime_error( oss.str() );
6570 }
6571 }
6572
6573 // isSame with matrix and non-matching submatrix (different row index)
6574 {
6575 SMT sm = blaze::submatrix( mat_, 1UL, 0UL, 4UL, 4UL );
6576
6577 if( blaze::isSame( sm, mat_ ) == true ) {
6578 std::ostringstream oss;
6579 oss << " Test: " << test_ << "\n"
6580 << " Error: Invalid isSame evaluation\n"
6581 << " Details:\n"
6582 << " Matrix:\n" << mat_ << "\n"
6583 << " Submatrix:\n" << sm << "\n";
6584 throw std::runtime_error( oss.str() );
6585 }
6586
6587 if( blaze::isSame( mat_, sm ) == true ) {
6588 std::ostringstream oss;
6589 oss << " Test: " << test_ << "\n"
6590 << " Error: Invalid isSame evaluation\n"
6591 << " Details:\n"
6592 << " Matrix:\n" << mat_ << "\n"
6593 << " Submatrix:\n" << sm << "\n";
6594 throw std::runtime_error( oss.str() );
6595 }
6596 }
6597
6598 // isSame with matrix and non-matching submatrix (different column index)
6599 {
6600 SMT sm = blaze::submatrix( mat_, 0UL, 1UL, 5UL, 3UL );
6601
6602 if( blaze::isSame( sm, mat_ ) == true ) {
6603 std::ostringstream oss;
6604 oss << " Test: " << test_ << "\n"
6605 << " Error: Invalid isSame evaluation\n"
6606 << " Details:\n"
6607 << " Matrix:\n" << mat_ << "\n"
6608 << " Submatrix:\n" << sm << "\n";
6609 throw std::runtime_error( oss.str() );
6610 }
6611
6612 if( blaze::isSame( mat_, sm ) == true ) {
6613 std::ostringstream oss;
6614 oss << " Test: " << test_ << "\n"
6615 << " Error: Invalid isSame evaluation\n"
6616 << " Details:\n"
6617 << " Matrix:\n" << mat_ << "\n"
6618 << " Submatrix:\n" << sm << "\n";
6619 throw std::runtime_error( oss.str() );
6620 }
6621 }
6622
6623 // isSame with matching submatrices
6624 {
6625 SMT sm1 = blaze::submatrix( mat_, 0UL, 0UL, 5UL, 4UL );
6626 SMT sm2 = blaze::submatrix( mat_, 0UL, 0UL, 5UL, 4UL );
6627
6628 if( blaze::isSame( sm1, sm2 ) == false ) {
6629 std::ostringstream oss;
6630 oss << " Test: " << test_ << "\n"
6631 << " Error: Invalid isSame evaluation\n"
6632 << " Details:\n"
6633 << " First submatrix:\n" << sm1 << "\n"
6634 << " Second submatrix:\n" << sm2 << "\n";
6635 throw std::runtime_error( oss.str() );
6636 }
6637 }
6638
6639 // isSame with non-matching submatrices (different number of rows)
6640 {
6641 SMT sm1 = blaze::submatrix( mat_, 0UL, 0UL, 5UL, 4UL );
6642 SMT sm2 = blaze::submatrix( mat_, 0UL, 0UL, 4UL, 4UL );
6643
6644 if( blaze::isSame( sm1, sm2 ) == true ) {
6645 std::ostringstream oss;
6646 oss << " Test: " << test_ << "\n"
6647 << " Error: Invalid isSame evaluation\n"
6648 << " Details:\n"
6649 << " First submatrix:\n" << sm1 << "\n"
6650 << " Second submatrix:\n" << sm2 << "\n";
6651 throw std::runtime_error( oss.str() );
6652 }
6653 }
6654
6655 // isSame with non-matching submatrices (different number of columns)
6656 {
6657 SMT sm1 = blaze::submatrix( mat_, 0UL, 0UL, 5UL, 4UL );
6658 SMT sm2 = blaze::submatrix( mat_, 0UL, 0UL, 5UL, 3UL );
6659
6660 if( blaze::isSame( sm1, sm2 ) == true ) {
6661 std::ostringstream oss;
6662 oss << " Test: " << test_ << "\n"
6663 << " Error: Invalid isSame evaluation\n"
6664 << " Details:\n"
6665 << " First submatrix:\n" << sm1 << "\n"
6666 << " Second submatrix:\n" << sm2 << "\n";
6667 throw std::runtime_error( oss.str() );
6668 }
6669 }
6670
6671 // isSame with non-matching submatrices (different row index)
6672 {
6673 SMT sm1 = blaze::submatrix( mat_, 0UL, 0UL, 5UL, 4UL );
6674 SMT sm2 = blaze::submatrix( mat_, 1UL, 0UL, 4UL, 4UL );
6675
6676 if( blaze::isSame( sm1, sm2 ) == true ) {
6677 std::ostringstream oss;
6678 oss << " Test: " << test_ << "\n"
6679 << " Error: Invalid isSame evaluation\n"
6680 << " Details:\n"
6681 << " First submatrix:\n" << sm1 << "\n"
6682 << " Second submatrix:\n" << sm2 << "\n";
6683 throw std::runtime_error( oss.str() );
6684 }
6685 }
6686
6687 // isSame with non-matching submatrices (different column index)
6688 {
6689 SMT sm1 = blaze::submatrix( mat_, 0UL, 0UL, 5UL, 4UL );
6690 SMT sm2 = blaze::submatrix( mat_, 0UL, 1UL, 5UL, 3UL );
6691
6692 if( blaze::isSame( sm1, sm2 ) == true ) {
6693 std::ostringstream oss;
6694 oss << " Test: " << test_ << "\n"
6695 << " Error: Invalid isSame evaluation\n"
6696 << " Details:\n"
6697 << " First submatrix:\n" << sm1 << "\n"
6698 << " Second submatrix:\n" << sm2 << "\n";
6699 throw std::runtime_error( oss.str() );
6700 }
6701 }
6702 }
6703
6704
6705 //=====================================================================================
6706 // Row-major rows-based tests
6707 //=====================================================================================
6708
6709 {
6710 test_ = "Row-major isSame() function (rows-based)";
6711
6712 // isSame with row selection and matching submatrix
6713 {
6714 auto rs = blaze::rows( mat_, { 0UL, 3UL, 2UL } );
6715 auto sm = blaze::submatrix( rs, 0UL, 0UL, 3UL, 4UL );
6716
6717 if( blaze::isSame( sm, rs ) == false ) {
6718 std::ostringstream oss;
6719 oss << " Test: " << test_ << "\n"
6720 << " Error: Invalid isSame evaluation\n"
6721 << " Details:\n"
6722 << " Row selection:\n" << rs << "\n"
6723 << " Submatrix:\n" << sm << "\n";
6724 throw std::runtime_error( oss.str() );
6725 }
6726
6727 if( blaze::isSame( rs, sm ) == false ) {
6728 std::ostringstream oss;
6729 oss << " Test: " << test_ << "\n"
6730 << " Error: Invalid isSame evaluation\n"
6731 << " Details:\n"
6732 << " Row selection:\n" << rs << "\n"
6733 << " Submatrix:\n" << sm << "\n";
6734 throw std::runtime_error( oss.str() );
6735 }
6736 }
6737
6738 // isSame with row selection and non-matching submatrix (different number of rows)
6739 {
6740 auto rs = blaze::rows( mat_, { 0UL, 3UL, 2UL } );
6741 auto sm = blaze::submatrix( rs, 0UL, 0UL, 2UL, 4UL );
6742
6743 if( blaze::isSame( sm, rs ) == true ) {
6744 std::ostringstream oss;
6745 oss << " Test: " << test_ << "\n"
6746 << " Error: Invalid isSame evaluation\n"
6747 << " Details:\n"
6748 << " Row selection:\n" << rs << "\n"
6749 << " Submatrix:\n" << sm << "\n";
6750 throw std::runtime_error( oss.str() );
6751 }
6752
6753 if( blaze::isSame( rs, sm ) == true ) {
6754 std::ostringstream oss;
6755 oss << " Test: " << test_ << "\n"
6756 << " Error: Invalid isSame evaluation\n"
6757 << " Details:\n"
6758 << " Row selection:\n" << rs << "\n"
6759 << " Submatrix:\n" << sm << "\n";
6760 throw std::runtime_error( oss.str() );
6761 }
6762 }
6763
6764 // isSame with row selection and non-matching submatrix (different number of columns)
6765 {
6766 auto rs = blaze::rows( mat_, { 0UL, 3UL, 2UL } );
6767 auto sm = blaze::submatrix( rs, 0UL, 0UL, 3UL, 3UL );
6768
6769 if( blaze::isSame( sm, rs ) == true ) {
6770 std::ostringstream oss;
6771 oss << " Test: " << test_ << "\n"
6772 << " Error: Invalid isSame evaluation\n"
6773 << " Details:\n"
6774 << " Row selection:\n" << rs << "\n"
6775 << " Submatrix:\n" << sm << "\n";
6776 throw std::runtime_error( oss.str() );
6777 }
6778
6779 if( blaze::isSame( rs, sm ) == true ) {
6780 std::ostringstream oss;
6781 oss << " Test: " << test_ << "\n"
6782 << " Error: Invalid isSame evaluation\n"
6783 << " Details:\n"
6784 << " Row selection:\n" << rs << "\n"
6785 << " Submatrix:\n" << sm << "\n";
6786 throw std::runtime_error( oss.str() );
6787 }
6788 }
6789
6790 // isSame with row selection and non-matching submatrix (different row index)
6791 {
6792 auto rs = blaze::rows( mat_, { 0UL, 3UL, 2UL } );
6793 auto sm = blaze::submatrix( rs, 1UL, 0UL, 2UL, 4UL );
6794
6795 if( blaze::isSame( sm, rs ) == true ) {
6796 std::ostringstream oss;
6797 oss << " Test: " << test_ << "\n"
6798 << " Error: Invalid isSame evaluation\n"
6799 << " Details:\n"
6800 << " Row selection:\n" << rs << "\n"
6801 << " Submatrix:\n" << sm << "\n";
6802 throw std::runtime_error( oss.str() );
6803 }
6804
6805 if( blaze::isSame( rs, sm ) == true ) {
6806 std::ostringstream oss;
6807 oss << " Test: " << test_ << "\n"
6808 << " Error: Invalid isSame evaluation\n"
6809 << " Details:\n"
6810 << " Row selection:\n" << rs << "\n"
6811 << " Submatrix:\n" << sm << "\n";
6812 throw std::runtime_error( oss.str() );
6813 }
6814 }
6815
6816 // isSame with row selection and non-matching submatrix (different column index)
6817 {
6818 auto rs = blaze::rows( mat_, { 0UL, 3UL, 2UL } );
6819 auto sm = blaze::submatrix( rs, 0UL, 1UL, 3UL, 3UL );
6820
6821 if( blaze::isSame( sm, rs ) == true ) {
6822 std::ostringstream oss;
6823 oss << " Test: " << test_ << "\n"
6824 << " Error: Invalid isSame evaluation\n"
6825 << " Details:\n"
6826 << " Row selection:\n" << rs << "\n"
6827 << " Submatrix:\n" << sm << "\n";
6828 throw std::runtime_error( oss.str() );
6829 }
6830
6831 if( blaze::isSame( rs, sm ) == true ) {
6832 std::ostringstream oss;
6833 oss << " Test: " << test_ << "\n"
6834 << " Error: Invalid isSame evaluation\n"
6835 << " Details:\n"
6836 << " Row selection:\n" << rs << "\n"
6837 << " Submatrix:\n" << sm << "\n";
6838 throw std::runtime_error( oss.str() );
6839 }
6840 }
6841
6842 // isSame with matching submatrices
6843 {
6844 auto rs = blaze::rows( mat_, { 0UL, 3UL, 2UL } );
6845 auto sm1 = blaze::submatrix( rs, 0UL, 0UL, 2UL, 3UL );
6846 auto sm2 = blaze::submatrix( rs, 0UL, 0UL, 2UL, 3UL );
6847
6848 if( blaze::isSame( sm1, sm2 ) == false ) {
6849 std::ostringstream oss;
6850 oss << " Test: " << test_ << "\n"
6851 << " Error: Invalid isSame evaluation\n"
6852 << " Details:\n"
6853 << " First submatrix:\n" << sm1 << "\n"
6854 << " Second submatrix:\n" << sm2 << "\n";
6855 throw std::runtime_error( oss.str() );
6856 }
6857 }
6858
6859 // isSame with non-matching submatrices (different number of rows)
6860 {
6861 auto rs = blaze::rows( mat_, { 0UL, 3UL, 2UL } );
6862 auto sm1 = blaze::submatrix( rs, 0UL, 0UL, 2UL, 3UL );
6863 auto sm2 = blaze::submatrix( rs, 0UL, 0UL, 1UL, 3UL );
6864
6865 if( blaze::isSame( sm1, sm2 ) == true ) {
6866 std::ostringstream oss;
6867 oss << " Test: " << test_ << "\n"
6868 << " Error: Invalid isSame evaluation\n"
6869 << " Details:\n"
6870 << " First submatrix:\n" << sm1 << "\n"
6871 << " Second submatrix:\n" << sm2 << "\n";
6872 throw std::runtime_error( oss.str() );
6873 }
6874 }
6875
6876 // isSame with non-matching submatrices (different number of columns)
6877 {
6878 auto rs = blaze::rows( mat_, { 0UL, 3UL, 2UL } );
6879 auto sm1 = blaze::submatrix( rs, 0UL, 0UL, 2UL, 3UL );
6880 auto sm2 = blaze::submatrix( rs, 0UL, 0UL, 2UL, 2UL );
6881
6882 if( blaze::isSame( sm1, sm2 ) == true ) {
6883 std::ostringstream oss;
6884 oss << " Test: " << test_ << "\n"
6885 << " Error: Invalid isSame evaluation\n"
6886 << " Details:\n"
6887 << " First submatrix:\n" << sm1 << "\n"
6888 << " Second submatrix:\n" << sm2 << "\n";
6889 throw std::runtime_error( oss.str() );
6890 }
6891 }
6892
6893 // isSame with non-matching submatrices (different row index)
6894 {
6895 auto rs = blaze::rows( mat_, { 0UL, 3UL, 2UL } );
6896 auto sm1 = blaze::submatrix( rs, 0UL, 0UL, 2UL, 3UL );
6897 auto sm2 = blaze::submatrix( rs, 1UL, 0UL, 2UL, 3UL );
6898
6899 if( blaze::isSame( sm1, sm2 ) == true ) {
6900 std::ostringstream oss;
6901 oss << " Test: " << test_ << "\n"
6902 << " Error: Invalid isSame evaluation\n"
6903 << " Details:\n"
6904 << " First submatrix:\n" << sm1 << "\n"
6905 << " Second submatrix:\n" << sm2 << "\n";
6906 throw std::runtime_error( oss.str() );
6907 }
6908 }
6909
6910 // isSame with non-matching submatrices (different column index)
6911 {
6912 auto rs = blaze::rows( mat_, { 0UL, 3UL, 2UL } );
6913 auto sm1 = blaze::submatrix( rs, 0UL, 0UL, 2UL, 3UL );
6914 auto sm2 = blaze::submatrix( rs, 0UL, 1UL, 2UL, 3UL );
6915
6916 if( blaze::isSame( sm1, sm2 ) == true ) {
6917 std::ostringstream oss;
6918 oss << " Test: " << test_ << "\n"
6919 << " Error: Invalid isSame evaluation\n"
6920 << " Details:\n"
6921 << " First submatrix:\n" << sm1 << "\n"
6922 << " Second submatrix:\n" << sm2 << "\n";
6923 throw std::runtime_error( oss.str() );
6924 }
6925 }
6926 }
6927
6928
6929 //=====================================================================================
6930 // Row-major columns-based tests
6931 //=====================================================================================
6932
6933 {
6934 test_ = "Row-major isSame() function (columns-based)";
6935
6936 // isSame with column selection and matching submatrix
6937 {
6938 auto cs = blaze::columns( mat_, { 0UL, 3UL, 2UL } );
6939 auto sm = blaze::submatrix( cs, 0UL, 0UL, 5UL, 3UL );
6940
6941 if( blaze::isSame( sm, cs ) == false ) {
6942 std::ostringstream oss;
6943 oss << " Test: " << test_ << "\n"
6944 << " Error: Invalid isSame evaluation\n"
6945 << " Details:\n"
6946 << " Column selection:\n" << cs << "\n"
6947 << " Submatrix:\n" << sm << "\n";
6948 throw std::runtime_error( oss.str() );
6949 }
6950
6951 if( blaze::isSame( cs, sm ) == false ) {
6952 std::ostringstream oss;
6953 oss << " Test: " << test_ << "\n"
6954 << " Error: Invalid isSame evaluation\n"
6955 << " Details:\n"
6956 << " Column selection:\n" << cs << "\n"
6957 << " Submatrix:\n" << sm << "\n";
6958 throw std::runtime_error( oss.str() );
6959 }
6960 }
6961
6962 // isSame with column selection and non-matching submatrix (different number of rows)
6963 {
6964 auto cs = blaze::columns( mat_, { 0UL, 3UL, 2UL } );
6965 auto sm = blaze::submatrix( cs, 0UL, 0UL, 4UL, 3UL );
6966
6967 if( blaze::isSame( sm, cs ) == true ) {
6968 std::ostringstream oss;
6969 oss << " Test: " << test_ << "\n"
6970 << " Error: Invalid isSame evaluation\n"
6971 << " Details:\n"
6972 << " Column selection:\n" << cs << "\n"
6973 << " Submatrix:\n" << sm << "\n";
6974 throw std::runtime_error( oss.str() );
6975 }
6976
6977 if( blaze::isSame( cs, sm ) == true ) {
6978 std::ostringstream oss;
6979 oss << " Test: " << test_ << "\n"
6980 << " Error: Invalid isSame evaluation\n"
6981 << " Details:\n"
6982 << " Column selection:\n" << cs << "\n"
6983 << " Submatrix:\n" << sm << "\n";
6984 throw std::runtime_error( oss.str() );
6985 }
6986 }
6987
6988 // isSame with column selection and non-matching submatrix (different number of columns)
6989 {
6990 auto cs = blaze::columns( mat_, { 0UL, 3UL, 2UL } );
6991 auto sm = blaze::submatrix( cs, 0UL, 0UL, 5UL, 2UL );
6992
6993 if( blaze::isSame( sm, cs ) == true ) {
6994 std::ostringstream oss;
6995 oss << " Test: " << test_ << "\n"
6996 << " Error: Invalid isSame evaluation\n"
6997 << " Details:\n"
6998 << " Column selection:\n" << cs << "\n"
6999 << " Submatrix:\n" << sm << "\n";
7000 throw std::runtime_error( oss.str() );
7001 }
7002
7003 if( blaze::isSame( cs, sm ) == true ) {
7004 std::ostringstream oss;
7005 oss << " Test: " << test_ << "\n"
7006 << " Error: Invalid isSame evaluation\n"
7007 << " Details:\n"
7008 << " Column selection:\n" << cs << "\n"
7009 << " Submatrix:\n" << sm << "\n";
7010 throw std::runtime_error( oss.str() );
7011 }
7012 }
7013
7014 // isSame with column selection and non-matching submatrix (different row index)
7015 {
7016 auto cs = blaze::columns( mat_, { 0UL, 3UL, 2UL } );
7017 auto sm = blaze::submatrix( cs, 1UL, 0UL, 4UL, 3UL );
7018
7019 if( blaze::isSame( sm, cs ) == true ) {
7020 std::ostringstream oss;
7021 oss << " Test: " << test_ << "\n"
7022 << " Error: Invalid isSame evaluation\n"
7023 << " Details:\n"
7024 << " Column selection:\n" << cs << "\n"
7025 << " Submatrix:\n" << sm << "\n";
7026 throw std::runtime_error( oss.str() );
7027 }
7028
7029 if( blaze::isSame( cs, sm ) == true ) {
7030 std::ostringstream oss;
7031 oss << " Test: " << test_ << "\n"
7032 << " Error: Invalid isSame evaluation\n"
7033 << " Details:\n"
7034 << " Column selection:\n" << cs << "\n"
7035 << " Submatrix:\n" << sm << "\n";
7036 throw std::runtime_error( oss.str() );
7037 }
7038 }
7039
7040 // isSame with column selection and non-matching submatrix (different column index)
7041 {
7042 auto cs = blaze::columns( mat_, { 0UL, 3UL, 2UL } );
7043 auto sm = blaze::submatrix( cs, 0UL, 1UL, 5UL, 2UL );
7044
7045 if( blaze::isSame( sm, cs ) == true ) {
7046 std::ostringstream oss;
7047 oss << " Test: " << test_ << "\n"
7048 << " Error: Invalid isSame evaluation\n"
7049 << " Details:\n"
7050 << " Column selection:\n" << cs << "\n"
7051 << " Submatrix:\n" << sm << "\n";
7052 throw std::runtime_error( oss.str() );
7053 }
7054
7055 if( blaze::isSame( cs, sm ) == true ) {
7056 std::ostringstream oss;
7057 oss << " Test: " << test_ << "\n"
7058 << " Error: Invalid isSame evaluation\n"
7059 << " Details:\n"
7060 << " Column selection:\n" << cs << "\n"
7061 << " Submatrix:\n" << sm << "\n";
7062 throw std::runtime_error( oss.str() );
7063 }
7064 }
7065
7066 // isSame with matching submatrices
7067 {
7068 auto cs = blaze::columns( mat_, { 0UL, 3UL, 2UL } );
7069 auto sm1 = blaze::submatrix( cs, 0UL, 0UL, 4UL, 2UL );
7070 auto sm2 = blaze::submatrix( cs, 0UL, 0UL, 4UL, 2UL );
7071
7072 if( blaze::isSame( sm1, sm2 ) == false ) {
7073 std::ostringstream oss;
7074 oss << " Test: " << test_ << "\n"
7075 << " Error: Invalid isSame evaluation\n"
7076 << " Details:\n"
7077 << " First submatrix:\n" << sm1 << "\n"
7078 << " Second submatrix:\n" << sm2 << "\n";
7079 throw std::runtime_error( oss.str() );
7080 }
7081 }
7082
7083 // isSame with non-matching submatrices (different number of rows)
7084 {
7085 auto cs = blaze::columns( mat_, { 0UL, 3UL, 2UL } );
7086 auto sm1 = blaze::submatrix( cs, 0UL, 0UL, 4UL, 2UL );
7087 auto sm2 = blaze::submatrix( cs, 0UL, 0UL, 3UL, 2UL );
7088
7089 if( blaze::isSame( sm1, sm2 ) == true ) {
7090 std::ostringstream oss;
7091 oss << " Test: " << test_ << "\n"
7092 << " Error: Invalid isSame evaluation\n"
7093 << " Details:\n"
7094 << " First submatrix:\n" << sm1 << "\n"
7095 << " Second submatrix:\n" << sm2 << "\n";
7096 throw std::runtime_error( oss.str() );
7097 }
7098 }
7099
7100 // isSame with non-matching submatrices (different number of columns)
7101 {
7102 auto cs = blaze::columns( mat_, { 0UL, 3UL, 2UL } );
7103 auto sm1 = blaze::submatrix( cs, 0UL, 0UL, 4UL, 2UL );
7104 auto sm2 = blaze::submatrix( cs, 0UL, 0UL, 4UL, 1UL );
7105
7106 if( blaze::isSame( sm1, sm2 ) == true ) {
7107 std::ostringstream oss;
7108 oss << " Test: " << test_ << "\n"
7109 << " Error: Invalid isSame evaluation\n"
7110 << " Details:\n"
7111 << " First submatrix:\n" << sm1 << "\n"
7112 << " Second submatrix:\n" << sm2 << "\n";
7113 throw std::runtime_error( oss.str() );
7114 }
7115 }
7116
7117 // isSame with non-matching submatrices (different row index)
7118 {
7119 auto cs = blaze::columns( mat_, { 0UL, 3UL, 2UL } );
7120 auto sm1 = blaze::submatrix( cs, 0UL, 0UL, 4UL, 2UL );
7121 auto sm2 = blaze::submatrix( cs, 1UL, 0UL, 4UL, 2UL );
7122
7123 if( blaze::isSame( sm1, sm2 ) == true ) {
7124 std::ostringstream oss;
7125 oss << " Test: " << test_ << "\n"
7126 << " Error: Invalid isSame evaluation\n"
7127 << " Details:\n"
7128 << " First submatrix:\n" << sm1 << "\n"
7129 << " Second submatrix:\n" << sm2 << "\n";
7130 throw std::runtime_error( oss.str() );
7131 }
7132 }
7133
7134 // isSame with non-matching submatrices (different column index)
7135 {
7136 auto cs = blaze::columns( mat_, { 0UL, 3UL, 2UL } );
7137 auto sm1 = blaze::submatrix( cs, 0UL, 0UL, 4UL, 2UL );
7138 auto sm2 = blaze::submatrix( cs, 0UL, 1UL, 4UL, 2UL );
7139
7140 if( blaze::isSame( sm1, sm2 ) == true ) {
7141 std::ostringstream oss;
7142 oss << " Test: " << test_ << "\n"
7143 << " Error: Invalid isSame evaluation\n"
7144 << " Details:\n"
7145 << " First submatrix:\n" << sm1 << "\n"
7146 << " Second submatrix:\n" << sm2 << "\n";
7147 throw std::runtime_error( oss.str() );
7148 }
7149 }
7150 }
7151
7152
7153 //=====================================================================================
7154 // Column-major matrix-based tests
7155 //=====================================================================================
7156
7157 {
7158 test_ = "Column-major isSame() function (matrix-based)";
7159
7160 // isSame with matrix and matching submatrix
7161 {
7162 OSMT sm = blaze::submatrix( tmat_, 0UL, 0UL, 4UL, 5UL );
7163
7164 if( blaze::isSame( sm, tmat_ ) == false ) {
7165 std::ostringstream oss;
7166 oss << " Test: " << test_ << "\n"
7167 << " Error: Invalid isSame evaluation\n"
7168 << " Details:\n"
7169 << " Matrix:\n" << tmat_ << "\n"
7170 << " Submatrix:\n" << sm << "\n";
7171 throw std::runtime_error( oss.str() );
7172 }
7173
7174 if( blaze::isSame( tmat_, sm ) == false ) {
7175 std::ostringstream oss;
7176 oss << " Test: " << test_ << "\n"
7177 << " Error: Invalid isSame evaluation\n"
7178 << " Details:\n"
7179 << " Matrix:\n" << tmat_ << "\n"
7180 << " Submatrix:\n" << sm << "\n";
7181 throw std::runtime_error( oss.str() );
7182 }
7183 }
7184
7185 // isSame with matrix and non-matching submatrix (different number of rows)
7186 {
7187 OSMT sm = blaze::submatrix( tmat_, 0UL, 0UL, 3UL, 5UL );
7188
7189 if( blaze::isSame( sm, tmat_ ) == true ) {
7190 std::ostringstream oss;
7191 oss << " Test: " << test_ << "\n"
7192 << " Error: Invalid isSame evaluation\n"
7193 << " Details:\n"
7194 << " Matrix:\n" << tmat_ << "\n"
7195 << " Submatrix:\n" << sm << "\n";
7196 throw std::runtime_error( oss.str() );
7197 }
7198
7199 if( blaze::isSame( tmat_, sm ) == true ) {
7200 std::ostringstream oss;
7201 oss << " Test: " << test_ << "\n"
7202 << " Error: Invalid isSame evaluation\n"
7203 << " Details:\n"
7204 << " Matrix:\n" << tmat_ << "\n"
7205 << " Submatrix:\n" << sm << "\n";
7206 throw std::runtime_error( oss.str() );
7207 }
7208 }
7209
7210 // isSame with matrix and non-matching submatrix (different number of columns)
7211 {
7212 OSMT sm = blaze::submatrix( tmat_, 0UL, 0UL, 4UL, 4UL );
7213
7214 if( blaze::isSame( sm, tmat_ ) == true ) {
7215 std::ostringstream oss;
7216 oss << " Test: " << test_ << "\n"
7217 << " Error: Invalid isSame evaluation\n"
7218 << " Details:\n"
7219 << " Matrix:\n" << tmat_ << "\n"
7220 << " Submatrix:\n" << sm << "\n";
7221 throw std::runtime_error( oss.str() );
7222 }
7223
7224 if( blaze::isSame( tmat_, sm ) == true ) {
7225 std::ostringstream oss;
7226 oss << " Test: " << test_ << "\n"
7227 << " Error: Invalid isSame evaluation\n"
7228 << " Details:\n"
7229 << " Matrix:\n" << tmat_ << "\n"
7230 << " Submatrix:\n" << sm << "\n";
7231 throw std::runtime_error( oss.str() );
7232 }
7233 }
7234
7235 // isSame with matrix and non-matching submatrix (different row index)
7236 {
7237 OSMT sm = blaze::submatrix( tmat_, 1UL, 0UL, 3UL, 5UL );
7238
7239 if( blaze::isSame( sm, tmat_ ) == true ) {
7240 std::ostringstream oss;
7241 oss << " Test: " << test_ << "\n"
7242 << " Error: Invalid isSame evaluation\n"
7243 << " Details:\n"
7244 << " Matrix:\n" << tmat_ << "\n"
7245 << " Submatrix:\n" << sm << "\n";
7246 throw std::runtime_error( oss.str() );
7247 }
7248
7249 if( blaze::isSame( tmat_, sm ) == true ) {
7250 std::ostringstream oss;
7251 oss << " Test: " << test_ << "\n"
7252 << " Error: Invalid isSame evaluation\n"
7253 << " Details:\n"
7254 << " Matrix:\n" << tmat_ << "\n"
7255 << " Submatrix:\n" << sm << "\n";
7256 throw std::runtime_error( oss.str() );
7257 }
7258 }
7259
7260 // isSame with matrix and non-matching submatrix (different column index)
7261 {
7262 OSMT sm = blaze::submatrix( tmat_, 0UL, 1UL, 4UL, 4UL );
7263
7264 if( blaze::isSame( sm, tmat_ ) == true ) {
7265 std::ostringstream oss;
7266 oss << " Test: " << test_ << "\n"
7267 << " Error: Invalid isSame evaluation\n"
7268 << " Details:\n"
7269 << " Matrix:\n" << tmat_ << "\n"
7270 << " Submatrix:\n" << sm << "\n";
7271 throw std::runtime_error( oss.str() );
7272 }
7273
7274 if( blaze::isSame( tmat_, sm ) == true ) {
7275 std::ostringstream oss;
7276 oss << " Test: " << test_ << "\n"
7277 << " Error: Invalid isSame evaluation\n"
7278 << " Details:\n"
7279 << " Matrix:\n" << tmat_ << "\n"
7280 << " Submatrix:\n" << sm << "\n";
7281 throw std::runtime_error( oss.str() );
7282 }
7283 }
7284
7285 // isSame with matching submatrices
7286 {
7287 OSMT sm1 = blaze::submatrix( tmat_, 0UL, 0UL, 4UL, 5UL );
7288 OSMT sm2 = blaze::submatrix( tmat_, 0UL, 0UL, 4UL, 5UL );
7289
7290 if( blaze::isSame( sm1, sm2 ) == false ) {
7291 std::ostringstream oss;
7292 oss << " Test: " << test_ << "\n"
7293 << " Error: Invalid isSame evaluation\n"
7294 << " Details:\n"
7295 << " First submatrix:\n" << sm1 << "\n"
7296 << " Second submatrix:\n" << sm2 << "\n";
7297 throw std::runtime_error( oss.str() );
7298 }
7299 }
7300
7301 // isSame with non-matching submatrices (different number of rows)
7302 {
7303 OSMT sm1 = blaze::submatrix( tmat_, 0UL, 0UL, 4UL, 5UL );
7304 OSMT sm2 = blaze::submatrix( tmat_, 0UL, 0UL, 3UL, 5UL );
7305
7306 if( blaze::isSame( sm1, sm2 ) == true ) {
7307 std::ostringstream oss;
7308 oss << " Test: " << test_ << "\n"
7309 << " Error: Invalid isSame evaluation\n"
7310 << " Details:\n"
7311 << " First submatrix:\n" << sm1 << "\n"
7312 << " Second submatrix:\n" << sm2 << "\n";
7313 throw std::runtime_error( oss.str() );
7314 }
7315 }
7316
7317 // isSame with non-matching submatrices (different number of columns)
7318 {
7319 OSMT sm1 = blaze::submatrix( tmat_, 0UL, 0UL, 4UL, 5UL );
7320 OSMT sm2 = blaze::submatrix( tmat_, 0UL, 0UL, 4UL, 4UL );
7321
7322 if( blaze::isSame( sm1, sm2 ) == true ) {
7323 std::ostringstream oss;
7324 oss << " Test: " << test_ << "\n"
7325 << " Error: Invalid isSame evaluation\n"
7326 << " Details:\n"
7327 << " First submatrix:\n" << sm1 << "\n"
7328 << " Second submatrix:\n" << sm2 << "\n";
7329 throw std::runtime_error( oss.str() );
7330 }
7331 }
7332
7333 // isSame with non-matching submatrices (different row index)
7334 {
7335 OSMT sm1 = blaze::submatrix( tmat_, 0UL, 0UL, 4UL, 5UL );
7336 OSMT sm2 = blaze::submatrix( tmat_, 1UL, 0UL, 3UL, 5UL );
7337
7338 if( blaze::isSame( sm1, sm2 ) == true ) {
7339 std::ostringstream oss;
7340 oss << " Test: " << test_ << "\n"
7341 << " Error: Invalid isSame evaluation\n"
7342 << " Details:\n"
7343 << " First submatrix:\n" << sm1 << "\n"
7344 << " Second submatrix:\n" << sm2 << "\n";
7345 throw std::runtime_error( oss.str() );
7346 }
7347 }
7348
7349 // isSame with non-matching submatrices (different column index)
7350 {
7351 OSMT sm1 = blaze::submatrix( tmat_, 0UL, 0UL, 4UL, 5UL );
7352 OSMT sm2 = blaze::submatrix( tmat_, 0UL, 1UL, 4UL, 4UL );
7353
7354 if( blaze::isSame( sm1, sm2 ) == true ) {
7355 std::ostringstream oss;
7356 oss << " Test: " << test_ << "\n"
7357 << " Error: Invalid isSame evaluation\n"
7358 << " Details:\n"
7359 << " First submatrix:\n" << sm1 << "\n"
7360 << " Second submatrix:\n" << sm2 << "\n";
7361 throw std::runtime_error( oss.str() );
7362 }
7363 }
7364 }
7365
7366
7367 //=====================================================================================
7368 // Column-major rows-based tests
7369 //=====================================================================================
7370
7371 {
7372 test_ = "Column-major isSame() function (rows-based)";
7373
7374 // isSame with row selection and matching submatrix
7375 {
7376 auto rs = blaze::rows( tmat_, { 0UL, 3UL, 2UL } );
7377 auto sm = blaze::submatrix( rs, 0UL, 0UL, 3UL, 5UL );
7378
7379 if( blaze::isSame( sm, rs ) == false ) {
7380 std::ostringstream oss;
7381 oss << " Test: " << test_ << "\n"
7382 << " Error: Invalid isSame evaluation\n"
7383 << " Details:\n"
7384 << " Row selection:\n" << rs << "\n"
7385 << " Submatrix:\n" << sm << "\n";
7386 throw std::runtime_error( oss.str() );
7387 }
7388
7389 if( blaze::isSame( rs, sm ) == false ) {
7390 std::ostringstream oss;
7391 oss << " Test: " << test_ << "\n"
7392 << " Error: Invalid isSame evaluation\n"
7393 << " Details:\n"
7394 << " Row selection:\n" << rs << "\n"
7395 << " Submatrix:\n" << sm << "\n";
7396 throw std::runtime_error( oss.str() );
7397 }
7398 }
7399
7400 // isSame with row selection and non-matching submatrix (different number of rows)
7401 {
7402 auto rs = blaze::rows( tmat_, { 0UL, 3UL, 2UL } );
7403 auto sm = blaze::submatrix( rs, 0UL, 0UL, 2UL, 5UL );
7404
7405 if( blaze::isSame( sm, rs ) == true ) {
7406 std::ostringstream oss;
7407 oss << " Test: " << test_ << "\n"
7408 << " Error: Invalid isSame evaluation\n"
7409 << " Details:\n"
7410 << " Row selection:\n" << rs << "\n"
7411 << " Submatrix:\n" << sm << "\n";
7412 throw std::runtime_error( oss.str() );
7413 }
7414
7415 if( blaze::isSame( rs, sm ) == true ) {
7416 std::ostringstream oss;
7417 oss << " Test: " << test_ << "\n"
7418 << " Error: Invalid isSame evaluation\n"
7419 << " Details:\n"
7420 << " Row selection:\n" << rs << "\n"
7421 << " Submatrix:\n" << sm << "\n";
7422 throw std::runtime_error( oss.str() );
7423 }
7424 }
7425
7426 // isSame with row selection and non-matching submatrix (different number of columns)
7427 {
7428 auto rs = blaze::rows( tmat_, { 0UL, 3UL, 2UL } );
7429 auto sm = blaze::submatrix( rs, 0UL, 0UL, 3UL, 4UL );
7430
7431 if( blaze::isSame( sm, rs ) == true ) {
7432 std::ostringstream oss;
7433 oss << " Test: " << test_ << "\n"
7434 << " Error: Invalid isSame evaluation\n"
7435 << " Details:\n"
7436 << " Row selection:\n" << rs << "\n"
7437 << " Submatrix:\n" << sm << "\n";
7438 throw std::runtime_error( oss.str() );
7439 }
7440
7441 if( blaze::isSame( rs, sm ) == true ) {
7442 std::ostringstream oss;
7443 oss << " Test: " << test_ << "\n"
7444 << " Error: Invalid isSame evaluation\n"
7445 << " Details:\n"
7446 << " Row selection:\n" << rs << "\n"
7447 << " Submatrix:\n" << sm << "\n";
7448 throw std::runtime_error( oss.str() );
7449 }
7450 }
7451
7452 // isSame with row selection and non-matching submatrix (different row index)
7453 {
7454 auto rs = blaze::rows( tmat_, { 0UL, 3UL, 2UL } );
7455 auto sm = blaze::submatrix( rs, 1UL, 0UL, 2UL, 5UL );
7456
7457 if( blaze::isSame( sm, rs ) == true ) {
7458 std::ostringstream oss;
7459 oss << " Test: " << test_ << "\n"
7460 << " Error: Invalid isSame evaluation\n"
7461 << " Details:\n"
7462 << " Row selection:\n" << rs << "\n"
7463 << " Submatrix:\n" << sm << "\n";
7464 throw std::runtime_error( oss.str() );
7465 }
7466
7467 if( blaze::isSame( rs, sm ) == true ) {
7468 std::ostringstream oss;
7469 oss << " Test: " << test_ << "\n"
7470 << " Error: Invalid isSame evaluation\n"
7471 << " Details:\n"
7472 << " Row selection:\n" << rs << "\n"
7473 << " Submatrix:\n" << sm << "\n";
7474 throw std::runtime_error( oss.str() );
7475 }
7476 }
7477
7478 // isSame with row selection and non-matching submatrix (different column index)
7479 {
7480 auto rs = blaze::rows( tmat_, { 0UL, 3UL, 2UL } );
7481 auto sm = blaze::submatrix( rs, 0UL, 1UL, 3UL, 4UL );
7482
7483 if( blaze::isSame( sm, rs ) == true ) {
7484 std::ostringstream oss;
7485 oss << " Test: " << test_ << "\n"
7486 << " Error: Invalid isSame evaluation\n"
7487 << " Details:\n"
7488 << " Row selection:\n" << rs << "\n"
7489 << " Submatrix:\n" << sm << "\n";
7490 throw std::runtime_error( oss.str() );
7491 }
7492
7493 if( blaze::isSame( rs, sm ) == true ) {
7494 std::ostringstream oss;
7495 oss << " Test: " << test_ << "\n"
7496 << " Error: Invalid isSame evaluation\n"
7497 << " Details:\n"
7498 << " Row selection:\n" << rs << "\n"
7499 << " Submatrix:\n" << sm << "\n";
7500 throw std::runtime_error( oss.str() );
7501 }
7502 }
7503
7504 // isSame with matching submatrices
7505 {
7506 auto rs = blaze::rows( tmat_, { 0UL, 3UL, 2UL } );
7507 auto sm1 = blaze::submatrix( rs, 0UL, 0UL, 2UL, 4UL );
7508 auto sm2 = blaze::submatrix( rs, 0UL, 0UL, 2UL, 4UL );
7509
7510 if( blaze::isSame( sm1, sm2 ) == false ) {
7511 std::ostringstream oss;
7512 oss << " Test: " << test_ << "\n"
7513 << " Error: Invalid isSame evaluation\n"
7514 << " Details:\n"
7515 << " First submatrix:\n" << sm1 << "\n"
7516 << " Second submatrix:\n" << sm2 << "\n";
7517 throw std::runtime_error( oss.str() );
7518 }
7519 }
7520
7521 // isSame with non-matching submatrices (different number of rows)
7522 {
7523 auto rs = blaze::rows( tmat_, { 0UL, 3UL, 2UL } );
7524 auto sm1 = blaze::submatrix( rs, 0UL, 0UL, 2UL, 4UL );
7525 auto sm2 = blaze::submatrix( rs, 0UL, 0UL, 1UL, 4UL );
7526
7527 if( blaze::isSame( sm1, sm2 ) == true ) {
7528 std::ostringstream oss;
7529 oss << " Test: " << test_ << "\n"
7530 << " Error: Invalid isSame evaluation\n"
7531 << " Details:\n"
7532 << " First submatrix:\n" << sm1 << "\n"
7533 << " Second submatrix:\n" << sm2 << "\n";
7534 throw std::runtime_error( oss.str() );
7535 }
7536 }
7537
7538 // isSame with non-matching submatrices (different number of columns)
7539 {
7540 auto rs = blaze::rows( tmat_, { 0UL, 3UL, 2UL } );
7541 auto sm1 = blaze::submatrix( rs, 0UL, 0UL, 2UL, 4UL );
7542 auto sm2 = blaze::submatrix( rs, 0UL, 0UL, 2UL, 3UL );
7543
7544 if( blaze::isSame( sm1, sm2 ) == true ) {
7545 std::ostringstream oss;
7546 oss << " Test: " << test_ << "\n"
7547 << " Error: Invalid isSame evaluation\n"
7548 << " Details:\n"
7549 << " First submatrix:\n" << sm1 << "\n"
7550 << " Second submatrix:\n" << sm2 << "\n";
7551 throw std::runtime_error( oss.str() );
7552 }
7553 }
7554
7555 // isSame with non-matching submatrices (different row index)
7556 {
7557 auto rs = blaze::rows( tmat_, { 0UL, 3UL, 2UL } );
7558 auto sm1 = blaze::submatrix( rs, 0UL, 0UL, 2UL, 4UL );
7559 auto sm2 = blaze::submatrix( rs, 1UL, 0UL, 2UL, 4UL );
7560
7561 if( blaze::isSame( sm1, sm2 ) == true ) {
7562 std::ostringstream oss;
7563 oss << " Test: " << test_ << "\n"
7564 << " Error: Invalid isSame evaluation\n"
7565 << " Details:\n"
7566 << " First submatrix:\n" << sm1 << "\n"
7567 << " Second submatrix:\n" << sm2 << "\n";
7568 throw std::runtime_error( oss.str() );
7569 }
7570 }
7571
7572 // isSame with non-matching submatrices (different column index)
7573 {
7574 auto rs = blaze::rows( tmat_, { 0UL, 3UL, 2UL } );
7575 auto sm1 = blaze::submatrix( rs, 0UL, 0UL, 2UL, 4UL );
7576 auto sm2 = blaze::submatrix( rs, 0UL, 1UL, 2UL, 4UL );
7577
7578 if( blaze::isSame( sm1, sm2 ) == true ) {
7579 std::ostringstream oss;
7580 oss << " Test: " << test_ << "\n"
7581 << " Error: Invalid isSame evaluation\n"
7582 << " Details:\n"
7583 << " First submatrix:\n" << sm1 << "\n"
7584 << " Second submatrix:\n" << sm2 << "\n";
7585 throw std::runtime_error( oss.str() );
7586 }
7587 }
7588 }
7589
7590
7591 //=====================================================================================
7592 // Column-major columns-based tests
7593 //=====================================================================================
7594
7595 {
7596 test_ = "Column-major isSame() function (columns-based)";
7597
7598 // isSame with column selection and matching submatrix
7599 {
7600 auto cs = blaze::columns( tmat_, { 0UL, 3UL, 2UL } );
7601 auto sm = blaze::submatrix( cs, 0UL, 0UL, 4UL, 3UL );
7602
7603 if( blaze::isSame( sm, cs ) == false ) {
7604 std::ostringstream oss;
7605 oss << " Test: " << test_ << "\n"
7606 << " Error: Invalid isSame evaluation\n"
7607 << " Details:\n"
7608 << " Column selection:\n" << cs << "\n"
7609 << " Submatrix:\n" << sm << "\n";
7610 throw std::runtime_error( oss.str() );
7611 }
7612
7613 if( blaze::isSame( cs, sm ) == false ) {
7614 std::ostringstream oss;
7615 oss << " Test: " << test_ << "\n"
7616 << " Error: Invalid isSame evaluation\n"
7617 << " Details:\n"
7618 << " Column selection:\n" << cs << "\n"
7619 << " Submatrix:\n" << sm << "\n";
7620 throw std::runtime_error( oss.str() );
7621 }
7622 }
7623
7624 // isSame with column selection and non-matching submatrix (different number of rows)
7625 {
7626 auto cs = blaze::columns( tmat_, { 0UL, 3UL, 2UL } );
7627 auto sm = blaze::submatrix( cs, 0UL, 0UL, 3UL, 3UL );
7628
7629 if( blaze::isSame( sm, cs ) == true ) {
7630 std::ostringstream oss;
7631 oss << " Test: " << test_ << "\n"
7632 << " Error: Invalid isSame evaluation\n"
7633 << " Details:\n"
7634 << " Column selection:\n" << cs << "\n"
7635 << " Submatrix:\n" << sm << "\n";
7636 throw std::runtime_error( oss.str() );
7637 }
7638
7639 if( blaze::isSame( cs, sm ) == true ) {
7640 std::ostringstream oss;
7641 oss << " Test: " << test_ << "\n"
7642 << " Error: Invalid isSame evaluation\n"
7643 << " Details:\n"
7644 << " Column selection:\n" << cs << "\n"
7645 << " Submatrix:\n" << sm << "\n";
7646 throw std::runtime_error( oss.str() );
7647 }
7648 }
7649
7650 // isSame with column selection and non-matching submatrix (different number of columns)
7651 {
7652 auto cs = blaze::columns( tmat_, { 0UL, 3UL, 2UL } );
7653 auto sm = blaze::submatrix( cs, 0UL, 0UL, 4UL, 2UL );
7654
7655 if( blaze::isSame( sm, cs ) == true ) {
7656 std::ostringstream oss;
7657 oss << " Test: " << test_ << "\n"
7658 << " Error: Invalid isSame evaluation\n"
7659 << " Details:\n"
7660 << " Column selection:\n" << cs << "\n"
7661 << " Submatrix:\n" << sm << "\n";
7662 throw std::runtime_error( oss.str() );
7663 }
7664
7665 if( blaze::isSame( cs, sm ) == true ) {
7666 std::ostringstream oss;
7667 oss << " Test: " << test_ << "\n"
7668 << " Error: Invalid isSame evaluation\n"
7669 << " Details:\n"
7670 << " Column selection:\n" << cs << "\n"
7671 << " Submatrix:\n" << sm << "\n";
7672 throw std::runtime_error( oss.str() );
7673 }
7674 }
7675
7676 // isSame with column selection and non-matching submatrix (different row index)
7677 {
7678 auto cs = blaze::columns( tmat_, { 0UL, 3UL, 2UL } );
7679 auto sm = blaze::submatrix( cs, 1UL, 0UL, 3UL, 3UL );
7680
7681 if( blaze::isSame( sm, cs ) == true ) {
7682 std::ostringstream oss;
7683 oss << " Test: " << test_ << "\n"
7684 << " Error: Invalid isSame evaluation\n"
7685 << " Details:\n"
7686 << " Column selection:\n" << cs << "\n"
7687 << " Submatrix:\n" << sm << "\n";
7688 throw std::runtime_error( oss.str() );
7689 }
7690
7691 if( blaze::isSame( cs, sm ) == true ) {
7692 std::ostringstream oss;
7693 oss << " Test: " << test_ << "\n"
7694 << " Error: Invalid isSame evaluation\n"
7695 << " Details:\n"
7696 << " Column selection:\n" << cs << "\n"
7697 << " Submatrix:\n" << sm << "\n";
7698 throw std::runtime_error( oss.str() );
7699 }
7700 }
7701
7702 // isSame with column selection and non-matching submatrix (different column index)
7703 {
7704 auto cs = blaze::columns( tmat_, { 0UL, 3UL, 2UL } );
7705 auto sm = blaze::submatrix( cs, 0UL, 1UL, 4UL, 2UL );
7706
7707 if( blaze::isSame( sm, cs ) == true ) {
7708 std::ostringstream oss;
7709 oss << " Test: " << test_ << "\n"
7710 << " Error: Invalid isSame evaluation\n"
7711 << " Details:\n"
7712 << " Column selection:\n" << cs << "\n"
7713 << " Submatrix:\n" << sm << "\n";
7714 throw std::runtime_error( oss.str() );
7715 }
7716
7717 if( blaze::isSame( cs, sm ) == true ) {
7718 std::ostringstream oss;
7719 oss << " Test: " << test_ << "\n"
7720 << " Error: Invalid isSame evaluation\n"
7721 << " Details:\n"
7722 << " Column selection:\n" << cs << "\n"
7723 << " Submatrix:\n" << sm << "\n";
7724 throw std::runtime_error( oss.str() );
7725 }
7726 }
7727
7728 // isSame with matching submatrices
7729 {
7730 auto cs = blaze::columns( tmat_, { 0UL, 3UL, 2UL } );
7731 auto sm1 = blaze::submatrix( cs, 0UL, 0UL, 3UL, 2UL );
7732 auto sm2 = blaze::submatrix( cs, 0UL, 0UL, 3UL, 2UL );
7733
7734 if( blaze::isSame( sm1, sm2 ) == false ) {
7735 std::ostringstream oss;
7736 oss << " Test: " << test_ << "\n"
7737 << " Error: Invalid isSame evaluation\n"
7738 << " Details:\n"
7739 << " First submatrix:\n" << sm1 << "\n"
7740 << " Second submatrix:\n" << sm2 << "\n";
7741 throw std::runtime_error( oss.str() );
7742 }
7743 }
7744
7745 // isSame with non-matching submatrices (different number of rows)
7746 {
7747 auto cs = blaze::columns( tmat_, { 0UL, 3UL, 2UL } );
7748 auto sm1 = blaze::submatrix( cs, 0UL, 0UL, 3UL, 2UL );
7749 auto sm2 = blaze::submatrix( cs, 0UL, 0UL, 2UL, 2UL );
7750
7751 if( blaze::isSame( sm1, sm2 ) == true ) {
7752 std::ostringstream oss;
7753 oss << " Test: " << test_ << "\n"
7754 << " Error: Invalid isSame evaluation\n"
7755 << " Details:\n"
7756 << " First submatrix:\n" << sm1 << "\n"
7757 << " Second submatrix:\n" << sm2 << "\n";
7758 throw std::runtime_error( oss.str() );
7759 }
7760 }
7761
7762 // isSame with non-matching submatrices (different number of columns)
7763 {
7764 auto cs = blaze::columns( tmat_, { 0UL, 3UL, 2UL } );
7765 auto sm1 = blaze::submatrix( cs, 0UL, 0UL, 3UL, 2UL );
7766 auto sm2 = blaze::submatrix( cs, 0UL, 0UL, 3UL, 1UL );
7767
7768 if( blaze::isSame( sm1, sm2 ) == true ) {
7769 std::ostringstream oss;
7770 oss << " Test: " << test_ << "\n"
7771 << " Error: Invalid isSame evaluation\n"
7772 << " Details:\n"
7773 << " First submatrix:\n" << sm1 << "\n"
7774 << " Second submatrix:\n" << sm2 << "\n";
7775 throw std::runtime_error( oss.str() );
7776 }
7777 }
7778
7779 // isSame with non-matching submatrices (different row index)
7780 {
7781 auto cs = blaze::columns( tmat_, { 0UL, 3UL, 2UL } );
7782 auto sm1 = blaze::submatrix( cs, 0UL, 0UL, 3UL, 2UL );
7783 auto sm2 = blaze::submatrix( cs, 1UL, 0UL, 3UL, 2UL );
7784
7785 if( blaze::isSame( sm1, sm2 ) == true ) {
7786 std::ostringstream oss;
7787 oss << " Test: " << test_ << "\n"
7788 << " Error: Invalid isSame evaluation\n"
7789 << " Details:\n"
7790 << " First submatrix:\n" << sm1 << "\n"
7791 << " Second submatrix:\n" << sm2 << "\n";
7792 throw std::runtime_error( oss.str() );
7793 }
7794 }
7795
7796 // isSame with non-matching submatrices (different column index)
7797 {
7798 auto cs = blaze::columns( tmat_, { 0UL, 3UL, 2UL } );
7799 auto sm1 = blaze::submatrix( cs, 0UL, 0UL, 3UL, 2UL );
7800 auto sm2 = blaze::submatrix( cs, 0UL, 1UL, 3UL, 2UL );
7801
7802 if( blaze::isSame( sm1, sm2 ) == true ) {
7803 std::ostringstream oss;
7804 oss << " Test: " << test_ << "\n"
7805 << " Error: Invalid isSame evaluation\n"
7806 << " Details:\n"
7807 << " First submatrix:\n" << sm1 << "\n"
7808 << " Second submatrix:\n" << sm2 << "\n";
7809 throw std::runtime_error( oss.str() );
7810 }
7811 }
7812 }
7813 }
7814 //*************************************************************************************************
7815
7816
7817 //*************************************************************************************************
7818 /*!\brief Test of the \c blaze::submatrix() function with the Submatrix class template.
7819 //
7820 // \return void
7821 // \exception std::runtime_error Error detected.
7822 //
7823 // This function performs a test of the \c blaze::submatrix() function with the Submatrix
7824 // specialization. In case an error is detected, a \a std::runtime_error exception is thrown.
7825 */
testSubmatrix()7826 void SparseTest::testSubmatrix()
7827 {
7828 //=====================================================================================
7829 // Row-major matrix tests
7830 //=====================================================================================
7831
7832 {
7833 test_ = "Row-major blaze::submatrix() function";
7834
7835 initialize();
7836
7837 {
7838 SMT sm1 = blaze::submatrix( mat_, 1UL, 1UL, 4UL, 3UL );
7839 SMT sm2 = blaze::submatrix( sm1 , 1UL, 1UL, 3UL, 2UL );
7840
7841 if( sm2(0,0) != -3 || sm2(0,1) != 0 ||
7842 sm2(1,0) != 5 || sm2(1,1) != -6 ||
7843 sm2(2,0) != 9 || sm2(2,1) != 10 ) {
7844 std::ostringstream oss;
7845 oss << " Test: " << test_ << "\n"
7846 << " Error: Function call operator access failed\n"
7847 << " Details:\n"
7848 << " Result:\n" << sm2 << "\n"
7849 << " Expected result:\n( -3 0 )\n( 5 -6 )\n( 9 10 )\n";
7850 throw std::runtime_error( oss.str() );
7851 }
7852
7853 if( sm2.begin(1UL)->value() != 5 ) {
7854 std::ostringstream oss;
7855 oss << " Test: " << test_ << "\n"
7856 << " Error: Iterator access failed\n"
7857 << " Details:\n"
7858 << " Result: " << sm2.begin(1UL)->value() << "\n"
7859 << " Expected result: 5\n";
7860 throw std::runtime_error( oss.str() );
7861 }
7862 }
7863
7864 try {
7865 SMT sm1 = blaze::submatrix( mat_, 1UL, 1UL, 4UL, 3UL );
7866 SMT sm2 = blaze::submatrix( sm1 , 4UL, 1UL, 3UL, 2UL );
7867
7868 std::ostringstream oss;
7869 oss << " Test: " << test_ << "\n"
7870 << " Error: Setup of out-of-bounds submatrix succeeded\n"
7871 << " Details:\n"
7872 << " Result:\n" << sm2 << "\n";
7873 throw std::runtime_error( oss.str() );
7874 }
7875 catch( std::invalid_argument& ) {}
7876
7877 try {
7878 SMT sm1 = blaze::submatrix( mat_, 1UL, 1UL, 4UL, 3UL );
7879 SMT sm2 = blaze::submatrix( sm1 , 1UL, 3UL, 3UL, 2UL );
7880
7881 std::ostringstream oss;
7882 oss << " Test: " << test_ << "\n"
7883 << " Error: Setup of out-of-bounds submatrix succeeded\n"
7884 << " Details:\n"
7885 << " Result:\n" << sm2 << "\n";
7886 throw std::runtime_error( oss.str() );
7887 }
7888 catch( std::invalid_argument& ) {}
7889
7890 try {
7891 SMT sm1 = blaze::submatrix( mat_, 1UL, 1UL, 4UL, 3UL );
7892 SMT sm2 = blaze::submatrix( sm1 , 1UL, 1UL, 4UL, 2UL );
7893
7894 std::ostringstream oss;
7895 oss << " Test: " << test_ << "\n"
7896 << " Error: Setup of out-of-bounds submatrix succeeded\n"
7897 << " Details:\n"
7898 << " Result:\n" << sm2 << "\n";
7899 throw std::runtime_error( oss.str() );
7900 }
7901 catch( std::invalid_argument& ) {}
7902
7903 try {
7904 SMT sm1 = blaze::submatrix( mat_, 1UL, 1UL, 4UL, 3UL );
7905 SMT sm2 = blaze::submatrix( sm1 , 1UL, 1UL, 3UL, 3UL );
7906
7907 std::ostringstream oss;
7908 oss << " Test: " << test_ << "\n"
7909 << " Error: Setup of out-of-bounds submatrix succeeded\n"
7910 << " Details:\n"
7911 << " Result:\n" << sm2 << "\n";
7912 throw std::runtime_error( oss.str() );
7913 }
7914 catch( std::invalid_argument& ) {}
7915 }
7916
7917
7918 //=====================================================================================
7919 // Column-major matrix tests
7920 //=====================================================================================
7921
7922 {
7923 test_ = "Column-major blaze::submatrix() function";
7924
7925 initialize();
7926
7927 {
7928 OSMT sm1 = blaze::submatrix( tmat_, 1UL, 1UL, 3UL, 4UL );
7929 OSMT sm2 = blaze::submatrix( sm1 , 1UL, 1UL, 2UL, 3UL );
7930
7931 if( sm2(0,0) != -3 || sm2(0,1) != 5 || sm2(0,2) != 9 ||
7932 sm2(1,0) != 0 || sm2(1,1) != -6 || sm2(1,2) != 10 ) {
7933 std::ostringstream oss;
7934 oss << " Test: " << test_ << "\n"
7935 << " Error: Function call operator access failed\n"
7936 << " Details:\n"
7937 << " Result:\n" << sm2 << "\n"
7938 << " Expected result:\n( -3 5 9 )\n( 0 -6 10 )\n";
7939 throw std::runtime_error( oss.str() );
7940 }
7941
7942 if( sm2.begin(1UL)->value() != 5 ) {
7943 std::ostringstream oss;
7944 oss << " Test: " << test_ << "\n"
7945 << " Error: Iterator access failed\n"
7946 << " Details:\n"
7947 << " Result: " << sm2.begin(1UL)->value() << "\n"
7948 << " Expected result: 5\n";
7949 throw std::runtime_error( oss.str() );
7950 }
7951 }
7952
7953 try {
7954 OSMT sm1 = blaze::submatrix( tmat_, 1UL, 1UL, 3UL, 4UL );
7955 OSMT sm2 = blaze::submatrix( sm1 , 3UL, 1UL, 2UL, 3UL );
7956
7957 std::ostringstream oss;
7958 oss << " Test: " << test_ << "\n"
7959 << " Error: Setup of out-of-bounds submatrix succeeded\n"
7960 << " Details:\n"
7961 << " Result:\n" << sm2 << "\n";
7962 throw std::runtime_error( oss.str() );
7963 }
7964 catch( std::invalid_argument& ) {}
7965
7966 try {
7967 OSMT sm1 = blaze::submatrix( tmat_, 1UL, 1UL, 3UL, 4UL );
7968 OSMT sm2 = blaze::submatrix( sm1 , 1UL, 4UL, 2UL, 3UL );
7969
7970 std::ostringstream oss;
7971 oss << " Test: " << test_ << "\n"
7972 << " Error: Setup of out-of-bounds submatrix succeeded\n"
7973 << " Details:\n"
7974 << " Result:\n" << sm2 << "\n";
7975 throw std::runtime_error( oss.str() );
7976 }
7977 catch( std::invalid_argument& ) {}
7978
7979 try {
7980 OSMT sm1 = blaze::submatrix( tmat_, 1UL, 1UL, 3UL, 4UL );
7981 OSMT sm2 = blaze::submatrix( sm1 , 1UL, 1UL, 3UL, 3UL );
7982
7983 std::ostringstream oss;
7984 oss << " Test: " << test_ << "\n"
7985 << " Error: Setup of out-of-bounds submatrix succeeded\n"
7986 << " Details:\n"
7987 << " Result:\n" << sm2 << "\n";
7988 throw std::runtime_error( oss.str() );
7989 }
7990 catch( std::invalid_argument& ) {}
7991
7992 try {
7993 OSMT sm1 = blaze::submatrix( tmat_, 1UL, 1UL, 3UL, 4UL );
7994 OSMT sm2 = blaze::submatrix( sm1 , 1UL, 1UL, 2UL, 4UL );
7995
7996 std::ostringstream oss;
7997 oss << " Test: " << test_ << "\n"
7998 << " Error: Setup of out-of-bounds submatrix succeeded\n"
7999 << " Details:\n"
8000 << " Result:\n" << sm2 << "\n";
8001 throw std::runtime_error( oss.str() );
8002 }
8003 catch( std::invalid_argument& ) {}
8004 }
8005 }
8006 //*************************************************************************************************
8007
8008
8009 //*************************************************************************************************
8010 /*!\brief Test of the \c row() function with the Submatrix class template.
8011 //
8012 // \return void
8013 // \exception std::runtime_error Error detected.
8014 //
8015 // This function performs a test of the \c row() function with the Submatrix specialization.
8016 // In case an error is detected, a \a std::runtime_error exception is thrown.
8017 */
testRow()8018 void SparseTest::testRow()
8019 {
8020 //=====================================================================================
8021 // Row-major matrix tests
8022 //=====================================================================================
8023
8024 {
8025 test_ = "Row-major row() function";
8026
8027 initialize();
8028
8029 {
8030 SMT sm1 = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 2UL );
8031 auto row1 = blaze::row( sm1, 1UL );
8032
8033 if( row1[0] != 0 || row1[1] != -3 ) {
8034 std::ostringstream oss;
8035 oss << " Test: " << test_ << "\n"
8036 << " Error: Subscript operator access failed\n"
8037 << " Details:\n"
8038 << " Result:\n" << row1 << "\n"
8039 << " Expected result:\n( 0 -3 )\n";
8040 throw std::runtime_error( oss.str() );
8041 }
8042
8043 if( row1.begin()->value() != -3 ) {
8044 std::ostringstream oss;
8045 oss << " Test: " << test_ << "\n"
8046 << " Error: Iterator access failed\n"
8047 << " Details:\n"
8048 << " Result: " << row1.begin()->value() << "\n"
8049 << " Expected result: -3\n";
8050 throw std::runtime_error( oss.str() );
8051 }
8052 }
8053
8054 try {
8055 SMT sm1 = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 2UL );
8056 auto row3 = blaze::row( sm1, 3UL );
8057
8058 std::ostringstream oss;
8059 oss << " Test: " << test_ << "\n"
8060 << " Error: Setup of out-of-bounds row succeeded\n"
8061 << " Details:\n"
8062 << " Result:\n" << row3 << "\n";
8063 throw std::runtime_error( oss.str() );
8064 }
8065 catch( std::invalid_argument& ) {}
8066 }
8067
8068
8069 //=====================================================================================
8070 // Column-major matrix tests
8071 //=====================================================================================
8072
8073 {
8074 test_ = "Column-major row() function";
8075
8076 initialize();
8077
8078 {
8079 OSMT sm1 = blaze::submatrix( tmat_, 1UL, 1UL, 2UL, 3UL );
8080 auto row1 = blaze::row( sm1, 1UL );
8081
8082 if( row1[0] != 0 || row1[1] != -3 || row1[2] != 5 ) {
8083 std::ostringstream oss;
8084 oss << " Test: " << test_ << "\n"
8085 << " Error: Subscript operator access failed\n"
8086 << " Details:\n"
8087 << " Result:\n" << row1 << "\n"
8088 << " Expected result:\n( 0 -3 5 )\n";
8089 throw std::runtime_error( oss.str() );
8090 }
8091
8092 if( row1.begin()->value() != -3 ) {
8093 std::ostringstream oss;
8094 oss << " Test: " << test_ << "\n"
8095 << " Error: Iterator access failed\n"
8096 << " Details:\n"
8097 << " Result: " << row1.begin()->value() << "\n"
8098 << " Expected result: -3\n";
8099 throw std::runtime_error( oss.str() );
8100 }
8101 }
8102
8103 try {
8104 OSMT sm1 = blaze::submatrix( tmat_, 1UL, 1UL, 2UL, 3UL );
8105 auto row2 = blaze::row( sm1, 2UL );
8106
8107 std::ostringstream oss;
8108 oss << " Test: " << test_ << "\n"
8109 << " Error: Setup of out-of-bounds row succeeded\n"
8110 << " Details:\n"
8111 << " Result:\n" << row2 << "\n";
8112 throw std::runtime_error( oss.str() );
8113 }
8114 catch( std::invalid_argument& ) {}
8115 }
8116 }
8117 //*************************************************************************************************
8118
8119
8120 //*************************************************************************************************
8121 /*!\brief Test of the \c rows() function with the Submatrix class template.
8122 //
8123 // \return void
8124 // \exception std::runtime_error Error detected.
8125 //
8126 // This function performs a test of the \c rows() function with the Submatrix specialization.
8127 // In case an error is detected, a \a std::runtime_error exception is thrown.
8128 */
testRows()8129 void SparseTest::testRows()
8130 {
8131 //=====================================================================================
8132 // Row-major matrix tests (initializer_list)
8133 //=====================================================================================
8134
8135 {
8136 test_ = "Row-major rows() function (initializer_list)";
8137
8138 initialize();
8139
8140 {
8141 SMT sm1 = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 2UL );
8142 auto rs = blaze::rows( sm1, { 1UL, 0UL } );
8143
8144 if( rs(0,0) != 0 || rs(0,1) != -3 ||
8145 rs(1,0) != 1 || rs(1,1) != 0 ) {
8146 std::ostringstream oss;
8147 oss << " Test: " << test_ << "\n"
8148 << " Error: Function call operator access failed\n"
8149 << " Details:\n"
8150 << " Result:\n" << rs << "\n"
8151 << " Expected result:\n( 0 -3 )\n( 1 0 )\n";
8152 throw std::runtime_error( oss.str() );
8153 }
8154
8155 if( rs.begin( 1UL )->value() != 1 ) {
8156 std::ostringstream oss;
8157 oss << " Test: " << test_ << "\n"
8158 << " Error: Iterator access failed\n"
8159 << " Details:\n"
8160 << " Result: " << rs.begin( 1UL )->value() << "\n"
8161 << " Expected result: 1\n";
8162 throw std::runtime_error( oss.str() );
8163 }
8164 }
8165
8166 try {
8167 SMT sm1 = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 2UL );
8168 auto rs = blaze::rows( sm1, { 3UL } );
8169
8170 std::ostringstream oss;
8171 oss << " Test: " << test_ << "\n"
8172 << " Error: Setup of out-of-bounds row selection succeeded\n"
8173 << " Details:\n"
8174 << " Result:\n" << rs << "\n";
8175 throw std::runtime_error( oss.str() );
8176 }
8177 catch( std::invalid_argument& ) {}
8178 }
8179
8180
8181 //=====================================================================================
8182 // Row-major matrix tests (std::array)
8183 //=====================================================================================
8184
8185 {
8186 test_ = "Row-major rows() function (std::array)";
8187
8188 initialize();
8189
8190 {
8191 std::array<int,2UL> indices{ 1UL, 0UL };
8192
8193 SMT sm1 = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 2UL );
8194 auto rs = blaze::rows( sm1, indices );
8195
8196 if( rs(0,0) != 0 || rs(0,1) != -3 ||
8197 rs(1,0) != 1 || rs(1,1) != 0 ) {
8198 std::ostringstream oss;
8199 oss << " Test: " << test_ << "\n"
8200 << " Error: Function call operator access failed\n"
8201 << " Details:\n"
8202 << " Result:\n" << rs << "\n"
8203 << " Expected result:\n( 0 -3 )\n( 1 0 )\n";
8204 throw std::runtime_error( oss.str() );
8205 }
8206
8207 if( rs.begin( 1UL )->value() != 1 ) {
8208 std::ostringstream oss;
8209 oss << " Test: " << test_ << "\n"
8210 << " Error: Iterator access failed\n"
8211 << " Details:\n"
8212 << " Result: " << rs.begin( 1UL )->value() << "\n"
8213 << " Expected result: 1\n";
8214 throw std::runtime_error( oss.str() );
8215 }
8216 }
8217
8218 try {
8219 std::array<int,1UL> indices{ 3UL };
8220
8221 SMT sm1 = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 2UL );
8222 auto rs = blaze::rows( sm1, indices );
8223
8224 std::ostringstream oss;
8225 oss << " Test: " << test_ << "\n"
8226 << " Error: Setup of out-of-bounds row selection succeeded\n"
8227 << " Details:\n"
8228 << " Result:\n" << rs << "\n";
8229 throw std::runtime_error( oss.str() );
8230 }
8231 catch( std::invalid_argument& ) {}
8232 }
8233
8234
8235 //=====================================================================================
8236 // Row-major matrix tests (lambda expression)
8237 //=====================================================================================
8238
8239 {
8240 test_ = "Row-major rows() function (lambda expression)";
8241
8242 initialize();
8243
8244 {
8245 SMT sm1 = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 2UL );
8246 auto rs = blaze::rows( sm1, []( size_t i ){ return 1UL-i; }, 2UL );
8247
8248 if( rs(0,0) != 0 || rs(0,1) != -3 ||
8249 rs(1,0) != 1 || rs(1,1) != 0 ) {
8250 std::ostringstream oss;
8251 oss << " Test: " << test_ << "\n"
8252 << " Error: Function call operator access failed\n"
8253 << " Details:\n"
8254 << " Result:\n" << rs << "\n"
8255 << " Expected result:\n( 0 -3 )\n( 1 0 )\n";
8256 throw std::runtime_error( oss.str() );
8257 }
8258
8259 if( rs.begin( 1UL )->value() != 1 ) {
8260 std::ostringstream oss;
8261 oss << " Test: " << test_ << "\n"
8262 << " Error: Iterator access failed\n"
8263 << " Details:\n"
8264 << " Result: " << rs.begin( 1UL )->value() << "\n"
8265 << " Expected result: 1\n";
8266 throw std::runtime_error( oss.str() );
8267 }
8268 }
8269
8270 try {
8271 SMT sm1 = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 2UL );
8272 auto rs = blaze::rows( sm1, []( size_t ){ return 3UL; }, 1UL );
8273
8274 std::ostringstream oss;
8275 oss << " Test: " << test_ << "\n"
8276 << " Error: Setup of out-of-bounds row selection succeeded\n"
8277 << " Details:\n"
8278 << " Result:\n" << rs << "\n";
8279 throw std::runtime_error( oss.str() );
8280 }
8281 catch( std::invalid_argument& ) {}
8282 }
8283
8284
8285 //=====================================================================================
8286 // Column-major matrix tests (initializer_list)
8287 //=====================================================================================
8288
8289 {
8290 test_ = "Column-major rows() function (initializer_list)";
8291
8292 initialize();
8293
8294 {
8295 OSMT sm1 = blaze::submatrix( tmat_, 1UL, 1UL, 2UL, 3UL );
8296 auto rs = blaze::rows( sm1, { 1UL, 0UL } );
8297
8298 if( rs(0,0) != 0 || rs(0,1) != -3 || rs(0,2) != 5 ||
8299 rs(1,0) != 1 || rs(1,1) != 0 || rs(1,2) != 4 ) {
8300 std::ostringstream oss;
8301 oss << " Test: " << test_ << "\n"
8302 << " Error: Function call operator access failed\n"
8303 << " Details:\n"
8304 << " Result:\n" << rs << "\n"
8305 << " Expected result:\n( 0 -3 5 )\n( 1 0 4 )\n";
8306 throw std::runtime_error( oss.str() );
8307 }
8308
8309 if( rs.begin( 1UL )->value() != 1 ) {
8310 std::ostringstream oss;
8311 oss << " Test: " << test_ << "\n"
8312 << " Error: Iterator access failed\n"
8313 << " Details:\n"
8314 << " Result: " << rs.begin( 1UL )->value() << "\n"
8315 << " Expected result: 1\n";
8316 throw std::runtime_error( oss.str() );
8317 }
8318 }
8319
8320 try {
8321 OSMT sm1 = blaze::submatrix( tmat_, 1UL, 1UL, 2UL, 3UL );
8322 auto rs = blaze::rows( sm1, { 2UL } );
8323
8324 std::ostringstream oss;
8325 oss << " Test: " << test_ << "\n"
8326 << " Error: Setup of out-of-bounds row selection succeeded\n"
8327 << " Details:\n"
8328 << " Result:\n" << rs << "\n";
8329 throw std::runtime_error( oss.str() );
8330 }
8331 catch( std::invalid_argument& ) {}
8332 }
8333
8334
8335 //=====================================================================================
8336 // Colummn-major matrix tests (std::array)
8337 //=====================================================================================
8338
8339 {
8340 test_ = "Column-major rows() function (std::array)";
8341
8342 initialize();
8343
8344 {
8345 std::array<int,2UL> indices{ 1UL, 0UL };
8346
8347 OSMT sm1 = blaze::submatrix( tmat_, 1UL, 1UL, 2UL, 3UL );
8348 auto rs = blaze::rows( sm1, indices );
8349
8350 if( rs(0,0) != 0 || rs(0,1) != -3 || rs(0,2) != 5 ||
8351 rs(1,0) != 1 || rs(1,1) != 0 || rs(1,2) != 4 ) {
8352 std::ostringstream oss;
8353 oss << " Test: " << test_ << "\n"
8354 << " Error: Function call operator access failed\n"
8355 << " Details:\n"
8356 << " Result:\n" << rs << "\n"
8357 << " Expected result:\n( 0 -3 5 )\n( 1 0 4 )\n";
8358 throw std::runtime_error( oss.str() );
8359 }
8360
8361 if( rs.begin( 1UL )->value() != 1 ) {
8362 std::ostringstream oss;
8363 oss << " Test: " << test_ << "\n"
8364 << " Error: Iterator access failed\n"
8365 << " Details:\n"
8366 << " Result: " << rs.begin( 1UL )->value() << "\n"
8367 << " Expected result: 1\n";
8368 throw std::runtime_error( oss.str() );
8369 }
8370 }
8371
8372 try {
8373 std::array<int,2UL> indices{ 2UL };
8374
8375 OSMT sm1 = blaze::submatrix( tmat_, 1UL, 1UL, 2UL, 3UL );
8376 auto rs = blaze::rows( sm1, indices );
8377
8378 std::ostringstream oss;
8379 oss << " Test: " << test_ << "\n"
8380 << " Error: Setup of out-of-bounds row selection succeeded\n"
8381 << " Details:\n"
8382 << " Result:\n" << rs << "\n";
8383 throw std::runtime_error( oss.str() );
8384 }
8385 catch( std::invalid_argument& ) {}
8386 }
8387
8388
8389 //=====================================================================================
8390 // Column-major matrix tests (lambda expression)
8391 //=====================================================================================
8392
8393 {
8394 test_ = "Column-major rows() function (lambda expression)";
8395
8396 initialize();
8397
8398 {
8399 OSMT sm1 = blaze::submatrix( tmat_, 1UL, 1UL, 2UL, 3UL );
8400 auto rs = blaze::rows( sm1, []( size_t i ){ return 1UL-i; }, 2UL );
8401
8402 if( rs(0,0) != 0 || rs(0,1) != -3 || rs(0,2) != 5 ||
8403 rs(1,0) != 1 || rs(1,1) != 0 || rs(1,2) != 4 ) {
8404 std::ostringstream oss;
8405 oss << " Test: " << test_ << "\n"
8406 << " Error: Function call operator access failed\n"
8407 << " Details:\n"
8408 << " Result:\n" << rs << "\n"
8409 << " Expected result:\n( 0 -3 5 )\n( 1 0 4 )\n";
8410 throw std::runtime_error( oss.str() );
8411 }
8412
8413 if( rs.begin( 1UL )->value() != 1 ) {
8414 std::ostringstream oss;
8415 oss << " Test: " << test_ << "\n"
8416 << " Error: Iterator access failed\n"
8417 << " Details:\n"
8418 << " Result: " << rs.begin( 1UL )->value() << "\n"
8419 << " Expected result: 1\n";
8420 throw std::runtime_error( oss.str() );
8421 }
8422 }
8423
8424 try {
8425 OSMT sm1 = blaze::submatrix( tmat_, 1UL, 1UL, 2UL, 3UL );
8426 auto rs = blaze::rows( sm1, []( size_t ){ return 2UL; }, 1UL );
8427
8428 std::ostringstream oss;
8429 oss << " Test: " << test_ << "\n"
8430 << " Error: Setup of out-of-bounds row selection succeeded\n"
8431 << " Details:\n"
8432 << " Result:\n" << rs << "\n";
8433 throw std::runtime_error( oss.str() );
8434 }
8435 catch( std::invalid_argument& ) {}
8436 }
8437 }
8438 //*************************************************************************************************
8439
8440
8441 //*************************************************************************************************
8442 /*!\brief Test of the \c column() function with the Submatrix class template.
8443 //
8444 // \return void
8445 // \exception std::runtime_error Error detected.
8446 //
8447 // This function performs a test of the \c column() function with the Submatrix specialization.
8448 // In case an error is detected, a \a std::runtime_error exception is thrown.
8449 */
testColumn()8450 void SparseTest::testColumn()
8451 {
8452 //=====================================================================================
8453 // Row-major matrix tests
8454 //=====================================================================================
8455
8456 {
8457 test_ = "Row-major column() function";
8458
8459 initialize();
8460
8461 {
8462 SMT sm1 = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 2UL );
8463 auto col1 = blaze::column( sm1, 1UL );
8464
8465 if( col1[0] != 0 || col1[1] != -3 || col1[2] != 5 ) {
8466 std::ostringstream oss;
8467 oss << " Test: " << test_ << "\n"
8468 << " Error: Subscript operator access failed\n"
8469 << " Details:\n"
8470 << " Result:\n" << col1 << "\n"
8471 << " Expected result:\n( 0 -3 5 )\n";
8472 throw std::runtime_error( oss.str() );
8473 }
8474
8475 if( col1.begin()->value() != -3 ) {
8476 std::ostringstream oss;
8477 oss << " Test: " << test_ << "\n"
8478 << " Error: Iterator access failed\n"
8479 << " Details:\n"
8480 << " Result: " << col1.begin()->value() << "\n"
8481 << " Expected result: -3\n";
8482 throw std::runtime_error( oss.str() );
8483 }
8484 }
8485
8486 try {
8487 SMT sm1 = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 2UL );
8488 auto col2 = blaze::column( sm1, 2UL );
8489
8490 std::ostringstream oss;
8491 oss << " Test: " << test_ << "\n"
8492 << " Error: Setup of out-of-bounds column succeeded\n"
8493 << " Details:\n"
8494 << " Result:\n" << col2 << "\n";
8495 throw std::runtime_error( oss.str() );
8496 }
8497 catch( std::invalid_argument& ) {}
8498 }
8499
8500
8501 //=====================================================================================
8502 // Column-major matrix tests
8503 //=====================================================================================
8504
8505 {
8506 test_ = "Column-major column() function";
8507
8508 initialize();
8509
8510 {
8511 OSMT sm1 = blaze::submatrix( tmat_, 1UL, 1UL, 2UL, 3UL );
8512 auto col1 = blaze::column( sm1, 1UL );
8513
8514 if( col1[0] != 0 || col1[1] != -3 ) {
8515 std::ostringstream oss;
8516 oss << " Test: " << test_ << "\n"
8517 << " Error: Subscript operator access failed\n"
8518 << " Details:\n"
8519 << " Result:\n" << col1 << "\n"
8520 << " Expected result:\n( 0 -3 )\n";
8521 throw std::runtime_error( oss.str() );
8522 }
8523
8524 if( col1.begin()->value() != -3 ) {
8525 std::ostringstream oss;
8526 oss << " Test: " << test_ << "\n"
8527 << " Error: Iterator access failed\n"
8528 << " Details:\n"
8529 << " Result: " << col1.begin()->value() << "\n"
8530 << " Expected result: -3\n";
8531 throw std::runtime_error( oss.str() );
8532 }
8533 }
8534
8535 try {
8536 OSMT sm1 = blaze::submatrix( tmat_, 1UL, 1UL, 2UL, 3UL );
8537 auto col3 = blaze::column( sm1, 3UL );
8538
8539 std::ostringstream oss;
8540 oss << " Test: " << test_ << "\n"
8541 << " Error: Setup of out-of-bounds column succeeded\n"
8542 << " Details:\n"
8543 << " Result:\n" << col3 << "\n";
8544 throw std::runtime_error( oss.str() );
8545 }
8546 catch( std::invalid_argument& ) {}
8547 }
8548 }
8549 //*************************************************************************************************
8550
8551
8552 //*************************************************************************************************
8553 /*!\brief Test of the \c columns() function with the Submatrix class template.
8554 //
8555 // \return void
8556 // \exception std::runtime_error Error detected.
8557 //
8558 // This function performs a test of the \c columns() function with the Submatrix specialization.
8559 // In case an error is detected, a \a std::runtime_error exception is thrown.
8560 */
testColumns()8561 void SparseTest::testColumns()
8562 {
8563 //=====================================================================================
8564 // Row-major matrix tests (initializer_list)
8565 //=====================================================================================
8566
8567 {
8568 test_ = "Row-major columns() function (initializer_list)";
8569
8570 initialize();
8571
8572 {
8573 SMT sm1 = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 2UL );
8574 auto cs = blaze::columns( sm1, { 1UL, 0UL } );
8575
8576 if( cs(0,0) != 0 || cs(0,1) != 1 ||
8577 cs(1,0) != -3 || cs(1,1) != 0 ||
8578 cs(2,0) != 5 || cs(2,1) != 4 ) {
8579 std::ostringstream oss;
8580 oss << " Test: " << test_ << "\n"
8581 << " Error: Function call operator access failed\n"
8582 << " Details:\n"
8583 << " Result:\n" << cs << "\n"
8584 << " Expected result:\n( 0 1 )\n( -3 0 )\n( 5 4 )\n";
8585 throw std::runtime_error( oss.str() );
8586 }
8587
8588 if( cs.begin( 1UL )->value() != 1 ) {
8589 std::ostringstream oss;
8590 oss << " Test: " << test_ << "\n"
8591 << " Error: Iterator access failed\n"
8592 << " Details:\n"
8593 << " Result: " << cs.begin( 1UL )->value() << "\n"
8594 << " Expected result: 1\n";
8595 throw std::runtime_error( oss.str() );
8596 }
8597 }
8598
8599 try {
8600 SMT sm1 = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 2UL );
8601 auto cs = blaze::columns( sm1, { 2UL } );
8602
8603 std::ostringstream oss;
8604 oss << " Test: " << test_ << "\n"
8605 << " Error: Setup of out-of-bounds column selection succeeded\n"
8606 << " Details:\n"
8607 << " Result:\n" << cs << "\n";
8608 throw std::runtime_error( oss.str() );
8609 }
8610 catch( std::invalid_argument& ) {}
8611 }
8612
8613
8614 //=====================================================================================
8615 // Row-major matrix tests (std::array)
8616 //=====================================================================================
8617
8618 {
8619 test_ = "Row-major columns() function (std::array)";
8620
8621 initialize();
8622
8623 {
8624 std::array<int,2UL> indices{ 1UL, 0UL };
8625
8626 SMT sm1 = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 2UL );
8627 auto cs = blaze::columns( sm1, indices );
8628
8629 if( cs(0,0) != 0 || cs(0,1) != 1 ||
8630 cs(1,0) != -3 || cs(1,1) != 0 ||
8631 cs(2,0) != 5 || cs(2,1) != 4 ) {
8632 std::ostringstream oss;
8633 oss << " Test: " << test_ << "\n"
8634 << " Error: Function call operator access failed\n"
8635 << " Details:\n"
8636 << " Result:\n" << cs << "\n"
8637 << " Expected result:\n( 0 1 )\n( -3 0 )\n( 5 4 )\n";
8638 throw std::runtime_error( oss.str() );
8639 }
8640
8641 if( cs.begin( 1UL )->value() != 1 ) {
8642 std::ostringstream oss;
8643 oss << " Test: " << test_ << "\n"
8644 << " Error: Iterator access failed\n"
8645 << " Details:\n"
8646 << " Result: " << cs.begin( 1UL )->value() << "\n"
8647 << " Expected result: 1\n";
8648 throw std::runtime_error( oss.str() );
8649 }
8650 }
8651
8652 try {
8653 std::array<int,1UL> indices{ 2UL };
8654
8655 SMT sm1 = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 2UL );
8656 auto cs = blaze::columns( sm1, indices );
8657
8658 std::ostringstream oss;
8659 oss << " Test: " << test_ << "\n"
8660 << " Error: Setup of out-of-bounds column selection succeeded\n"
8661 << " Details:\n"
8662 << " Result:\n" << cs << "\n";
8663 throw std::runtime_error( oss.str() );
8664 }
8665 catch( std::invalid_argument& ) {}
8666 }
8667
8668
8669 //=====================================================================================
8670 // Row-major matrix tests (lambda expression)
8671 //=====================================================================================
8672
8673 {
8674 test_ = "Row-major columns() function (lambda expression)";
8675
8676 initialize();
8677
8678 {
8679 SMT sm1 = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 2UL );
8680 auto cs = blaze::columns( sm1, []( size_t i ){ return 1UL-i; }, 2UL );
8681
8682 if( cs(0,0) != 0 || cs(0,1) != 1 ||
8683 cs(1,0) != -3 || cs(1,1) != 0 ||
8684 cs(2,0) != 5 || cs(2,1) != 4 ) {
8685 std::ostringstream oss;
8686 oss << " Test: " << test_ << "\n"
8687 << " Error: Function call operator access failed\n"
8688 << " Details:\n"
8689 << " Result:\n" << cs << "\n"
8690 << " Expected result:\n( 0 1 )\n( -3 0 )\n( 5 4 )\n";
8691 throw std::runtime_error( oss.str() );
8692 }
8693
8694 if( cs.begin( 1UL )->value() != 1 ) {
8695 std::ostringstream oss;
8696 oss << " Test: " << test_ << "\n"
8697 << " Error: Iterator access failed\n"
8698 << " Details:\n"
8699 << " Result: " << cs.begin( 1UL )->value() << "\n"
8700 << " Expected result: 1\n";
8701 throw std::runtime_error( oss.str() );
8702 }
8703 }
8704
8705 try {
8706 SMT sm1 = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 2UL );
8707 auto cs = blaze::columns( sm1, []( size_t ){ return 2UL; }, 1UL );
8708
8709 std::ostringstream oss;
8710 oss << " Test: " << test_ << "\n"
8711 << " Error: Setup of out-of-bounds column selection succeeded\n"
8712 << " Details:\n"
8713 << " Result:\n" << cs << "\n";
8714 throw std::runtime_error( oss.str() );
8715 }
8716 catch( std::invalid_argument& ) {}
8717 }
8718
8719
8720 //=====================================================================================
8721 // Column-major matrix tests (initializer_list)
8722 //=====================================================================================
8723
8724 {
8725 test_ = "Column-major columns() function (initializer_list)";
8726
8727 initialize();
8728
8729 {
8730 OSMT sm1 = blaze::submatrix( tmat_, 1UL, 1UL, 2UL, 3UL );
8731 auto cs = blaze::columns( sm1, { 1UL, 0UL } );
8732
8733 if( cs(0,0) != 0 || cs(0,1) != 1 ||
8734 cs(1,0) != -3 || cs(1,1) != 0 ) {
8735 std::ostringstream oss;
8736 oss << " Test: " << test_ << "\n"
8737 << " Error: Function call operator access failed\n"
8738 << " Details:\n"
8739 << " Result:\n" << cs << "\n"
8740 << " Expected result:\n( 0 1 )\n( -3 0 )\n";
8741 throw std::runtime_error( oss.str() );
8742 }
8743
8744 if( cs.begin( 1UL )->value() != 1 ) {
8745 std::ostringstream oss;
8746 oss << " Test: " << test_ << "\n"
8747 << " Error: Iterator access failed\n"
8748 << " Details:\n"
8749 << " Result: " << cs.begin( 1UL )->value() << "\n"
8750 << " Expected result: 1\n";
8751 throw std::runtime_error( oss.str() );
8752 }
8753 }
8754
8755 try {
8756 OSMT sm1 = blaze::submatrix( tmat_, 1UL, 1UL, 2UL, 3UL );
8757 auto cs = blaze::columns( sm1, { 3UL } );
8758
8759 std::ostringstream oss;
8760 oss << " Test: " << test_ << "\n"
8761 << " Error: Setup of out-of-bounds column selection succeeded\n"
8762 << " Details:\n"
8763 << " Result:\n" << cs << "\n";
8764 throw std::runtime_error( oss.str() );
8765 }
8766 catch( std::invalid_argument& ) {}
8767 }
8768
8769
8770 //=====================================================================================
8771 // Column-major matrix tests (std::array)
8772 //=====================================================================================
8773
8774 {
8775 test_ = "Column-major columns() function (std::array)";
8776
8777 initialize();
8778
8779 {
8780 std::array<int,2UL> indices{ 1UL, 0UL };
8781
8782 OSMT sm1 = blaze::submatrix( tmat_, 1UL, 1UL, 2UL, 3UL );
8783 auto cs = blaze::columns( sm1, indices );
8784
8785 if( cs(0,0) != 0 || cs(0,1) != 1 ||
8786 cs(1,0) != -3 || cs(1,1) != 0 ) {
8787 std::ostringstream oss;
8788 oss << " Test: " << test_ << "\n"
8789 << " Error: Function call operator access failed\n"
8790 << " Details:\n"
8791 << " Result:\n" << cs << "\n"
8792 << " Expected result:\n( 0 1 )\n( -3 0 )\n";
8793 throw std::runtime_error( oss.str() );
8794 }
8795
8796 if( cs.begin( 1UL )->value() != 1 ) {
8797 std::ostringstream oss;
8798 oss << " Test: " << test_ << "\n"
8799 << " Error: Iterator access failed\n"
8800 << " Details:\n"
8801 << " Result: " << cs.begin( 1UL )->value() << "\n"
8802 << " Expected result: 1\n";
8803 throw std::runtime_error( oss.str() );
8804 }
8805 }
8806
8807 try {
8808 std::array<int,1UL> indices{ 3UL };
8809
8810 OSMT sm1 = blaze::submatrix( tmat_, 1UL, 1UL, 2UL, 3UL );
8811 auto cs = blaze::columns( sm1, indices );
8812
8813 std::ostringstream oss;
8814 oss << " Test: " << test_ << "\n"
8815 << " Error: Setup of out-of-bounds column selection succeeded\n"
8816 << " Details:\n"
8817 << " Result:\n" << cs << "\n";
8818 throw std::runtime_error( oss.str() );
8819 }
8820 catch( std::invalid_argument& ) {}
8821 }
8822
8823
8824 //=====================================================================================
8825 // Column-major matrix tests (lambda expression)
8826 //=====================================================================================
8827
8828 {
8829 test_ = "Column-major columns() function (lambda expression)";
8830
8831 initialize();
8832
8833 {
8834 OSMT sm1 = blaze::submatrix( tmat_, 1UL, 1UL, 2UL, 3UL );
8835 auto cs = blaze::columns( sm1, []( size_t i ){ return 1UL-i; }, 2UL );
8836
8837 if( cs(0,0) != 0 || cs(0,1) != 1 ||
8838 cs(1,0) != -3 || cs(1,1) != 0 ) {
8839 std::ostringstream oss;
8840 oss << " Test: " << test_ << "\n"
8841 << " Error: Function call operator access failed\n"
8842 << " Details:\n"
8843 << " Result:\n" << cs << "\n"
8844 << " Expected result:\n( 0 1 )\n( -3 0 )\n";
8845 throw std::runtime_error( oss.str() );
8846 }
8847
8848 if( cs.begin( 1UL )->value() != 1 ) {
8849 std::ostringstream oss;
8850 oss << " Test: " << test_ << "\n"
8851 << " Error: Iterator access failed\n"
8852 << " Details:\n"
8853 << " Result: " << cs.begin( 1UL )->value() << "\n"
8854 << " Expected result: 1\n";
8855 throw std::runtime_error( oss.str() );
8856 }
8857 }
8858
8859 try {
8860 OSMT sm1 = blaze::submatrix( tmat_, 1UL, 1UL, 2UL, 3UL );
8861 auto cs = blaze::columns( sm1, []( size_t ){ return 3UL; }, 1UL );
8862
8863 std::ostringstream oss;
8864 oss << " Test: " << test_ << "\n"
8865 << " Error: Setup of out-of-bounds column selection succeeded\n"
8866 << " Details:\n"
8867 << " Result:\n" << cs << "\n";
8868 throw std::runtime_error( oss.str() );
8869 }
8870 catch( std::invalid_argument& ) {}
8871 }
8872 }
8873 //*************************************************************************************************
8874
8875
8876 //*************************************************************************************************
8877 /*!\brief Test of the \c band() function with the Submatrix class template.
8878 //
8879 // \return void
8880 // \exception std::runtime_error Error detected.
8881 //
8882 // This function performs a test of the \c band() function with the Submatrix specialization.
8883 // In case an error is detected, a \a std::runtime_error exception is thrown.
8884 */
testBand()8885 void SparseTest::testBand()
8886 {
8887 //=====================================================================================
8888 // Row-major matrix tests
8889 //=====================================================================================
8890
8891 {
8892 test_ = "Row-major band() function";
8893
8894 initialize();
8895
8896 {
8897 SMT sm1 = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 2UL );
8898 auto b1 = blaze::band( sm1, -1L );
8899
8900 if( b1[0] != 0 || b1[1] != 5 ) {
8901 std::ostringstream oss;
8902 oss << " Test: " << test_ << "\n"
8903 << " Error: Subscript operator access failed\n"
8904 << " Details:\n"
8905 << " Result:\n" << b1 << "\n"
8906 << " Expected result:\n( 0 5 )\n";
8907 throw std::runtime_error( oss.str() );
8908 }
8909
8910 if( b1.begin()->value() != 5 ) {
8911 std::ostringstream oss;
8912 oss << " Test: " << test_ << "\n"
8913 << " Error: Iterator access failed\n"
8914 << " Details:\n"
8915 << " Result: " << b1.begin()->value() << "\n"
8916 << " Expected result: 5\n";
8917 throw std::runtime_error( oss.str() );
8918 }
8919 }
8920
8921 try {
8922 SMT sm1 = blaze::submatrix( mat_, 1UL, 1UL, 3UL, 2UL );
8923 auto b2 = blaze::band( sm1, 2L );
8924
8925 std::ostringstream oss;
8926 oss << " Test: " << test_ << "\n"
8927 << " Error: Setup of out-of-bounds band succeeded\n"
8928 << " Details:\n"
8929 << " Result:\n" << b2 << "\n";
8930 throw std::runtime_error( oss.str() );
8931 }
8932 catch( std::invalid_argument& ) {}
8933 }
8934
8935
8936 //=====================================================================================
8937 // Column-major matrix tests
8938 //=====================================================================================
8939
8940 {
8941 test_ = "Column-major band() function";
8942
8943 initialize();
8944
8945 {
8946 OSMT sm1 = blaze::submatrix( tmat_, 1UL, 1UL, 2UL, 3UL );
8947 auto b1 = blaze::band( sm1, 1L );
8948
8949 if( b1[0] != 0 || b1[1] != 5 ) {
8950 std::ostringstream oss;
8951 oss << " Test: " << test_ << "\n"
8952 << " Error: Subscript operator access failed\n"
8953 << " Details:\n"
8954 << " Result:\n" << b1 << "\n"
8955 << " Expected result:\n( 0 5 )\n";
8956 throw std::runtime_error( oss.str() );
8957 }
8958
8959 if( b1.begin()->value() != 5 ) {
8960 std::ostringstream oss;
8961 oss << " Test: " << test_ << "\n"
8962 << " Error: Iterator access failed\n"
8963 << " Details:\n"
8964 << " Result: " << b1.begin()->value() << "\n"
8965 << " Expected result: 5\n";
8966 throw std::runtime_error( oss.str() );
8967 }
8968 }
8969
8970 try {
8971 OSMT sm1 = blaze::submatrix( tmat_, 1UL, 1UL, 2UL, 3UL );
8972 auto b2 = blaze::band( sm1, -2L );
8973
8974 std::ostringstream oss;
8975 oss << " Test: " << test_ << "\n"
8976 << " Error: Setup of out-of-bounds band succeeded\n"
8977 << " Details:\n"
8978 << " Result:\n" << b2 << "\n";
8979 throw std::runtime_error( oss.str() );
8980 }
8981 catch( std::invalid_argument& ) {}
8982 }
8983 }
8984 //*************************************************************************************************
8985
8986
8987
8988
8989 //=================================================================================================
8990 //
8991 // UTILITY FUNCTIONS
8992 //
8993 //=================================================================================================
8994
8995 //*************************************************************************************************
8996 /*!\brief Initialization of all member matrices.
8997 //
8998 // \return void
8999 // \exception std::runtime_error Error detected.
9000 //
9001 // This function initializes all member matrices to specific predetermined values.
9002 */
initialize()9003 void SparseTest::initialize()
9004 {
9005 // Initializing the row-major compressed matrix
9006 mat_.reset();
9007 mat_(1,1) = 1;
9008 mat_(2,0) = -2;
9009 mat_(2,2) = -3;
9010 mat_(3,1) = 4;
9011 mat_(3,2) = 5;
9012 mat_(3,3) = -6;
9013 mat_(4,0) = 7;
9014 mat_(4,1) = -8;
9015 mat_(4,2) = 9;
9016 mat_(4,3) = 10;
9017
9018 // Initializing the column-major compressed matrix
9019 tmat_.reset();
9020 tmat_(1,1) = 1;
9021 tmat_(0,2) = -2;
9022 tmat_(2,2) = -3;
9023 tmat_(1,3) = 4;
9024 tmat_(2,3) = 5;
9025 tmat_(3,3) = -6;
9026 tmat_(0,4) = 7;
9027 tmat_(1,4) = -8;
9028 tmat_(2,4) = 9;
9029 tmat_(3,4) = 10;
9030 }
9031 //*************************************************************************************************
9032
9033 } // namespace submatrix
9034
9035 } // namespace views
9036
9037 } // namespace mathtest
9038
9039 } // namespace blazetest
9040
9041
9042
9043
9044 //=================================================================================================
9045 //
9046 // MAIN FUNCTION
9047 //
9048 //=================================================================================================
9049
9050 //*************************************************************************************************
main()9051 int main()
9052 {
9053 std::cout << " Running Submatrix sparse test (part 2)..." << std::endl;
9054
9055 try
9056 {
9057 RUN_SUBMATRIX_SPARSE_TEST;
9058 }
9059 catch( std::exception& ex ) {
9060 std::cerr << "\n\n ERROR DETECTED during Submatrix sparse test (part 2):\n"
9061 << ex.what() << "\n";
9062 return EXIT_FAILURE;
9063 }
9064
9065 return EXIT_SUCCESS;
9066 }
9067 //*************************************************************************************************
9068