Nektar++
Functions
Nektar::FullMatrixOperationsUnitTests Namespace Reference

Functions

template<typename DataType , typename MatrixType >
int foo (NekMatrix< DataType, MatrixType > &d)
 
template<typename DataType >
int foo (NekMatrix< DataType, BlockMatrixTag > &d)
 
 BOOST_AUTO_TEST_CASE (TestDoubleSquareFullVectorMultiplication)
 
 BOOST_AUTO_TEST_CASE (TestDoubleSquareFullVectorMultiplicationWithAliasing)
 
 BOOST_AUTO_TEST_CASE (TestDoubleSquareFullVectorMultiplicationWithSharedArrayAliasing)
 
 BOOST_AUTO_TEST_CASE (TestDoubleSquareFullVectorMultiplicationWithSharedArrayAliasingAndMatrixTranspose)
 
 BOOST_AUTO_TEST_CASE (TestDoubleSquareFullVectorMultiplicationWithSharedArrayAliasingAndOverlap)
 
 BOOST_AUTO_TEST_CASE (TestScaledDoubleSquareFullVectorMultiplication)
 
 BOOST_AUTO_TEST_CASE (TestThreeMatrixMultiplication)
 
 BOOST_AUTO_TEST_CASE (TestThreeMatrixMultiplicationWithTranspose)
 
 BOOST_AUTO_TEST_CASE (TestThreeWrappedMatrixMultiplicationWithTranspose)
 

Function Documentation

◆ BOOST_AUTO_TEST_CASE() [1/9]

Nektar::FullMatrixOperationsUnitTests::BOOST_AUTO_TEST_CASE ( TestDoubleSquareFullVectorMultiplication  )

Definition at line 61 of file TestFullMatrixOperations.cpp.

