Nektar++
BlockMatrixUnitTests.cpp
Go to the documentation of this file.
1///////////////////////////////////////////////////////////////////////////////
2//
3// File: BlockMatrixUnitTests.cpp
4//
5// For more information, please see: http://www.nektar.info
6//
7// The MIT License
8//
9// Copyright (c) 2006 Division of Applied Mathematics, Brown University (USA),
10// Department of Aeronautics, Imperial College London (UK), and Scientific
11// Computing and Imaging Institute, University of Utah (USA).
12//
13// Permission is hereby granted, free of charge, to any person obtaining a
14// copy of this software and associated documentation files (the "Software"),
15// to deal in the Software without restriction, including without limitation
16// the rights to use, copy, modify, merge, publish, distribute, sublicense,
17// and/or sell copies of the Software, and to permit persons to whom the
18// Software is furnished to do so, subject to the following conditions:
19//
20// The above copyright notice and this permission notice shall be included
21// in all copies or substantial portions of the Software.
22//
23// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
24// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
25// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
26// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
27// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
28// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
29// DEALINGS IN THE SOFTWARE.
30//
31// Description:
32//
33///////////////////////////////////////////////////////////////////////////////
34
35#include <LibUtilities/LinearAlgebra/NekMatrix.hpp>
36#include <LibUtilities/LinearAlgebra/NekTypeDefs.hpp>
37#include <boost/test/tools/floating_point_comparison.hpp>
38#include <boost/test/unit_test.hpp>
39#include <iostream>
40
41namespace Nektar
42{
43namespace BlockMatrixUnitTests
44{
45BOOST_AUTO_TEST_CASE(TestEqualSizedBlockConstruction)
46{
47 {
48 typedef NekMatrix<NekMatrix<NekDouble>, BlockMatrixTag> BlockMatrixType;
49 BlockMatrixType m1(3, 2, 2, 2);
50 std::shared_ptr<ConstMatrix<NekDouble>> m2(
51 new BlockMatrixType(2, 3, 2, 2));
52
53 BOOST_CHECK_EQUAL(m1.GetRows(), 6u);
54 BOOST_CHECK_EQUAL(m1.GetColumns(), 4u);
55 BOOST_CHECK_EQUAL(m2->GetRows(), 4u);
56 BOOST_CHECK_EQUAL(m2->GetColumns(), 6u);
57 }
58
59 // Bad Input
60 {
61 }
62}
63
64BOOST_AUTO_TEST_CASE(TestElementAccessBlockMatrix)
65{
66 {
67 typedef NekMatrix<NekMatrix<NekDouble>, BlockMatrixTag> BlockMatrixType;
68 BlockMatrixType m1(3, 2, 2, 2);
69 std::shared_ptr<ConstMatrix<NekDouble>> m2(
70 new BlockMatrixType(3, 2, 2, 2));
71
72 double vals1[] = {1.0, 3.0, 2.0, 4.0};
73 double vals2[] = {5.0, 7.0, 6.0, 8.0};
74 double vals3[] = {9.0, 11.0, 10.0, 12.0};
75 double vals4[] = {13.0, 15.0, 14.0, 16.0};
76 double vals5[] = {17.0, 19.0, 18.0, 20.0};
77 double vals6[] = {21.0, 23.0, 22.0, 24.0};
78
79 std::shared_ptr<NekMatrix<NekDouble>> sub1(
80 new NekMatrix<NekDouble>(2, 2, vals1));
81 std::shared_ptr<NekMatrix<NekDouble>> sub2(
82 new NekMatrix<NekDouble>(2, 2, vals2));
83 std::shared_ptr<NekMatrix<NekDouble>> sub3(
84 new NekMatrix<NekDouble>(2, 2, vals3));
85 std::shared_ptr<NekMatrix<NekDouble>> sub4(
86 new NekMatrix<NekDouble>(2, 2, vals4));
87 std::shared_ptr<NekMatrix<NekDouble>> sub5(
88 new NekMatrix<NekDouble>(2, 2, vals5));
89 std::shared_ptr<NekMatrix<NekDouble>> sub6(
90 new NekMatrix<NekDouble>(2, 2, vals6));
91
92 m1.SetBlock(0, 0, sub1);
93 m1.SetBlock(0, 1, sub2);
94 m1.SetBlock(1, 0, sub3);
95 m1.SetBlock(1, 1, sub4);
96 m1.SetBlock(2, 0, sub5);
97 m1.SetBlock(2, 1, sub6);
98
99 std::shared_ptr<BlockMatrixType> m2_cast =
100 std::dynamic_pointer_cast<BlockMatrixType>(m2);
101
102 m2_cast->SetBlock(0, 0, sub1);
103 m2_cast->SetBlock(0, 1, sub2);
104 m2_cast->SetBlock(1, 0, sub3);
105 m2_cast->SetBlock(1, 1, sub4);
106 m2_cast->SetBlock(2, 0, sub5);
107 m2_cast->SetBlock(2, 1, sub6);
108
109 BOOST_CHECK_EQUAL(m1(0, 0), 1.0);
110 BOOST_CHECK_EQUAL(m1(0, 1), 2.0);
111 BOOST_CHECK_EQUAL(m1(0, 2), 5.0);
112 BOOST_CHECK_EQUAL(m1(0, 3), 6.0);
113 BOOST_CHECK_EQUAL(m1(1, 0), 3.0);
114 BOOST_CHECK_EQUAL(m1(1, 1), 4.0);
115 BOOST_CHECK_EQUAL(m1(1, 2), 7.0);
116 BOOST_CHECK_EQUAL(m1(1, 3), 8.0);
117 BOOST_CHECK_EQUAL(m1(2, 0), 9.0);
118 BOOST_CHECK_EQUAL(m1(2, 1), 10.0);
119 BOOST_CHECK_EQUAL(m1(2, 2), 13.0);
120 BOOST_CHECK_EQUAL(m1(2, 3), 14.0);
121 BOOST_CHECK_EQUAL(m1(3, 0), 11.0);
122 BOOST_CHECK_EQUAL(m1(3, 1), 12.0);
123 BOOST_CHECK_EQUAL(m1(3, 2), 15.0);
124 BOOST_CHECK_EQUAL(m1(3, 3), 16.0);
125 BOOST_CHECK_EQUAL(m1(4, 0), 17.0);
126 BOOST_CHECK_EQUAL(m1(4, 1), 18.0);
127 BOOST_CHECK_EQUAL(m1(4, 2), 21.0);
128 BOOST_CHECK_EQUAL(m1(4, 3), 22.0);
129 BOOST_CHECK_EQUAL(m1(5, 0), 19.0);
130 BOOST_CHECK_EQUAL(m1(5, 1), 20.0);
131 BOOST_CHECK_EQUAL(m1(5, 2), 23.0);
132 BOOST_CHECK_EQUAL(m1(5, 3), 24.0);
133
134 BOOST_CHECK_EQUAL((*m2)(0, 0), 1.0);
135 BOOST_CHECK_EQUAL((*m2)(0, 1), 2.0);
136 BOOST_CHECK_EQUAL((*m2)(0, 2), 5.0);
137 BOOST_CHECK_EQUAL((*m2)(0, 3), 6.0);
138 BOOST_CHECK_EQUAL((*m2)(1, 0), 3.0);
139 BOOST_CHECK_EQUAL((*m2)(1, 1), 4.0);
140 BOOST_CHECK_EQUAL((*m2)(1, 2), 7.0);
141 BOOST_CHECK_EQUAL((*m2)(1, 3), 8.0);
142 BOOST_CHECK_EQUAL((*m2)(2, 0), 9.0);
143 BOOST_CHECK_EQUAL((*m2)(2, 1), 10.0);
144 BOOST_CHECK_EQUAL((*m2)(2, 2), 13.0);
145 BOOST_CHECK_EQUAL((*m2)(2, 3), 14.0);
146 BOOST_CHECK_EQUAL((*m2)(3, 0), 11.0);
147 BOOST_CHECK_EQUAL((*m2)(3, 1), 12.0);
148 BOOST_CHECK_EQUAL((*m2)(3, 2), 15.0);
149 BOOST_CHECK_EQUAL((*m2)(3, 3), 16.0);
150 BOOST_CHECK_EQUAL((*m2)(4, 0), 17.0);
151 BOOST_CHECK_EQUAL((*m2)(4, 1), 18.0);
152 BOOST_CHECK_EQUAL((*m2)(4, 2), 21.0);
153 BOOST_CHECK_EQUAL((*m2)(4, 3), 22.0);
154 BOOST_CHECK_EQUAL((*m2)(5, 0), 19.0);
155 BOOST_CHECK_EQUAL((*m2)(5, 1), 20.0);
156 BOOST_CHECK_EQUAL((*m2)(5, 2), 23.0);
157 BOOST_CHECK_EQUAL((*m2)(5, 3), 24.0);
158 }
159
160 {
161 typedef NekMatrix<NekMatrix<NekDouble>, BlockMatrixTag> BlockMatrixType;
162 unsigned int rowSizes[] = {2, 2, 2};
163 unsigned int columnSizes[] = {2, 2};
164 BlockMatrixType m1(3, 2, rowSizes, columnSizes);
165 std::shared_ptr<ConstMatrix<NekDouble>> m2(
166 new BlockMatrixType(3, 2, rowSizes, columnSizes));
167
168 double vals1[] = {1.0, 3.0, 2.0, 4.0};
169 double vals2[] = {5.0, 7.0, 6.0, 8.0};
170 double vals3[] = {9.0, 11.0, 10.0, 12.0};
171 double vals4[] = {13.0, 15.0, 14.0, 16.0};
172 double vals5[] = {17.0, 19.0, 18.0, 20.0};
173 double vals6[] = {21.0, 23.0, 22.0, 24.0};
174
175 std::shared_ptr<NekMatrix<NekDouble>> sub1(
176 new NekMatrix<NekDouble>(2, 2, vals1));
177 std::shared_ptr<NekMatrix<NekDouble>> sub2(
178 new NekMatrix<NekDouble>(2, 2, vals2));
179 std::shared_ptr<NekMatrix<NekDouble>> sub3(
180 new NekMatrix<NekDouble>(2, 2, vals3));
181 std::shared_ptr<NekMatrix<NekDouble>> sub4(
182 new NekMatrix<NekDouble>(2, 2, vals4));
183 std::shared_ptr<NekMatrix<NekDouble>> sub5(
184 new NekMatrix<NekDouble>(2, 2, vals5));
185 std::shared_ptr<NekMatrix<NekDouble>> sub6(
186 new NekMatrix<NekDouble>(2, 2, vals6));
187
188 m1.SetBlock(0, 0, sub1);
189 m1.SetBlock(0, 1, sub2);
190 m1.SetBlock(1, 0, sub3);
191 m1.SetBlock(1, 1, sub4);
192 m1.SetBlock(2, 0, sub5);
193 m1.SetBlock(2, 1, sub6);
194
195 std::shared_ptr<BlockMatrixType> m2_cast =
196 std::dynamic_pointer_cast<BlockMatrixType>(m2);
197
198 m2_cast->SetBlock(0, 0, sub1);
199 m2_cast->SetBlock(0, 1, sub2);
200 m2_cast->SetBlock(1, 0, sub3);
201 m2_cast->SetBlock(1, 1, sub4);
202 m2_cast->SetBlock(2, 0, sub5);
203 m2_cast->SetBlock(2, 1, sub6);
204
205 BOOST_CHECK_EQUAL(m1(0, 0), 1.0);
206 BOOST_CHECK_EQUAL(m1(0, 1), 2.0);
207 BOOST_CHECK_EQUAL(m1(0, 2), 5.0);
208 BOOST_CHECK_EQUAL(m1(0, 3), 6.0);
209 BOOST_CHECK_EQUAL(m1(1, 0), 3.0);
210 BOOST_CHECK_EQUAL(m1(1, 1), 4.0);
211 BOOST_CHECK_EQUAL(m1(1, 2), 7.0);
212 BOOST_CHECK_EQUAL(m1(1, 3), 8.0);
213 BOOST_CHECK_EQUAL(m1(2, 0), 9.0);
214 BOOST_CHECK_EQUAL(m1(2, 1), 10.0);
215 BOOST_CHECK_EQUAL(m1(2, 2), 13.0);
216 BOOST_CHECK_EQUAL(m1(2, 3), 14.0);
217 BOOST_CHECK_EQUAL(m1(3, 0), 11.0);
218 BOOST_CHECK_EQUAL(m1(3, 1), 12.0);
219 BOOST_CHECK_EQUAL(m1(3, 2), 15.0);
220 BOOST_CHECK_EQUAL(m1(3, 3), 16.0);
221 BOOST_CHECK_EQUAL(m1(4, 0), 17.0);
222 BOOST_CHECK_EQUAL(m1(4, 1), 18.0);
223 BOOST_CHECK_EQUAL(m1(4, 2), 21.0);
224 BOOST_CHECK_EQUAL(m1(4, 3), 22.0);
225 BOOST_CHECK_EQUAL(m1(5, 0), 19.0);
226 BOOST_CHECK_EQUAL(m1(5, 1), 20.0);
227 BOOST_CHECK_EQUAL(m1(5, 2), 23.0);
228 BOOST_CHECK_EQUAL(m1(5, 3), 24.0);
229
230 BOOST_CHECK_EQUAL((*m2)(0, 0), 1.0);
231 BOOST_CHECK_EQUAL((*m2)(0, 1), 2.0);
232 BOOST_CHECK_EQUAL((*m2)(0, 2), 5.0);
233 BOOST_CHECK_EQUAL((*m2)(0, 3), 6.0);
234 BOOST_CHECK_EQUAL((*m2)(1, 0), 3.0);
235 BOOST_CHECK_EQUAL((*m2)(1, 1), 4.0);
236 BOOST_CHECK_EQUAL((*m2)(1, 2), 7.0);
237 BOOST_CHECK_EQUAL((*m2)(1, 3), 8.0);
238 BOOST_CHECK_EQUAL((*m2)(2, 0), 9.0);
239 BOOST_CHECK_EQUAL((*m2)(2, 1), 10.0);
240 BOOST_CHECK_EQUAL((*m2)(2, 2), 13.0);
241 BOOST_CHECK_EQUAL((*m2)(2, 3), 14.0);
242 BOOST_CHECK_EQUAL((*m2)(3, 0), 11.0);
243 BOOST_CHECK_EQUAL((*m2)(3, 1), 12.0);
244 BOOST_CHECK_EQUAL((*m2)(3, 2), 15.0);
245 BOOST_CHECK_EQUAL((*m2)(3, 3), 16.0);
246 BOOST_CHECK_EQUAL((*m2)(4, 0), 17.0);
247 BOOST_CHECK_EQUAL((*m2)(4, 1), 18.0);
248 BOOST_CHECK_EQUAL((*m2)(4, 2), 21.0);
249 BOOST_CHECK_EQUAL((*m2)(4, 3), 22.0);
250 BOOST_CHECK_EQUAL((*m2)(5, 0), 19.0);
251 BOOST_CHECK_EQUAL((*m2)(5, 1), 20.0);
252 BOOST_CHECK_EQUAL((*m2)(5, 2), 23.0);
253 BOOST_CHECK_EQUAL((*m2)(5, 3), 24.0);
254 }
255
256 {
257 typedef NekMatrix<NekMatrix<NekDouble>, BlockMatrixTag> BlockMatrixType;
258 unsigned int rowSizesBuf[] = {2, 2, 2};
259 unsigned int columnSizesBuf[] = {2, 2};
260 Array<OneD, unsigned int> rowSizes(3, rowSizesBuf);
261 Array<OneD, unsigned int> columnSizes(2, columnSizesBuf);
262
263 BlockMatrixType m1(3, 2, rowSizes, columnSizes);
264 std::shared_ptr<ConstMatrix<NekDouble>> m2(
265 new BlockMatrixType(3, 2, rowSizes, columnSizes));
266
267 double vals1[] = {1.0, 3.0, 2.0, 4.0};
268 double vals2[] = {5.0, 7.0, 6.0, 8.0};
269 double vals3[] = {9.0, 11.0, 10.0, 12.0};
270 double vals4[] = {13.0, 15.0, 14.0, 16.0};
271 double vals5[] = {17.0, 19.0, 18.0, 20.0};
272 double vals6[] = {21.0, 23.0, 22.0, 24.0};
273
274 std::shared_ptr<NekMatrix<NekDouble>> sub1(
275 new NekMatrix<NekDouble>(2, 2, vals1));
276 std::shared_ptr<NekMatrix<NekDouble>> sub2(
277 new NekMatrix<NekDouble>(2, 2, vals2));
278 std::shared_ptr<NekMatrix<NekDouble>> sub3(
279 new NekMatrix<NekDouble>(2, 2, vals3));
280 std::shared_ptr<NekMatrix<NekDouble>> sub4(
281 new NekMatrix<NekDouble>(2, 2, vals4));
282 std::shared_ptr<NekMatrix<NekDouble>> sub5(
283 new NekMatrix<NekDouble>(2, 2, vals5));
284 std::shared_ptr<NekMatrix<NekDouble>> sub6(
285 new NekMatrix<NekDouble>(2, 2, vals6));
286
287 m1.SetBlock(0, 0, sub1);
288 m1.SetBlock(0, 1, sub2);
289 m1.SetBlock(1, 0, sub3);
290 m1.SetBlock(1, 1, sub4);
291 m1.SetBlock(2, 0, sub5);
292 m1.SetBlock(2, 1, sub6);
293
294 std::shared_ptr<BlockMatrixType> m2_cast =
295 std::dynamic_pointer_cast<BlockMatrixType>(m2);
296
297 m2_cast->SetBlock(0, 0, sub1);
298 m2_cast->SetBlock(0, 1, sub2);
299 m2_cast->SetBlock(1, 0, sub3);
300 m2_cast->SetBlock(1, 1, sub4);
301 m2_cast->SetBlock(2, 0, sub5);
302 m2_cast->SetBlock(2, 1, sub6);
303
304 BOOST_CHECK_EQUAL(m1(0, 0), 1.0);
305 BOOST_CHECK_EQUAL(m1(0, 1), 2.0);
306 BOOST_CHECK_EQUAL(m1(0, 2), 5.0);
307 BOOST_CHECK_EQUAL(m1(0, 3), 6.0);
308 BOOST_CHECK_EQUAL(m1(1, 0), 3.0);
309 BOOST_CHECK_EQUAL(m1(1, 1), 4.0);
310 BOOST_CHECK_EQUAL(m1(1, 2), 7.0);
311 BOOST_CHECK_EQUAL(m1(1, 3), 8.0);
312 BOOST_CHECK_EQUAL(m1(2, 0), 9.0);
313 BOOST_CHECK_EQUAL(m1(2, 1), 10.0);
314 BOOST_CHECK_EQUAL(m1(2, 2), 13.0);
315 BOOST_CHECK_EQUAL(m1(2, 3), 14.0);
316 BOOST_CHECK_EQUAL(m1(3, 0), 11.0);
317 BOOST_CHECK_EQUAL(m1(3, 1), 12.0);
318 BOOST_CHECK_EQUAL(m1(3, 2), 15.0);
319 BOOST_CHECK_EQUAL(m1(3, 3), 16.0);
320 BOOST_CHECK_EQUAL(m1(4, 0), 17.0);
321 BOOST_CHECK_EQUAL(m1(4, 1), 18.0);
322 BOOST_CHECK_EQUAL(m1(4, 2), 21.0);
323 BOOST_CHECK_EQUAL(m1(4, 3), 22.0);
324 BOOST_CHECK_EQUAL(m1(5, 0), 19.0);
325 BOOST_CHECK_EQUAL(m1(5, 1), 20.0);
326 BOOST_CHECK_EQUAL(m1(5, 2), 23.0);
327 BOOST_CHECK_EQUAL(m1(5, 3), 24.0);
328
329 BOOST_CHECK_EQUAL((*m2)(0, 0), 1.0);
330 BOOST_CHECK_EQUAL((*m2)(0, 1), 2.0);
331 BOOST_CHECK_EQUAL((*m2)(0, 2), 5.0);
332 BOOST_CHECK_EQUAL((*m2)(0, 3), 6.0);
333 BOOST_CHECK_EQUAL((*m2)(1, 0), 3.0);
334 BOOST_CHECK_EQUAL((*m2)(1, 1), 4.0);
335 BOOST_CHECK_EQUAL((*m2)(1, 2), 7.0);
336 BOOST_CHECK_EQUAL((*m2)(1, 3), 8.0);
337 BOOST_CHECK_EQUAL((*m2)(2, 0), 9.0);
338 BOOST_CHECK_EQUAL((*m2)(2, 1), 10.0);
339 BOOST_CHECK_EQUAL((*m2)(2, 2), 13.0);
340 BOOST_CHECK_EQUAL((*m2)(2, 3), 14.0);
341 BOOST_CHECK_EQUAL((*m2)(3, 0), 11.0);
342 BOOST_CHECK_EQUAL((*m2)(3, 1), 12.0);
343 BOOST_CHECK_EQUAL((*m2)(3, 2), 15.0);
344 BOOST_CHECK_EQUAL((*m2)(3, 3), 16.0);
345 BOOST_CHECK_EQUAL((*m2)(4, 0), 17.0);
346 BOOST_CHECK_EQUAL((*m2)(4, 1), 18.0);
347 BOOST_CHECK_EQUAL((*m2)(4, 2), 21.0);
348 BOOST_CHECK_EQUAL((*m2)(4, 3), 22.0);
349 BOOST_CHECK_EQUAL((*m2)(5, 0), 19.0);
350 BOOST_CHECK_EQUAL((*m2)(5, 1), 20.0);
351 BOOST_CHECK_EQUAL((*m2)(5, 2), 23.0);
352 BOOST_CHECK_EQUAL((*m2)(5, 3), 24.0);
353 }
354}
355
356BOOST_AUTO_TEST_CASE(TestEmptyRowElementAccess)
357{
358 typedef NekMatrix<NekMatrix<NekDouble>, BlockMatrixTag> BlockMatrixType;
359 unsigned int rowSizes[] = {2, 0, 2, 0, 0, 2};
360 unsigned int columnSizes[] = {2, 2};
361 BlockMatrixType m1(6, 2, rowSizes, columnSizes);
362 std::shared_ptr<ConstMatrix<NekDouble>> m2(
363 new BlockMatrixType(6, 2, rowSizes, columnSizes));
364
365 double vals1[] = {1.0, 3.0, 2.0, 4.0};
366 double vals2[] = {5.0, 7.0, 6.0, 8.0};
367 double vals3[] = {9.0, 11.0, 10.0, 12.0};
368 double vals4[] = {13.0, 15.0, 14.0, 16.0};
369 double vals5[] = {17.0, 19.0, 18.0, 20.0};
370 double vals6[] = {21.0, 23.0, 22.0, 24.0};
371
372 std::shared_ptr<NekMatrix<NekDouble>> sub1(
373 new NekMatrix<NekDouble>(2, 2, vals1));
374 std::shared_ptr<NekMatrix<NekDouble>> sub2(
375 new NekMatrix<NekDouble>(2, 2, vals2));
376 std::shared_ptr<NekMatrix<NekDouble>> sub3(
377 new NekMatrix<NekDouble>(2, 2, vals3));
378 std::shared_ptr<NekMatrix<NekDouble>> sub4(
379 new NekMatrix<NekDouble>(2, 2, vals4));
380 std::shared_ptr<NekMatrix<NekDouble>> sub5(
381 new NekMatrix<NekDouble>(2, 2, vals5));
382 std::shared_ptr<NekMatrix<NekDouble>> sub6(
383 new NekMatrix<NekDouble>(2, 2, vals6));
384
385 m1.SetBlock(0, 0, sub1);
386 m1.SetBlock(0, 1, sub2);
387 m1.SetBlock(2, 0, sub3);
388 m1.SetBlock(2, 1, sub4);
389 m1.SetBlock(5, 0, sub5);
390 m1.SetBlock(5, 1, sub6);
391
392 std::shared_ptr<BlockMatrixType> m2_cast =
393 std::dynamic_pointer_cast<BlockMatrixType>(m2);
394
395 m2_cast->SetBlock(0, 0, sub1);
396 m2_cast->SetBlock(0, 1, sub2);
397 m2_cast->SetBlock(2, 0, sub3);
398 m2_cast->SetBlock(2, 1, sub4);
399 m2_cast->SetBlock(5, 0, sub5);
400 m2_cast->SetBlock(5, 1, sub6);
401
402 BOOST_CHECK_EQUAL(m1(0, 0), 1.0);
403 BOOST_CHECK_EQUAL(m1(0, 1), 2.0);
404 BOOST_CHECK_EQUAL(m1(0, 2), 5.0);
405 BOOST_CHECK_EQUAL(m1(0, 3), 6.0);
406 BOOST_CHECK_EQUAL(m1(1, 0), 3.0);
407 BOOST_CHECK_EQUAL(m1(1, 1), 4.0);
408 BOOST_CHECK_EQUAL(m1(1, 2), 7.0);
409 BOOST_CHECK_EQUAL(m1(1, 3), 8.0);
410 BOOST_CHECK_EQUAL(m1(2, 0), 9.0);
411 BOOST_CHECK_EQUAL(m1(2, 1), 10.0);
412 BOOST_CHECK_EQUAL(m1(2, 2), 13.0);
413 BOOST_CHECK_EQUAL(m1(2, 3), 14.0);
414 BOOST_CHECK_EQUAL(m1(3, 0), 11.0);
415 BOOST_CHECK_EQUAL(m1(3, 1), 12.0);
416 BOOST_CHECK_EQUAL(m1(3, 2), 15.0);
417 BOOST_CHECK_EQUAL(m1(3, 3), 16.0);
418 BOOST_CHECK_EQUAL(m1(4, 0), 17.0);
419 BOOST_CHECK_EQUAL(m1(4, 1), 18.0);
420 BOOST_CHECK_EQUAL(m1(4, 2), 21.0);
421 BOOST_CHECK_EQUAL(m1(4, 3), 22.0);
422 BOOST_CHECK_EQUAL(m1(5, 0), 19.0);
423 BOOST_CHECK_EQUAL(m1(5, 1), 20.0);
424 BOOST_CHECK_EQUAL(m1(5, 2), 23.0);
425 BOOST_CHECK_EQUAL(m1(5, 3), 24.0);
426
427 BOOST_CHECK_EQUAL((*m2)(0, 0), 1.0);
428 BOOST_CHECK_EQUAL((*m2)(0, 1), 2.0);
429 BOOST_CHECK_EQUAL((*m2)(0, 2), 5.0);
430 BOOST_CHECK_EQUAL((*m2)(0, 3), 6.0);
431 BOOST_CHECK_EQUAL((*m2)(1, 0), 3.0);
432 BOOST_CHECK_EQUAL((*m2)(1, 1), 4.0);
433 BOOST_CHECK_EQUAL((*m2)(1, 2), 7.0);
434 BOOST_CHECK_EQUAL((*m2)(1, 3), 8.0);
435 BOOST_CHECK_EQUAL((*m2)(2, 0), 9.0);
436 BOOST_CHECK_EQUAL((*m2)(2, 1), 10.0);
437 BOOST_CHECK_EQUAL((*m2)(2, 2), 13.0);
438 BOOST_CHECK_EQUAL((*m2)(2, 3), 14.0);
439 BOOST_CHECK_EQUAL((*m2)(3, 0), 11.0);
440 BOOST_CHECK_EQUAL((*m2)(3, 1), 12.0);
441 BOOST_CHECK_EQUAL((*m2)(3, 2), 15.0);
442 BOOST_CHECK_EQUAL((*m2)(3, 3), 16.0);
443 BOOST_CHECK_EQUAL((*m2)(4, 0), 17.0);
444 BOOST_CHECK_EQUAL((*m2)(4, 1), 18.0);
445 BOOST_CHECK_EQUAL((*m2)(4, 2), 21.0);
446 BOOST_CHECK_EQUAL((*m2)(4, 3), 22.0);
447 BOOST_CHECK_EQUAL((*m2)(5, 0), 19.0);
448 BOOST_CHECK_EQUAL((*m2)(5, 1), 20.0);
449 BOOST_CHECK_EQUAL((*m2)(5, 2), 23.0);
450 BOOST_CHECK_EQUAL((*m2)(5, 3), 24.0);
451}
452
453BOOST_AUTO_TEST_CASE(TestEmptyRowElementMultiplication)
454{
455 typedef NekMatrix<NekMatrix<NekDouble>, BlockMatrixTag> BlockMatrixType;
456 unsigned int rowSizes[] = {0, 2, 0, 2, 0, 0, 2};
457 unsigned int columnSizes[] = {0, 2, 2};
458 BlockMatrixType m1(7, 3, rowSizes, columnSizes);
459
460 double vals1[] = {1.0, 3.0, 2.0, 4.0};
461 double vals2[] = {5.0, 7.0, 6.0, 8.0};
462 double vals3[] = {9.0, 11.0, 10.0, 12.0};
463 double vals4[] = {13.0, 15.0, 14.0, 16.0};
464 double vals5[] = {17.0, 19.0, 18.0, 20.0};
465 double vals6[] = {21.0, 23.0, 22.0, 24.0};
466
467 std::shared_ptr<NekMatrix<NekDouble>> sub1(
468 new NekMatrix<NekDouble>(2, 2, vals1));
469 std::shared_ptr<NekMatrix<NekDouble>> sub2(
470 new NekMatrix<NekDouble>(2, 2, vals2));
471 std::shared_ptr<NekMatrix<NekDouble>> sub3(
472 new NekMatrix<NekDouble>(2, 2, vals3));
473 std::shared_ptr<NekMatrix<NekDouble>> sub4(
474 new NekMatrix<NekDouble>(2, 2, vals4));
475 std::shared_ptr<NekMatrix<NekDouble>> sub5(
476 new NekMatrix<NekDouble>(2, 2, vals5));
477 std::shared_ptr<NekMatrix<NekDouble>> sub6(
478 new NekMatrix<NekDouble>(2, 2, vals6));
479
480 std::shared_ptr<NekMatrix<NekDouble>> empty(new NekMatrix<NekDouble>(0, 0));
481 m1.SetBlock(0, 0, empty);
482 m1.SetBlock(0, 1, empty);
483 m1.SetBlock(0, 2, empty);
484 m1.SetBlock(1, 0, empty);
485 m1.SetBlock(1, 1, sub1);
486 m1.SetBlock(1, 2, sub2);
487 m1.SetBlock(2, 0, empty);
488 m1.SetBlock(3, 1, sub3);
489 m1.SetBlock(3, 2, sub4);
490 m1.SetBlock(6, 1, sub5);
491 m1.SetBlock(6, 2, sub6);
492
493 double x_buf[] = {1, 2, 3, 4};
494 NekVector<double> x(4, x_buf);
495
496 double expected_result_buf[] = {44, 64, 124, 144, 204, 224};
497 NekVector<double> expected_result(6, expected_result_buf);
498
499 NekVector<double> result1 = m1 * x;
500 BOOST_CHECK_EQUAL(result1, expected_result);
501}
502
503} // namespace BlockMatrixUnitTests
504} // namespace Nektar
Nektar::BlockMatrixUnitTests::BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(TestEqualSizedBlockConstruction)
Definition: BlockMatrixUnitTests.cpp:45
Nektar
The above copyright notice and this permission notice shall be included.
Definition: CoupledSolver.h:2
Generated on Wed Jan 31 2024 08:26:49 for Nektar++ by doxygen 1.9.4