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