62{
63 NekMatrix<double> m1;
64 NekMatrix<NekMatrix<double>, BlockMatrixTag> m2(2, 2, 2, 2);
65 foo(m1);
66 foo(m2);
67 double m_buf[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
68 double v_buf[] = {4, 5, 6};
69
70 NekMatrix<double> m(3, 3, m_buf);
71 NekVector<double> v(3, v_buf);
72
73 double expected_result_buf[] = {66, 81, 96};
74 NekVector<double> expected_result(3, expected_result_buf);
75
76 NekVector<double> result = m * v;
77
78 BOOST_CHECK_EQUAL(expected_result, result);
79}
Nektar::FullMatrixOperationsUnitTests::foo
int foo(NekMatrix< DataType, BlockMatrixTag > &d)
Definition: TestFullMatrixOperations.cpp:55

References foo().

◆ BOOST_AUTO_TEST_CASE() [2/9]

Nektar::FullMatrixOperationsUnitTests::BOOST_AUTO_TEST_CASE ( TestDoubleSquareFullVectorMultiplicationWithAliasing  )

Definition at line 81 of file TestFullMatrixOperations.cpp.

82{
83 double m_buf[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
84 double v_buf[] = {4, 5, 6};
85
86 NekMatrix<double> m(3, 3, m_buf);
87 NekVector<double> v(3, v_buf);
88
89 double expected_result_buf[] = {66, 81, 96};
90 NekVector<double> expected_result(3, expected_result_buf);
91
92 v = m * v;
93
94 BOOST_CHECK_EQUAL(expected_result, v);
95}

◆ BOOST_AUTO_TEST_CASE() [3/9]

Nektar::FullMatrixOperationsUnitTests::BOOST_AUTO_TEST_CASE ( TestDoubleSquareFullVectorMultiplicationWithSharedArrayAliasing  )

Definition at line 97 of file TestFullMatrixOperations.cpp.

99{
100 double m_buf[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
101 double v_buf[] = {4, 5, 6};
102
103 Array<OneD, double> vector_array(3, v_buf);
104
105 NekMatrix<double> m(3, 3, m_buf);
106 NekVector<double> v(3, vector_array, eWrapper);
107 NekVector<double> result(3, vector_array, eWrapper);
108
109 double expected_result_buf[] = {66, 81, 96};
110 NekVector<double> expected_result(3, expected_result_buf);
111
112 result = m * v;
113
114 BOOST_CHECK_EQUAL(expected_result, result);
115 BOOST_CHECK_EQUAL(vector_array[0], 66);
116 BOOST_CHECK_EQUAL(vector_array[1], 81);
117 BOOST_CHECK_EQUAL(vector_array[2], 96);
118}

References Nektar::eWrapper.

◆ BOOST_AUTO_TEST_CASE() [4/9]

Nektar::FullMatrixOperationsUnitTests::BOOST_AUTO_TEST_CASE ( TestDoubleSquareFullVectorMultiplicationWithSharedArrayAliasingAndMatrixTranspose  )

Definition at line 120 of file TestFullMatrixOperations.cpp.

122{
123 double m_buf[] = {1, 4, 7, 2, 5, 8, 3, 6, 9};
124 double v_buf[] = {4, 5, 6};
125
126 Array<OneD, double> vector_array(3, v_buf);
127
128 NekMatrix<double> m(3, 3, m_buf);
129 NekVector<double> v(3, vector_array, eWrapper);
130 NekVector<double> result(3, vector_array, eWrapper);
131
132 double expected_result_buf[] = {66, 81, 96};
133 NekVector<double> expected_result(3, expected_result_buf);
134
135 result = Transpose(m) * v;
136
137 BOOST_CHECK_EQUAL(expected_result, result);
138 BOOST_CHECK_EQUAL(vector_array[0], 66);
139 BOOST_CHECK_EQUAL(vector_array[1], 81);
140 BOOST_CHECK_EQUAL(vector_array[2], 96);
141}
Nektar::Transpose
NekMatrix< InnerMatrixType, BlockMatrixTag > Transpose(NekMatrix< InnerMatrixType, BlockMatrixTag > &rhs)
Definition: BlockMatrix.hpp:235

References Nektar::eWrapper, and Nektar::Transpose().

◆ BOOST_AUTO_TEST_CASE() [5/9]

Nektar::FullMatrixOperationsUnitTests::BOOST_AUTO_TEST_CASE ( TestDoubleSquareFullVectorMultiplicationWithSharedArrayAliasingAndOverlap  )

Definition at line 143 of file TestFullMatrixOperations.cpp.

145{
146 double m_buf[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
147 double v_buf[] = {4, 5, 6, 0};
148
149 Array<OneD, double> vector_array(4, v_buf);
150 Array<OneD, double> tmp;
151
152 NekMatrix<double> m(3, 3, m_buf);
153 NekVector<double> v(3, vector_array, eWrapper);
154 NekVector<double> result(3, tmp = vector_array + 1, eWrapper);
155
156 double expected_result_buf[] = {66, 81, 96};
157 NekVector<double> expected_result(3, expected_result_buf);
158
159 result = m * v;
160
161 BOOST_CHECK_EQUAL(expected_result, result);
162 BOOST_CHECK_EQUAL(vector_array[1], 66);
163 BOOST_CHECK_EQUAL(vector_array[2], 81);
164 BOOST_CHECK_EQUAL(vector_array[3], 96);
165}

References Nektar::eWrapper.

◆ BOOST_AUTO_TEST_CASE() [6/9]

Nektar::FullMatrixOperationsUnitTests::BOOST_AUTO_TEST_CASE ( TestScaledDoubleSquareFullVectorMultiplication  )

Definition at line 167 of file TestFullMatrixOperations.cpp.

168{
169 double m_buf[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
170 double v_buf[] = {4, 5, 6};
171
172 std::shared_ptr<NekMatrix<double>> inner(
173 new NekMatrix<double>(3, 3, m_buf));
174 NekMatrix<NekMatrix<double>, ScaledMatrixTag> m(7.0, inner);
175 NekVector<double> v(3, v_buf);
176
177 double expected_result_buf[] = {462, 567, 672};
178 NekVector<double> expected_result(3, expected_result_buf);
179
180 NekVector<double> result = m * v;
181
182 BOOST_CHECK_EQUAL(expected_result, result);
183}

◆ BOOST_AUTO_TEST_CASE() [7/9]

Nektar::FullMatrixOperationsUnitTests::BOOST_AUTO_TEST_CASE ( TestThreeMatrixMultiplication  )

Definition at line 185 of file TestFullMatrixOperations.cpp.

186{
187 double buf1[] = {1.0, 2.0, 3.0, 4.0};
188 double buf2[] = {5.0, 6.0, 7.0, 8.0};
189 double buf3[] = {9.0, 10.0, 11.0, 12.0};
190
191 NekMatrix<double> m1(2, 2, buf1);
192 NekMatrix<double> m2(2, 2, buf2);
193 NekMatrix<double> m3(2, 2, buf3);
194
195 double expected_result_buf[] = {517, 766, 625, 926};
196 NekMatrix<double> expected_result(2, 2, expected_result_buf);
197
198 NekMatrix<double> result1 = m1 * m2 * m3;
199 NekMatrix<double> result2 = m1 * (m2 * m3);
200 BOOST_CHECK_EQUAL(expected_result, m1 * m2 * m3);
201
202 BOOST_CHECK_EQUAL(expected_result, m1 * (m2 * m3));
203}

◆ BOOST_AUTO_TEST_CASE() [8/9]

Nektar::FullMatrixOperationsUnitTests::BOOST_AUTO_TEST_CASE ( TestThreeMatrixMultiplicationWithTranspose  )

Definition at line 205 of file TestFullMatrixOperations.cpp.

206{
207 double buf1[] = {1.0, 2.0, 3.0, 4.0};
208 double buf2[] = {5.0, 6.0, 7.0, 8.0};
209 double buf3[] = {9.0, 11.0, 10.0, 12.0};
210
211 NekMatrix<double> m1(2, 2, buf1);
212 NekMatrix<double> m2(2, 2, buf2);
213 NekMatrix<double> m3(2, 2, buf3);
214
215 double expected_result_buf[] = {517, 766, 625, 926};
216 NekMatrix<double> expected_result(2, 2, expected_result_buf);
217
218 BOOST_CHECK_EQUAL(expected_result, m1 * m2 * Transpose(m3));
219}

References Nektar::Transpose().

◆ BOOST_AUTO_TEST_CASE() [9/9]

Nektar::FullMatrixOperationsUnitTests::BOOST_AUTO_TEST_CASE ( TestThreeWrappedMatrixMultiplicationWithTranspose  )

Definition at line 221 of file TestFullMatrixOperations.cpp.

222{
223 double buf1[] = {1.0, 2.0, 3.0, 4.0};
224 double buf2[] = {5.0, 6.0, 7.0, 8.0};
225 double buf3[] = {9.0, 11.0, 10.0, 12.0};
226 double out_buf[] = {0.0, 0.0, 0.0, 0.0};
227
228 Array<OneD, double> array_buf1(4, buf1);
229 Array<OneD, double> array_buf2(4, buf2);
230 Array<OneD, double> array_buf3(4, buf3);
231 Array<OneD, double> array_out_buf(4, out_buf);
232
233 NekMatrix<double> m1(2, 2, array_buf1, eWrapper);
234 NekMatrix<double> m2(2, 2, array_buf2, eWrapper);
235 NekMatrix<double> m3(2, 2, array_buf3, eWrapper);
236 NekMatrix<double> result(2, 2, array_out_buf, eWrapper);
237
238 double expected_result_buf[] = {517, 766, 625, 926};
239 NekMatrix<double> expected_result(2, 2, expected_result_buf);
240
241 result = m1 * m2 * Transpose(m3);
242 BOOST_CHECK_EQUAL(expected_result, result);
243 BOOST_CHECK_EQUAL(array_out_buf[0], 517.0);
244 BOOST_CHECK_EQUAL(array_out_buf[1], 766.0);
245 BOOST_CHECK_EQUAL(array_out_buf[2], 625.0);
246 BOOST_CHECK_EQUAL(array_out_buf[3], 926.0);
247 BOOST_CHECK_EQUAL(result(0, 0), 517.0);
248 BOOST_CHECK_EQUAL(result(1, 0), 766.0);
249 BOOST_CHECK_EQUAL(result(0, 1), 625.0);
250 BOOST_CHECK_EQUAL(result(1, 1), 926.0);
251}

References Nektar::eWrapper, and Nektar::Transpose().

◆ foo() [1/2]

template<typename DataType >
int Nektar::FullMatrixOperationsUnitTests::foo ( NekMatrix< DataType, BlockMatrixTag > &  d)

Definition at line 55 of file TestFullMatrixOperations.cpp.

56{
57 boost::ignore_unused(d);
58 return 2;
59}
Nektar::UnitTests::d
std::vector< double > d(NPUPPER *NPUPPER)

References Nektar::UnitTests::d().

◆ foo() [2/2]

template<typename DataType , typename MatrixType >
int Nektar::FullMatrixOperationsUnitTests::foo ( NekMatrix< DataType, MatrixType > &  d)

Definition at line 49 of file TestFullMatrixOperations.cpp.

50{
51 boost::ignore_unused(d);
52 return 1;
53}

References Nektar::UnitTests::d().

Referenced by BOOST_AUTO_TEST_CASE().

Generated on Wed Jan 31 2024 08:26:55 for Nektar++ by doxygen 1.9.4