Nektar++
TestScaledBlockMatrixOperations.cpp
Go to the documentation of this file.
1///////////////////////////////////////////////////////////////////////////////
2//
3// File: TestScaledBlockMatrixOperations.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
39
40#include <boost/test/tools/floating_point_comparison.hpp>
41#include <boost/test/unit_test.hpp>
42
44{
45BOOST_AUTO_TEST_CASE(TestMatrixVectorMultiplication)
46{
47 typedef NekMatrix<double> InnerType;
49
50 double m1_buf[] = {1.0 / 2.0, 6.0 / 2.0, 2.0 / 2.0,
51 7.0 / 2.0, 3.0 / 2.0, 8.0 / 2.0};
52 double m2_buf[] = {4.0 / 2.0, 9.0 / 2.0, 5.0 / 2.0, 10.0 / 2.0};
53 double m3_buf[] = {11.0 / 2.0, 16.0 / 2.0, 12.0 / 2.0,
54 17.0 / 2.0, 13.0 / 2.0, 18 / 2.0};
55 double m4_buf[] = {14.0 / 2.0, 19.0 / 2.0, 15.0 / 2.0, 20.0 / 2.0};
56
57 std::shared_ptr<InnerType> in_m1(new InnerType(2, 3, m1_buf));
58 std::shared_ptr<InnerType> in_m2(new InnerType(2, 2, m2_buf));
59 std::shared_ptr<InnerType> in_m3(new InnerType(2, 3, m3_buf));
60 std::shared_ptr<InnerType> in_m4(new InnerType(2, 2, m4_buf));
61
62 std::shared_ptr<ScaleType> m1(new ScaleType(2.0, in_m1));
63 std::shared_ptr<ScaleType> m2(new ScaleType(2.0, in_m2));
64 std::shared_ptr<ScaleType> m3(new ScaleType(2.0, in_m3));
65 std::shared_ptr<ScaleType> m4(new ScaleType(2.0, in_m4));
66
67 unsigned int rowCounts[] = {2, 2};
68 unsigned int colCounts[] = {3, 2};
69
71
72 std::shared_ptr<BlockType> b(new BlockType(2, 2, rowCounts, colCounts));
73 b->SetBlock(0, 0, m1);
74 b->SetBlock(0, 1, m2);
75 b->SetBlock(1, 0, m3);
76 b->SetBlock(1, 1, m4);
77
78 double rhs_buf[] = {10, 20, 30, 40, 50};
79 NekVector<double> rhs(5, rhs_buf);
80
81 NekVector<double> result = (*b) * rhs;
82
83 double expected_buf[] = {550, 1300, 2050, 2800};
84 NekVector<double> expected_result(4, expected_buf);
85
86 BOOST_CHECK_EQUAL(expected_result, result);
87}
88
89BOOST_AUTO_TEST_CASE(TestMultiplicationScaledBlock_1)
90{
91 typedef NekMatrix<double> InnerType;
93
94 double m_00_buf[] = {3, 1, 5, 5};
95 double m_01_buf[] = {2, 4, 4, 1, 1, 3};
96 double m_02_buf[] = {3, 1, 2, 2, 4, 1, 4, 2};
97
98 double m_10_buf[] = {1, 3, 5, 1, 4, 2};
99 double m_11_buf[] = {4, 4, 1, 1, 1, 4, 5, 5, 3};
100 double m_12_buf[] = {5, 2, 1, 2, 3, 1, 1, 3, 1, 4, 1, 1};
101
102 double m_20_buf[] = {3, 1, 4, 2, 5, 1, 4, 2};
103 double m_21_buf[] = {4, 5, 2, 4, 4, 2, 3, 5, 2, 2, 5, 3};
104 double m_22_buf[] = {3, 4, 3, 1, 2, 1, 2, 4, 4, 5, 2, 3, 5, 4, 1, 1};
105
106 double m_30_buf[] = {2, 2, 1, 4, 5, 5};
107 double m_31_buf[] = {1, 1, 3, 2, 1, 2, 3, 3, 2};
108 double m_32_buf[] = {3, 1, 3, 1, 2, 2, 4, 2, 5, 5, 1, 1};
109
110 std::shared_ptr<InnerType> m00(new InnerType(2, 2, m_00_buf));
111 std::shared_ptr<InnerType> m01(new InnerType(2, 3, m_01_buf));
112 std::shared_ptr<InnerType> m02(new InnerType(2, 4, m_02_buf));
113
114 std::shared_ptr<InnerType> m10(new InnerType(3, 2, m_10_buf));
115 std::shared_ptr<InnerType> m11(new InnerType(3, 3, m_11_buf));
116 std::shared_ptr<InnerType> m12(new InnerType(3, 4, m_12_buf));
117
118 std::shared_ptr<InnerType> m20(new InnerType(4, 2, m_20_buf));
119 std::shared_ptr<InnerType> m21(new InnerType(4, 3, m_21_buf));
120 std::shared_ptr<InnerType> m22(new InnerType(4, 4, m_22_buf));
121
122 std::shared_ptr<InnerType> m30(new InnerType(3, 2, m_30_buf));
123 std::shared_ptr<InnerType> m31(new InnerType(3, 3, m_31_buf));
124 std::shared_ptr<InnerType> m32(new InnerType(3, 4, m_32_buf));
125
126 unsigned int rowCounts[] = {2, 3, 4, 3};
127 unsigned int colCounts[] = {2, 3, 4};
128
129 BlockType b(4, 3, rowCounts, colCounts);
130 b.SetBlock(0, 0, m00);
131 b.SetBlock(0, 1, m01);
132 b.SetBlock(0, 2, m02);
133 b.SetBlock(1, 0, m10);
134 b.SetBlock(1, 1, m11);
135 b.SetBlock(1, 2, m12);
136 b.SetBlock(2, 0, m20);
137 b.SetBlock(2, 1, m21);
138 b.SetBlock(2, 2, m22);
139 b.SetBlock(3, 0, m30);
140 b.SetBlock(3, 1, m31);
141 b.SetBlock(3, 2, m32);
142
143 Array<OneD, unsigned int> arrayRowCounts(4, rowCounts);
144 Array<OneD, unsigned int> arrayColCounts(3, colCounts);
145 BlockType b_initializedWithArray(arrayRowCounts, arrayColCounts);
146 b_initializedWithArray.SetBlock(0, 0, m00);
147 b_initializedWithArray.SetBlock(0, 1, m01);
148 b_initializedWithArray.SetBlock(0, 2, m02);
149 b_initializedWithArray.SetBlock(1, 0, m10);
150 b_initializedWithArray.SetBlock(1, 1, m11);
151 b_initializedWithArray.SetBlock(1, 2, m12);
152 b_initializedWithArray.SetBlock(2, 0, m20);
153 b_initializedWithArray.SetBlock(2, 1, m21);
154 b_initializedWithArray.SetBlock(2, 2, m22);
155 b_initializedWithArray.SetBlock(3, 0, m30);
156 b_initializedWithArray.SetBlock(3, 1, m31);
157 b_initializedWithArray.SetBlock(3, 2, m32);
158
159 double rhs_buf[] = {4, 2, 5, 5, 3, 1, 3, 2, 3};
160 NekVector<double> rhs(9, rhs_buf);
161
162 NekVector<double> result = b * rhs;
163 NekVector<double> result1 = b_initializedWithArray * rhs;
164
165 double expected_buf[] = {84, 63, 71, 80, 67, 100, 76, 80, 88, 69, 51, 67};
166 NekVector<double> expected_result(12, expected_buf);
167
168 BOOST_CHECK_EQUAL(expected_result, result);
169 BOOST_CHECK_EQUAL(expected_result, result1);
170}
171} // namespace Nektar::ScaledBlockMatrixUnitTests
BOOST_AUTO_TEST_CASE(TestMatrixVectorMultiplication)