Nektar++
TestBlockMatrix.cpp
Go to the documentation of this file.
1///////////////////////////////////////////////////////////////////////////////
2//
3// File: TestBlockMatrix.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 <boost/test/unit_test.hpp>
36
37#include <LibUtilities/LinearAlgebra/NekMatrix.hpp>
38#include <UnitTests/CountedObject.h>
39
40#include <boost/test/tools/floating_point_comparison.hpp>
41#include <boost/test/unit_test.hpp>
42
43namespace Nektar
44{
45namespace BlockMatrixUnitTests
46{
47BOOST_AUTO_TEST_CASE(TestRowsAndColumnsPerBlockAccess)
48{
49 NekMatrix<NekMatrix<double>, BlockMatrixTag> m(2, 3, 7, 10);
50 BOOST_CHECK_EQUAL(7, m.GetNumberOfRowsInBlockRow(0));
51 BOOST_CHECK_EQUAL(7, m.GetNumberOfRowsInBlockRow(1));
52 BOOST_CHECK_EQUAL(10, m.GetNumberOfColumnsInBlockColumn(0));
53 BOOST_CHECK_EQUAL(10, m.GetNumberOfColumnsInBlockColumn(1));
54 BOOST_CHECK_EQUAL(10, m.GetNumberOfColumnsInBlockColumn(2));
55}
56
57BOOST_AUTO_TEST_CASE(TestMultiplication)
58{
59 typedef NekMatrix<double> InnerType;
60 typedef NekMatrix<InnerType, BlockMatrixTag> BlockType;
61
62 double m1_buf[] = {1, 6, 2, 7, 3, 8};
63 double m2_buf[] = {4, 9, 5, 10};
64 double m3_buf[] = {11, 16, 12, 17, 13, 18};
65 double m4_buf[] = {14, 19, 15, 20};
66
67 std::shared_ptr<InnerType> m1(new InnerType(2, 3, m1_buf));
68 std::shared_ptr<InnerType> m2(new InnerType(2, 2, m2_buf));
69 std::shared_ptr<InnerType> m3(new InnerType(2, 3, m3_buf));
70 std::shared_ptr<InnerType> m4(new InnerType(2, 2, m4_buf));
71
72 unsigned int rowCounts[] = {2, 2};
73 unsigned int colCounts[] = {3, 2};
74
75 BlockType b(2, 2, rowCounts, colCounts);
76 b.SetBlock(0, 0, m1);
77 b.SetBlock(0, 1, m2);
78 b.SetBlock(1, 0, m3);
79 b.SetBlock(1, 1, m4);
80
81 double rhs_buf[] = {10, 20, 30, 40, 50};
82 NekVector<double> rhs(5, rhs_buf);
83
84 NekVector<double> result = b * rhs;
85
86 double expected_buf[] = {550, 1300, 2050, 2800};
87 NekVector<double> expected_result(4, expected_buf);
88
89 BOOST_CHECK_EQUAL(expected_result, result);
90}
91
92BOOST_AUTO_TEST_CASE(TestBlockMatrixTranspose)
93{
94 typedef NekMatrix<double> InnerType;
95 typedef NekMatrix<InnerType, BlockMatrixTag> BlockType;
96
97 double m00_buf[] = {1, 2, 3, 4, 5, 6, 7, 8};
98 double m01_buf[] = {9, 10, 11, 12, 13, 14, 15, 16, 17, 18};
99 double m02_buf[] = {19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30};
100 double m10_buf[] = {31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42};
101 double m11_buf[] = {43, 44, 45, 46, 47, 48, 49, 50,
102 51, 52, 53, 54, 55, 56, 57};
103 double m12_buf[] = {58, 59, 60, 61, 62, 63, 64, 65, 66,
104 67, 68, 69, 70, 71, 72, 73, 74, 75};
105
106 std::shared_ptr<InnerType> m00(new InnerType(2, 4, m00_buf));
107 std::shared_ptr<InnerType> m01(new InnerType(2, 5, m01_buf));
108 std::shared_ptr<InnerType> m02(new InnerType(2, 6, m02_buf));
109 std::shared_ptr<InnerType> m10(new InnerType(3, 4, m10_buf));
110 std::shared_ptr<InnerType> m11(new InnerType(3, 5, m11_buf));
111 std::shared_ptr<InnerType> m12(new InnerType(3, 6, m12_buf));
112
113 unsigned int rowCounts[] = {2, 3};
114 unsigned int colCounts[] = {4, 5, 6};
115
116 BlockType b(2, 3, rowCounts, colCounts);
117 b.SetBlock(0, 0, m00);
118 b.SetBlock(0, 1, m01);
119 b.SetBlock(0, 2, m02);
120 b.SetBlock(1, 0, m10);
121 b.SetBlock(1, 1, m11);
122 b.SetBlock(1, 2, m12);
123
124 BOOST_CHECK_EQUAL(2, b.GetNumberOfBlockRows());
125 BOOST_CHECK_EQUAL(3, b.GetNumberOfBlockColumns());
126 BOOST_CHECK_EQUAL(2, b.GetNumberOfRowsInBlockRow(0));
127 BOOST_CHECK_EQUAL(3, b.GetNumberOfRowsInBlockRow(1));
128 BOOST_CHECK_EQUAL(4, b.GetNumberOfColumnsInBlockColumn(0));
129 BOOST_CHECK_EQUAL(5, b.GetNumberOfColumnsInBlockColumn(1));
130 BOOST_CHECK_EQUAL(6, b.GetNumberOfColumnsInBlockColumn(2));
131
132 BOOST_CHECK_EQUAL(0, b.CalculateBlockIndex(0, 0));
133 BOOST_CHECK_EQUAL(1, b.CalculateBlockIndex(1, 0));
134 BOOST_CHECK_EQUAL(2, b.CalculateBlockIndex(0, 1));
135 BOOST_CHECK_EQUAL(3, b.CalculateBlockIndex(1, 1));
136 BOOST_CHECK_EQUAL(4, b.CalculateBlockIndex(0, 2));
137 BOOST_CHECK_EQUAL(5, b.CalculateBlockIndex(1, 2));
138
139 BOOST_CHECK_EQUAL(m00->GetRawPtr(), b.GetBlock(0, 0)->GetRawPtr());
140 BOOST_CHECK_EQUAL(m01->GetRawPtr(), b.GetBlock(0, 1)->GetRawPtr());
141 BOOST_CHECK_EQUAL(m02->GetRawPtr(), b.GetBlock(0, 2)->GetRawPtr());
142 BOOST_CHECK_EQUAL(m10->GetRawPtr(), b.GetBlock(1, 0)->GetRawPtr());
143 BOOST_CHECK_EQUAL(m11->GetRawPtr(), b.GetBlock(1, 1)->GetRawPtr());
144 BOOST_CHECK_EQUAL(m12->GetRawPtr(), b.GetBlock(1, 2)->GetRawPtr());
145
146 BOOST_CHECK_EQUAL('N', b.GetBlock(0, 0)->GetTransposeFlag());
147 BOOST_CHECK_EQUAL('N', b.GetBlock(0, 1)->GetTransposeFlag());
148 BOOST_CHECK_EQUAL('N', b.GetBlock(0, 2)->GetTransposeFlag());
149 BOOST_CHECK_EQUAL('N', b.GetBlock(1, 0)->GetTransposeFlag());
150 BOOST_CHECK_EQUAL('N', b.GetBlock(1, 1)->GetTransposeFlag());
151 BOOST_CHECK_EQUAL('N', b.GetBlock(1, 2)->GetTransposeFlag());
152
153 double v_buf[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
154 NekVector<double> v(15, v_buf);
155 NekVector<double> result = b * v;
156
157 BOOST_CHECK_EQUAL(5, result.GetRows());
158 BOOST_CHECK_EQUAL(2360, result[0]);
159 BOOST_CHECK_EQUAL(2480, result[1]);
160 BOOST_CHECK_EQUAL(7080, result[2]);
161 BOOST_CHECK_EQUAL(7200, result[3]);
162 BOOST_CHECK_EQUAL(7320, result[4]);
163
164 b.Transpose();
165
166 BOOST_CHECK_EQUAL(3, b.GetNumberOfBlockRows());
167 BOOST_CHECK_EQUAL(2, b.GetNumberOfBlockColumns());
168
169 BOOST_CHECK_EQUAL(2, b.GetNumberOfColumnsInBlockColumn(0));
170 BOOST_CHECK_EQUAL(3, b.GetNumberOfColumnsInBlockColumn(1));
171 BOOST_CHECK_EQUAL(4, b.GetNumberOfRowsInBlockRow(0));
172 BOOST_CHECK_EQUAL(5, b.GetNumberOfRowsInBlockRow(1));
173 BOOST_CHECK_EQUAL(6, b.GetNumberOfRowsInBlockRow(2));
174
175 BOOST_CHECK_EQUAL(0, b.CalculateBlockIndex(0, 0));
176 BOOST_CHECK_EQUAL(1, b.CalculateBlockIndex(0, 1));
177 BOOST_CHECK_EQUAL(2, b.CalculateBlockIndex(1, 0));
178 BOOST_CHECK_EQUAL(3, b.CalculateBlockIndex(1, 1));
179 BOOST_CHECK_EQUAL(4, b.CalculateBlockIndex(2, 0));
180 BOOST_CHECK_EQUAL(5, b.CalculateBlockIndex(2, 1));
181
182 BOOST_CHECK_EQUAL(m00->GetRawPtr(), b.GetBlock(0, 0)->GetRawPtr());
183 BOOST_CHECK_EQUAL(m01->GetRawPtr(), b.GetBlock(1, 0)->GetRawPtr());
184 BOOST_CHECK_EQUAL(m02->GetRawPtr(), b.GetBlock(2, 0)->GetRawPtr());
185 BOOST_CHECK_EQUAL(m10->GetRawPtr(), b.GetBlock(0, 1)->GetRawPtr());
186 BOOST_CHECK_EQUAL(m11->GetRawPtr(), b.GetBlock(1, 1)->GetRawPtr());
187 BOOST_CHECK_EQUAL(m12->GetRawPtr(), b.GetBlock(2, 1)->GetRawPtr());
188
189 BOOST_CHECK_EQUAL('T', b.GetBlock(0, 0)->GetTransposeFlag());
190 BOOST_CHECK_EQUAL('T', b.GetBlock(1, 0)->GetTransposeFlag());
191 BOOST_CHECK_EQUAL('T', b.GetBlock(2, 0)->GetTransposeFlag());
192 BOOST_CHECK_EQUAL('T', b.GetBlock(0, 1)->GetTransposeFlag());
193 BOOST_CHECK_EQUAL('T', b.GetBlock(1, 1)->GetTransposeFlag());
194 BOOST_CHECK_EQUAL('T', b.GetBlock(2, 1)->GetTransposeFlag());
195
196 double v_transpose_buf[] = {1, 2, 3, 4, 5};
197 NekVector<double> v_transpose(5, v_transpose_buf);
198 NekVector<double> result_transpose = b * v_transpose;
199
200 BOOST_CHECK_EQUAL(15, result_transpose.GetRows());
201 BOOST_CHECK_EQUAL(391, result_transpose[0]);
202 BOOST_CHECK_EQUAL(433, result_transpose[1]);
203 BOOST_CHECK_EQUAL(475, result_transpose[2]);
204 BOOST_CHECK_EQUAL(517, result_transpose[3]);
205 BOOST_CHECK_EQUAL(559, result_transpose[4]);
206 BOOST_CHECK_EQUAL(601, result_transpose[5]);
207 BOOST_CHECK_EQUAL(643, result_transpose[6]);
208 BOOST_CHECK_EQUAL(685, result_transpose[7]);
209 BOOST_CHECK_EQUAL(727, result_transpose[8]);
210 BOOST_CHECK_EQUAL(769, result_transpose[9]);
211 BOOST_CHECK_EQUAL(811, result_transpose[10]);
212 BOOST_CHECK_EQUAL(853, result_transpose[11]);
213 BOOST_CHECK_EQUAL(895, result_transpose[12]);
214 BOOST_CHECK_EQUAL(937, result_transpose[13]);
215 BOOST_CHECK_EQUAL(979, result_transpose[14]);
216
217 BlockType globalTranspose = Transpose(b);
218 NekVector<double> globalResult = globalTranspose * v;
219 BOOST_CHECK_EQUAL(5, globalResult.GetRows());
220 BOOST_CHECK_EQUAL(2360, globalResult[0]);
221 BOOST_CHECK_EQUAL(2480, globalResult[1]);
222 BOOST_CHECK_EQUAL(7080, globalResult[2]);
223 BOOST_CHECK_EQUAL(7200, globalResult[3]);
224 BOOST_CHECK_EQUAL(7320, globalResult[4]);
225 //
226}
227
228BOOST_AUTO_TEST_CASE(TestBlockScaledMatrix)
229{
230 typedef NekMatrix<NekMatrix<double>, ScaledMatrixTag> InnerType;
231 typedef NekMatrix<InnerType, BlockMatrixTag> BlockType;
232
233 double m00_buf[] = {1, 2, 3, 4, 5, 6, 7, 8};
234 double m01_buf[] = {9, 10, 11, 12, 13, 14, 15, 16, 17, 18};
235 double m02_buf[] = {19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30};
236 double m10_buf[] = {31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42};
237 double m11_buf[] = {43, 44, 45, 46, 47, 48, 49, 50,
238 51, 52, 53, 54, 55, 56, 57};
239 double m12_buf[] = {58, 59, 60, 61, 62, 63, 64, 65, 66,
240 67, 68, 69, 70, 71, 72, 73, 74, 75};
241
242 std::shared_ptr<NekMatrix<double>> m00(
243 new NekMatrix<double>(2, 4, m00_buf));
244 std::shared_ptr<NekMatrix<double>> m01(
245 new NekMatrix<double>(2, 5, m01_buf));
246 std::shared_ptr<NekMatrix<double>> m02(
247 new NekMatrix<double>(2, 6, m02_buf));
248 std::shared_ptr<NekMatrix<double>> m10(
249 new NekMatrix<double>(3, 4, m10_buf));
250 std::shared_ptr<NekMatrix<double>> m11(
251 new NekMatrix<double>(3, 5, m11_buf));
252 std::shared_ptr<NekMatrix<double>> m12(
253 new NekMatrix<double>(3, 6, m12_buf));
254
255 std::shared_ptr<InnerType> sm00(new InnerType(2.0, m00));
256 std::shared_ptr<InnerType> sm01(new InnerType(2.0, m01));
257 std::shared_ptr<InnerType> sm02(new InnerType(2.0, m02));
258 std::shared_ptr<InnerType> sm10(new InnerType(2.0, m10));
259 std::shared_ptr<InnerType> sm11(new InnerType(2.0, m11));
260 std::shared_ptr<InnerType> sm12(new InnerType(2.0, m12));
261
262 unsigned int rowCounts[] = {2, 3};
263 unsigned int colCounts[] = {4, 5, 6};
264
265 BlockType b(2, 3, rowCounts, colCounts);
266 b.SetBlock(0, 0, sm00);
267 b.SetBlock(0, 1, sm01);
268 b.SetBlock(0, 2, sm02);
269 b.SetBlock(1, 0, sm10);
270 b.SetBlock(1, 1, sm11);
271 b.SetBlock(1, 2, sm12);
272
273 BOOST_CHECK_EQUAL(2, b.GetNumberOfBlockRows());
274 BOOST_CHECK_EQUAL(3, b.GetNumberOfBlockColumns());
275 BOOST_CHECK_EQUAL(2, b.GetNumberOfRowsInBlockRow(0));
276 BOOST_CHECK_EQUAL(3, b.GetNumberOfRowsInBlockRow(1));
277 BOOST_CHECK_EQUAL(4, b.GetNumberOfColumnsInBlockColumn(0));
278 BOOST_CHECK_EQUAL(5, b.GetNumberOfColumnsInBlockColumn(1));
279 BOOST_CHECK_EQUAL(6, b.GetNumberOfColumnsInBlockColumn(2));
280
281 BOOST_CHECK_EQUAL(0, b.CalculateBlockIndex(0, 0));
282 BOOST_CHECK_EQUAL(1, b.CalculateBlockIndex(1, 0));
283 BOOST_CHECK_EQUAL(2, b.CalculateBlockIndex(0, 1));
284 BOOST_CHECK_EQUAL(3, b.CalculateBlockIndex(1, 1));
285 BOOST_CHECK_EQUAL(4, b.CalculateBlockIndex(0, 2));
286 BOOST_CHECK_EQUAL(5, b.CalculateBlockIndex(1, 2));
287
288 BOOST_CHECK_EQUAL(m00->GetRawPtr(), b.GetBlock(0, 0)->GetRawPtr());
289 BOOST_CHECK_EQUAL(m01->GetRawPtr(), b.GetBlock(0, 1)->GetRawPtr());
290 BOOST_CHECK_EQUAL(m02->GetRawPtr(), b.GetBlock(0, 2)->GetRawPtr());
291 BOOST_CHECK_EQUAL(m10->GetRawPtr(), b.GetBlock(1, 0)->GetRawPtr());
292 BOOST_CHECK_EQUAL(m11->GetRawPtr(), b.GetBlock(1, 1)->GetRawPtr());
293 BOOST_CHECK_EQUAL(m12->GetRawPtr(), b.GetBlock(1, 2)->GetRawPtr());
294
295 BOOST_CHECK_EQUAL('N', b.GetBlock(0, 0)->GetTransposeFlag());
296 BOOST_CHECK_EQUAL('N', b.GetBlock(0, 1)->GetTransposeFlag());
297 BOOST_CHECK_EQUAL('N', b.GetBlock(0, 2)->GetTransposeFlag());
298 BOOST_CHECK_EQUAL('N', b.GetBlock(1, 0)->GetTransposeFlag());
299 BOOST_CHECK_EQUAL('N', b.GetBlock(1, 1)->GetTransposeFlag());
300 BOOST_CHECK_EQUAL('N', b.GetBlock(1, 2)->GetTransposeFlag());
301
302 double v_buf[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
303 NekVector<double> v(15, v_buf);
304 NekVector<double> result = b * v;
305
306 BOOST_CHECK_EQUAL(5, result.GetRows());
307 BOOST_CHECK_EQUAL(2360 * 2, result[0]);
308 BOOST_CHECK_EQUAL(2480 * 2, result[1]);
309 BOOST_CHECK_EQUAL(7080 * 2, result[2]);
310 BOOST_CHECK_EQUAL(7200 * 2, result[3]);
311 BOOST_CHECK_EQUAL(7320 * 2, result[4]);
312
313 b.Transpose();
314
315 BOOST_CHECK_EQUAL(3, b.GetNumberOfBlockRows());
316 BOOST_CHECK_EQUAL(2, b.GetNumberOfBlockColumns());
317
318 BOOST_CHECK_EQUAL(2, b.GetNumberOfColumnsInBlockColumn(0));
319 BOOST_CHECK_EQUAL(3, b.GetNumberOfColumnsInBlockColumn(1));
320 BOOST_CHECK_EQUAL(4, b.GetNumberOfRowsInBlockRow(0));
321 BOOST_CHECK_EQUAL(5, b.GetNumberOfRowsInBlockRow(1));
322 BOOST_CHECK_EQUAL(6, b.GetNumberOfRowsInBlockRow(2));
323
324 BOOST_CHECK_EQUAL(0, b.CalculateBlockIndex(0, 0));
325 BOOST_CHECK_EQUAL(1, b.CalculateBlockIndex(0, 1));
326 BOOST_CHECK_EQUAL(2, b.CalculateBlockIndex(1, 0));
327 BOOST_CHECK_EQUAL(3, b.CalculateBlockIndex(1, 1));
328 BOOST_CHECK_EQUAL(4, b.CalculateBlockIndex(2, 0));
329 BOOST_CHECK_EQUAL(5, b.CalculateBlockIndex(2, 1));
330
331 BOOST_CHECK_EQUAL(m00->GetRawPtr(), b.GetBlock(0, 0)->GetRawPtr());
332 BOOST_CHECK_EQUAL(m01->GetRawPtr(), b.GetBlock(1, 0)->GetRawPtr());
333 BOOST_CHECK_EQUAL(m02->GetRawPtr(), b.GetBlock(2, 0)->GetRawPtr());
334 BOOST_CHECK_EQUAL(m10->GetRawPtr(), b.GetBlock(0, 1)->GetRawPtr());
335 BOOST_CHECK_EQUAL(m11->GetRawPtr(), b.GetBlock(1, 1)->GetRawPtr());
336 BOOST_CHECK_EQUAL(m12->GetRawPtr(), b.GetBlock(2, 1)->GetRawPtr());
337
338 BOOST_CHECK_EQUAL('T', b.GetBlock(0, 0)->GetTransposeFlag());
339 BOOST_CHECK_EQUAL('T', b.GetBlock(1, 0)->GetTransposeFlag());
340 BOOST_CHECK_EQUAL('T', b.GetBlock(2, 0)->GetTransposeFlag());
341 BOOST_CHECK_EQUAL('T', b.GetBlock(0, 1)->GetTransposeFlag());
342 BOOST_CHECK_EQUAL('T', b.GetBlock(1, 1)->GetTransposeFlag());
343 BOOST_CHECK_EQUAL('T', b.GetBlock(2, 1)->GetTransposeFlag());
344
345 double v_transpose_buf[] = {1, 2, 3, 4, 5};
346 NekVector<double> v_transpose(5, v_transpose_buf);
347 NekVector<double> result_transpose = b * v_transpose;
348
349 BOOST_CHECK_EQUAL(15, result_transpose.GetRows());
350 BOOST_CHECK_EQUAL(391 * 2, result_transpose[0]);
351 BOOST_CHECK_EQUAL(433 * 2, result_transpose[1]);
352 BOOST_CHECK_EQUAL(475 * 2, result_transpose[2]);
353 BOOST_CHECK_EQUAL(517 * 2, result_transpose[3]);
354 BOOST_CHECK_EQUAL(559 * 2, result_transpose[4]);
355 BOOST_CHECK_EQUAL(601 * 2, result_transpose[5]);
356 BOOST_CHECK_EQUAL(643 * 2, result_transpose[6]);
357 BOOST_CHECK_EQUAL(685 * 2, result_transpose[7]);
358 BOOST_CHECK_EQUAL(727 * 2, result_transpose[8]);
359 BOOST_CHECK_EQUAL(769 * 2, result_transpose[9]);
360 BOOST_CHECK_EQUAL(811 * 2, result_transpose[10]);
361 BOOST_CHECK_EQUAL(853 * 2, result_transpose[11]);
362 BOOST_CHECK_EQUAL(895 * 2, result_transpose[12]);
363 BOOST_CHECK_EQUAL(937 * 2, result_transpose[13]);
364 BOOST_CHECK_EQUAL(979 * 2, result_transpose[14]);
365}
366
367BOOST_AUTO_TEST_CASE(TestBlockBlockMatrixTranspose)
368{
369 typedef NekMatrix<double> Matrix;
370 typedef NekMatrix<Matrix, BlockMatrixTag> InnerMatrix;
371 typedef NekMatrix<InnerMatrix, BlockMatrixTag> BlockMatrix;
372
373 double m_00_buf[] = {1, 2, 3, 4, 5, 6};
374 double m_01_buf[] = {7, 8, 9, 10, 11, 12, 13, 14};
375 double m_10_buf[] = {15, 16, 17, 18, 19, 20};
376 double m_11_buf[] = {21, 22, 23, 24, 25, 26, 27, 28};
377 double m_20_buf[] = {29, 30, 31, 32, 33, 34};
378 double m_21_buf[] = {35, 36, 37, 38, 39, 40, 41, 42};
379 std::shared_ptr<Matrix> m00(new Matrix(2, 3, m_00_buf));
380 std::shared_ptr<Matrix> m01(new Matrix(2, 4, m_01_buf));
381 std::shared_ptr<Matrix> m10(new Matrix(2, 3, m_10_buf));
382 std::shared_ptr<Matrix> m11(new Matrix(2, 4, m_11_buf));
383 std::shared_ptr<Matrix> m20(new Matrix(2, 3, m_20_buf));
384 std::shared_ptr<Matrix> m21(new Matrix(2, 4, m_21_buf));
385
386 unsigned int rowCounts[] = {2, 2, 2};
387 unsigned int colCounts[] = {3, 4};
388
389 std::vector<std::shared_ptr<InnerMatrix>> innerMatrices;
390
391 for (int i = 0; i < 6; ++i)
392 {
393 std::shared_ptr<Matrix> t00(new Matrix(*m00));
394 std::shared_ptr<Matrix> t01(new Matrix(*m01));
395 std::shared_ptr<Matrix> t10(new Matrix(*m10));
396 std::shared_ptr<Matrix> t11(new Matrix(*m11));
397 std::shared_ptr<Matrix> t20(new Matrix(*m20));
398 std::shared_ptr<Matrix> t21(new Matrix(*m21));
399
400 (*t00) *= (i + 1);
401 (*t01) *= (i + 1);
402 (*t10) *= (i + 1);
403 (*t11) *= (i + 1);
404 (*t20) *= (i + 1);
405 (*t21) *= (i + 1);
406
407 std::shared_ptr<InnerMatrix> matrix(
408 new InnerMatrix(3, 2, rowCounts, colCounts));
409 matrix->SetBlock(0, 0, t00);
410 matrix->SetBlock(0, 1, t01);
411 matrix->SetBlock(1, 0, t10);
412 matrix->SetBlock(1, 1, t11);
413 matrix->SetBlock(2, 0, t20);
414 matrix->SetBlock(2, 1, t21);
415
416 innerMatrices.push_back(matrix);
417 }
418
419 unsigned int topLevelRowCounts[] = {6, 6};
420 unsigned int topLevelColumnCounts[] = {7, 7, 7};
421 BlockMatrix topLevelMatrix(2, 3, topLevelRowCounts, topLevelColumnCounts);
422 topLevelMatrix.SetBlock(0, 0, innerMatrices[0]);
423 topLevelMatrix.SetBlock(0, 1, innerMatrices[1]);
424 topLevelMatrix.SetBlock(0, 2, innerMatrices[2]);
425 topLevelMatrix.SetBlock(1, 0, innerMatrices[3]);
426 topLevelMatrix.SetBlock(1, 1, innerMatrices[4]);
427 topLevelMatrix.SetBlock(1, 2, innerMatrices[5]);
428
429 double v_buf[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
430 12, 13, 14, 15, 16, 17, 18, 19, 20, 21};
431 NekVector<double> v(21, v_buf);
432
433 NekVector<double> result = topLevelMatrix * v;
434
435 double expected_result_buf[] = {4256, 4816, 12096, 12656, 19936, 20496,
436 9611, 10864, 27153, 28406, 44695, 45948};
437 NekVector<double> expected_result(12, expected_result_buf);
438
439 BOOST_CHECK_EQUAL(expected_result, result);
440
441 topLevelMatrix.Transpose();
442
443 double transposed_v_buf[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
444 NekVector<double> transposed_v(12, transposed_v_buf);
445 NekVector<double> transposed_result = topLevelMatrix * transposed_v;
446
447 double expected_transpose_result_buf[] = {
448 4427, 4925, 5423, 5921, 6419, 6917, 7415, 5863, 6517, 7171, 7825,
449 8479, 9133, 9787, 7299, 8109, 8919, 9729, 10539, 11349, 12159};
450 NekVector<double> expected_transpose_result(21,
451 expected_transpose_result_buf);
452
453 BOOST_CHECK_EQUAL(expected_transpose_result, transposed_result);
454}
455
456BOOST_AUTO_TEST_CASE(TestBlockBlockScaledMatrixTranspose)
457{
458 typedef NekMatrix<double> Matrix;
459 typedef NekMatrix<NekMatrix<double>, ScaledMatrixTag> ScaledMatrix;
460 typedef NekMatrix<ScaledMatrix, BlockMatrixTag> InnerMatrix;
461 typedef NekMatrix<InnerMatrix, BlockMatrixTag> BlockMatrix;
462
463 double m_00_buf[] = {1, 2, 3, 4, 5, 6};
464 double m_01_buf[] = {7, 8, 9, 10, 11, 12, 13, 14};
465 double m_10_buf[] = {15, 16, 17, 18, 19, 20};
466 double m_11_buf[] = {21, 22, 23, 24, 25, 26, 27, 28};
467 double m_20_buf[] = {29, 30, 31, 32, 33, 34};
468 double m_21_buf[] = {35, 36, 37, 38, 39, 40, 41, 42};
469 std::shared_ptr<Matrix> m00(new Matrix(2, 3, m_00_buf));
470 std::shared_ptr<Matrix> m01(new Matrix(2, 4, m_01_buf));
471 std::shared_ptr<Matrix> m10(new Matrix(2, 3, m_10_buf));
472 std::shared_ptr<Matrix> m11(new Matrix(2, 4, m_11_buf));
473 std::shared_ptr<Matrix> m20(new Matrix(2, 3, m_20_buf));
474 std::shared_ptr<Matrix> m21(new Matrix(2, 4, m_21_buf));
475
476 unsigned int rowCounts[] = {2, 2, 2};
477 unsigned int colCounts[] = {3, 4};
478
479 std::vector<std::shared_ptr<InnerMatrix>> innerMatrices;
480
481 for (int i = 0; i < 6; ++i)
482 {
483 std::shared_ptr<Matrix> t00(new Matrix(*m00));
484 std::shared_ptr<Matrix> t01(new Matrix(*m01));
485 std::shared_ptr<Matrix> t10(new Matrix(*m10));
486 std::shared_ptr<Matrix> t11(new Matrix(*m11));
487 std::shared_ptr<Matrix> t20(new Matrix(*m20));
488 std::shared_ptr<Matrix> t21(new Matrix(*m21));
489
490 std::shared_ptr<ScaledMatrix> s00(new ScaledMatrix(i + 1, t00));
491 std::shared_ptr<ScaledMatrix> s01(new ScaledMatrix(i + 1, t01));
492 std::shared_ptr<ScaledMatrix> s10(new ScaledMatrix(i + 1, t10));
493 std::shared_ptr<ScaledMatrix> s11(new ScaledMatrix(i + 1, t11));
494 std::shared_ptr<ScaledMatrix> s20(new ScaledMatrix(i + 1, t20));
495 std::shared_ptr<ScaledMatrix> s21(new ScaledMatrix(i + 1, t21));
496
497 std::shared_ptr<InnerMatrix> matrix(
498 new InnerMatrix(3, 2, rowCounts, colCounts));
499 matrix->SetBlock(0, 0, s00);
500 matrix->SetBlock(0, 1, s01);
501 matrix->SetBlock(1, 0, s10);
502 matrix->SetBlock(1, 1, s11);
503 matrix->SetBlock(2, 0, s20);
504 matrix->SetBlock(2, 1, s21);
505
506 innerMatrices.push_back(matrix);
507 }
508
509 unsigned int topLevelRowCounts[] = {6, 6};
510 unsigned int topLevelColumnCounts[] = {7, 7, 7};
511 BlockMatrix topLevelMatrix(2, 3, topLevelRowCounts, topLevelColumnCounts);
512 topLevelMatrix.SetBlock(0, 0, innerMatrices[0]);
513 topLevelMatrix.SetBlock(0, 1, innerMatrices[1]);
514 topLevelMatrix.SetBlock(0, 2, innerMatrices[2]);
515 topLevelMatrix.SetBlock(1, 0, innerMatrices[3]);
516 topLevelMatrix.SetBlock(1, 1, innerMatrices[4]);
517 topLevelMatrix.SetBlock(1, 2, innerMatrices[5]);
518
519 double v_buf[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
520 12, 13, 14, 15, 16, 17, 18, 19, 20, 21};
521 NekVector<double> v(21, v_buf);
522
523 NekVector<double> result = topLevelMatrix * v;
524
525 double expected_result_buf[] = {4256, 4816, 12096, 12656, 19936, 20496,
526 9611, 10864, 27153, 28406, 44695, 45948};
527 NekVector<double> expected_result(12, expected_result_buf);
528
529 BOOST_CHECK_EQUAL(expected_result, result);
530
531 topLevelMatrix.Transpose();
532
533 double transposed_v_buf[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
534 NekVector<double> transposed_v(12, transposed_v_buf);
535 NekVector<double> transposed_result = topLevelMatrix * transposed_v;
536
537 double expected_transpose_result_buf[] = {
538 4427, 4925, 5423, 5921, 6419, 6917, 7415, 5863, 6517, 7171, 7825,
539 8479, 9133, 9787, 7299, 8109, 8919, 9729, 10539, 11349, 12159};
540 NekVector<double> expected_transpose_result(21,
541 expected_transpose_result_buf);
542
543 BOOST_CHECK_EQUAL(expected_transpose_result, transposed_result);
544}
545
546BOOST_AUTO_TEST_CASE(TestMultiplicationBlock_1)
547{
548 typedef NekMatrix<double> InnerType;
549 typedef NekMatrix<InnerType, BlockMatrixTag> BlockType;
550
551 double m_00_buf[] = {3, 1, 5, 5};
552 double m_01_buf[] = {2, 4, 4, 1, 1, 3};
553 double m_02_buf[] = {3, 1, 2, 2, 4, 1, 4, 2};
554
555 double m_10_buf[] = {1, 3, 5, 1, 4, 2};
556 double m_11_buf[] = {4, 4, 1, 1, 1, 4, 5, 5, 3};
557 double m_12_buf[] = {5, 2, 1, 2, 3, 1, 1, 3, 1, 4, 1, 1};
558
559 double m_20_buf[] = {3, 1, 4, 2, 5, 1, 4, 2};
560 double m_21_buf[] = {4, 5, 2, 4, 4, 2, 3, 5, 2, 2, 5, 3};
561 double m_22_buf[] = {3, 4, 3, 1, 2, 1, 2, 4, 4, 5, 2, 3, 5, 4, 1, 1};
562
563 double m_30_buf[] = {2, 2, 1, 4, 5, 5};
564 double m_31_buf[] = {1, 1, 3, 2, 1, 2, 3, 3, 2};
565 double m_32_buf[] = {3, 1, 3, 1, 2, 2, 4, 2, 5, 5, 1, 1};
566
567 std::shared_ptr<InnerType> m00(new InnerType(2, 2, m_00_buf));
568 std::shared_ptr<InnerType> m01(new InnerType(2, 3, m_01_buf));
569 std::shared_ptr<InnerType> m02(new InnerType(2, 4, m_02_buf));
570
571 std::shared_ptr<InnerType> m10(new InnerType(3, 2, m_10_buf));
572 std::shared_ptr<InnerType> m11(new InnerType(3, 3, m_11_buf));
573 std::shared_ptr<InnerType> m12(new InnerType(3, 4, m_12_buf));
574
575 std::shared_ptr<InnerType> m20(new InnerType(4, 2, m_20_buf));
576 std::shared_ptr<InnerType> m21(new InnerType(4, 3, m_21_buf));
577 std::shared_ptr<InnerType> m22(new InnerType(4, 4, m_22_buf));
578
579 std::shared_ptr<InnerType> m30(new InnerType(3, 2, m_30_buf));
580 std::shared_ptr<InnerType> m31(new InnerType(3, 3, m_31_buf));
581 std::shared_ptr<InnerType> m32(new InnerType(3, 4, m_32_buf));
582
583 unsigned int rowCounts[] = {2, 3, 4, 3};
584 unsigned int colCounts[] = {2, 3, 4};
585
586 BlockType b(4, 3, rowCounts, colCounts);
587 b.SetBlock(0, 0, m00);
588 b.SetBlock(0, 1, m01);
589 b.SetBlock(0, 2, m02);
590 b.SetBlock(1, 0, m10);
591 b.SetBlock(1, 1, m11);
592 b.SetBlock(1, 2, m12);
593 b.SetBlock(2, 0, m20);
594 b.SetBlock(2, 1, m21);
595 b.SetBlock(2, 2, m22);
596 b.SetBlock(3, 0, m30);
597 b.SetBlock(3, 1, m31);
598 b.SetBlock(3, 2, m32);
599
600 Array<OneD, unsigned int> arrayRowCounts(4, rowCounts);
601 Array<OneD, unsigned int> arrayColCounts(3, colCounts);
602 BlockType b_initializedWithArray(arrayRowCounts, arrayColCounts);
603 b_initializedWithArray.SetBlock(0, 0, m00);
604 b_initializedWithArray.SetBlock(0, 1, m01);
605 b_initializedWithArray.SetBlock(0, 2, m02);
606 b_initializedWithArray.SetBlock(1, 0, m10);
607 b_initializedWithArray.SetBlock(1, 1, m11);
608 b_initializedWithArray.SetBlock(1, 2, m12);
609 b_initializedWithArray.SetBlock(2, 0, m20);
610 b_initializedWithArray.SetBlock(2, 1, m21);
611 b_initializedWithArray.SetBlock(2, 2, m22);
612 b_initializedWithArray.SetBlock(3, 0, m30);
613 b_initializedWithArray.SetBlock(3, 1, m31);
614 b_initializedWithArray.SetBlock(3, 2, m32);
615
616 double rhs_buf[] = {4, 2, 5, 5, 3, 1, 3, 2, 3};
617 NekVector<double> rhs(9, rhs_buf);
618
619 NekVector<double> result = b * rhs;
620 NekVector<double> result1 = b_initializedWithArray * rhs;
621
622 double expected_buf[] = {84, 63, 71, 80, 67, 100, 76, 80, 88, 69, 51, 67};
623 NekVector<double> expected_result(12, expected_buf);
624
625 BOOST_CHECK_EQUAL(expected_result, result);
626 BOOST_CHECK_EQUAL(expected_result, result1);
627}
628
629BOOST_AUTO_TEST_CASE(TestDiagonalBlockMatrixMultiplication)
630{
631 typedef NekMatrix<double> InnerType;
632 typedef NekMatrix<InnerType, BlockMatrixTag> BlockType;
633
634 double m_00_buf[] = {1, 3, 2, 4};
635 double m_11_buf[] = {1, 4, 2, 5, 3, 6};
636 double m_22_buf[] = {1, 3, 5, 2, 4, 6};
637
638 std::shared_ptr<InnerType> m00(new InnerType(2, 2, m_00_buf));
639 std::shared_ptr<InnerType> m11(new InnerType(2, 3, m_11_buf));
640 std::shared_ptr<InnerType> m22(new InnerType(3, 2, m_22_buf));
641
642 unsigned int rowCounts[] = {2, 2, 3};
643 unsigned int colCounts[] = {2, 3, 2};
644
645 BlockType b(3, 3, rowCounts, colCounts, eDIAGONAL);
646 b.SetBlock(0, 0, m00);
647 b.SetBlock(1, 1, m11);
648 b.SetBlock(2, 2, m22);
649
650 double rhs_buf[] = {1, 2, 3, 4, 5, 6, 7};
651 NekVector<double> rhs(7, rhs_buf);
652
653 NekVector<double> result = b * rhs;
654
655 double expected_buf[] = {5, 11, 26, 62, 20, 46, 72};
656 NekVector<double> expected_result(7, expected_buf);
657
658 BOOST_CHECK_EQUAL(expected_result, result);
659}
660
661BOOST_AUTO_TEST_CASE(TestDiagonalBlockMatrixMultiplicationWith0SizeBlocks)
662{
663 typedef NekMatrix<double> InnerType;
664 typedef NekMatrix<InnerType, BlockMatrixTag> BlockType;
665
666 double m_22_buf[] = {1, 2, 3, 4, 5, 6, 7, 8};
667
668 std::shared_ptr<InnerType> m22(new InnerType(1, 8, m_22_buf));
669
670 unsigned int rowCounts[] = {0, 0, 1};
671 unsigned int colCounts[] = {6, 6, 8};
672
673 BlockType b(3, 3, rowCounts, colCounts, eDIAGONAL);
674 b.SetBlock(2, 2, m22);
675
676 double rhs_buf[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
677 0, 0, 1, 2, 3, 4, 5, 6, 7, 8};
678 NekVector<double> rhs(20, rhs_buf);
679
680 NekVector<double> result = b * rhs;
681
682 double expected_buf[] = {1 * 1 + 2 * 2 + 3 * 3 + 4 * 4 + 5 * 5 + 6 * 6 +
683 7 * 7 + 8 * 8};
684 NekVector<double> expected_result(1, expected_buf);
685
686 BOOST_CHECK_EQUAL(expected_result, result);
687}
688
689BOOST_AUTO_TEST_CASE(TestBlockMatrixMultiplicationWith0SizeBlocks)
690{
691 typedef NekMatrix<double> InnerType;
692 typedef NekMatrix<InnerType, BlockMatrixTag> BlockType;
693
694 double m_22_buf[] = {1, 2, 3, 4, 5, 6, 7, 8};
695
696 std::shared_ptr<InnerType> m22(new InnerType(1, 8, m_22_buf));
697
698 unsigned int rowCounts[] = {0, 0, 1};
699 unsigned int colCounts[] = {6, 6, 8};
700
701 BlockType b(3, 3, rowCounts, colCounts, eFULL);
702 b.SetBlock(2, 2, m22);
703
704 double rhs_buf[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
705 0, 0, 1, 2, 3, 4, 5, 6, 7, 8};
706 NekVector<double> rhs(20, rhs_buf);
707
708 NekVector<double> result = b * rhs;
709
710 double expected_buf[] = {1 * 1 + 2 * 2 + 3 * 3 + 4 * 4 + 5 * 5 + 6 * 6 +
711 7 * 7 + 8 * 8};
712 NekVector<double> expected_result(1, expected_buf);
713
714 BOOST_CHECK_EQUAL(expected_result, result);
715}
716
717BOOST_AUTO_TEST_CASE(TestBlockMatrixErrorFrom6_10)
718{
719
720 // Array<OneD, NekDouble> f_bnd(m_BCinv->GetRows());
721 // NekVector< NekDouble > F_bnd(f_bnd.size(), f_bnd, eWrapper);
722
723 // Array<OneD, NekDouble> f_int(m_BCinv->GetColumns());
724 // NekVector< NekDouble > F_int(f_int.size(),f_int, eWrapper);
725
726 // Array<OneD, NekDouble > f_p(m_D_int->GetRows());
727 // NekVector< NekDouble > F_p(f_p.size(),f_p,eWrapper);
728
729 // typedef NekMatrix<DNekScalBlkMat, BlockMatrixTag> BlkMatDNekScalBlkMat;
730 // typedef std::shared_ptr<BlkMatDNekScalBlkMat>
731 // BlkMatDNekScalBlkMatSharedPtr;
732
733 // BlkMatDNekScalBlkMatSharedPtr m_Btilde =
734 // MemoryManager<BlkMatDNekScalBlkMat>
735 // ::AllocateSharedPtr(nsize_int,nsize_bndry,blkmatStorage);
736 // BlkMatDNekScalBlkMatSharedPtr m_Cinv =
737 // MemoryManager<BlkMatDNekScalBlkMat>
738 // ::AllocateSharedPtr(nsize_int,nsize_int,eFull);
739
740 typedef NekMatrix<double> M1;
741 typedef NekMatrix<M1, ScaledMatrixTag> M2;
742 typedef NekMatrix<M2, BlockMatrixTag> M3;
743 typedef NekMatrix<M3, BlockMatrixTag> M4;
744
745 std::vector<std::shared_ptr<M2>> scaledMatrices;
746 for (unsigned int i = 0; i < 36; ++i)
747 {
748 double values[] = {i * 4.0, i * 4.0 + 1.0, i * 4.0 + 2.0,
749 i * 4.0 + 3.0};
750 std::shared_ptr<M1> matrix(new M1(2, 2, values));
751 std::shared_ptr<M2> scaled(new M2(1.0, matrix));
752 scaledMatrices.push_back(scaled);
753 }
754
755 std::vector<std::shared_ptr<M3>> blockMatrices;
756 for (unsigned int i = 0; i < 6; ++i)
757 {
758 std::shared_ptr<M3> blockMatrix(new M3(2, 3, 2, 2));
759 blockMatrix->SetBlock(0, 0, scaledMatrices[i * 6]);
760 blockMatrix->SetBlock(0, 1, scaledMatrices[i * 6 + 1]);
761 blockMatrix->SetBlock(0, 2, scaledMatrices[i * 6 + 2]);
762 blockMatrix->SetBlock(1, 0, scaledMatrices[i * 6 + 3]);
763 blockMatrix->SetBlock(1, 1, scaledMatrices[i * 6 + 4]);
764 blockMatrix->SetBlock(1, 2, scaledMatrices[i * 6 + 5]);
765 blockMatrices.push_back(blockMatrix);
766 }
767
768 std::shared_ptr<M4> matrix(new M4(3, 2, 4, 6));
769 matrix->SetBlock(0, 0, blockMatrices[0]);
770 matrix->SetBlock(0, 1, blockMatrices[1]);
771 matrix->SetBlock(1, 0, blockMatrices[2]);
772 matrix->SetBlock(1, 1, blockMatrices[3]);
773 matrix->SetBlock(2, 0, blockMatrices[4]);
774 matrix->SetBlock(2, 1, blockMatrices[5]);
775
776 double b_buf[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
777 NekVector<double> b(12, b_buf);
778
779 {
780 NekVector<double> result = (*matrix) * b;
781
782 double expected_buf[] = {1828, 1906, 2764, 2842, 5572, 5650,
783 6508, 6586, 9316, 9394, 10252, 10330};
784 NekVector<double> expected_result(12, expected_buf);
785 BOOST_CHECK_EQUAL(result, expected_result);
786 }
787
788 {
789 NekVector<double> result = b - (*matrix) * b;
790
791 double expected_buf[] = {-1827, -1904, -2761, -2838, -5567, -5644,
792 -6501, -6578, -9307, -9384, -10241, -10318};
793
794 NekVector<double> expected_result(12, expected_buf);
795 BOOST_CHECK_EQUAL(expected_result, result);
796 }
797
798 {
799 NekVector<double> result = b;
800 result = result - (*matrix) * b;
801
802 double expected_buf[] = {-1827, -1904, -2761, -2838, -5567, -5644,
803 -6501, -6578, -9307, -9384, -10241, -10318};
804
805 NekVector<double> expected_result(12, expected_buf);
806 BOOST_CHECK_EQUAL(expected_result, result);
807 }
808
809 //#if 0
810 // F_int = (F_int - (*m_Btilde)*F_bnd);
811 //#else
812 // for(i = 0; i < m_Btilde->GetRows(); ++i)
813 // {
814 // for(j = 0; j < m_Btilde->GetColumns(); ++j)
815 // {
816 // F_int[i] -= (*m_Btilde)(i,j)*F_bnd[j];
817 // }
818 // }
819 //#endif
820 //
821 // F_int = (F_int + Transpose(*m_D_int)*F_p);
822 //
823 //#if 0
824 // F_int = (*m_Cinv)*F_int;
825 //#else
826 // Array<OneD, NekDouble> ftmp(F_int.GetDimension(),0.0);
827 // for(i = 0; i < m_Cinv->GetRows(); ++i)
828 // {
829 // for(j = 0; j < m_Cinv->GetColumns(); ++j)
830 // {
831 // ftmp[i] += (*m_Cinv)(i,j)*F_int[j];
832 // }
833 // }
834 // for(i = 0; i < ftmp.size(); ++i)
835 // {
836 // F_int[i] = ftmp[i];
837 // }
838 //#endif
839}
840
841} // namespace BlockMatrixUnitTests
842} // namespace Nektar
Nektar::NekVector::GetRows
unsigned int GetRows() const
Definition: NekVector.cpp:206
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
Nektar::BlockMatrix
NekMatrix< DenseMatrix, BlockMatrixTag > BlockMatrix
Definition: NekTypeDefs.hpp:59
Nektar::ScaledMatrix
NekMatrix< DenseMatrix, ScaledMatrixTag > ScaledMatrix
Definition: NekTypeDefs.hpp:55
Nektar::Transpose
NekMatrix< InnerMatrixType, BlockMatrixTag > Transpose(NekMatrix< InnerMatrixType, BlockMatrixTag > &rhs)
Definition: BlockMatrix.hpp:235
Generated on Wed Jan 31 2024 08:26:49 for Nektar++ by doxygen 1.9.4