Arcane  4.2.3.0
Developer documentation
Loading...
Searching...
No Matches
TestNumMatrix.cc
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2026 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
4// See the top-level COPYRIGHT file for details.
5// SPDX-License-Identifier: Apache-2.0
6//-----------------------------------------------------------------------------
7
8#include <gtest/gtest.h>
9
10#include "arcane/utils/ValueConvert.h"
11#include "arcane/utils/NumMatrix.h"
12#include "arccore/base/MathNumeric.h"
13
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17using namespace Arcane;
18
20static_assert(std::is_same_v<TrueType,ArrayTraits<NumMatrix<double,4,2>>::IsPODType>);
21
22TEST(TestNumMatrix, Real2x2)
23{
24 auto zero = RealN2::zero();
25 {
26 RealN2x2 v0;
27 ASSERT_EQ(v0.vx(), zero);
28 ASSERT_EQ(v0.vy(), zero);
29 }
30 {
31 RealN2x2 v1{ 0.0 };
32 ASSERT_EQ(v1.vx(), zero);
33 ASSERT_EQ(v1.vy(), zero);
34 }
35 {
36 double value = 0.2;
37 RealN2 r2_value(value);
38 RealN2x2 v1(value);
39 ASSERT_EQ(v1.vx(), r2_value);
40 ASSERT_EQ(v1.vy(), r2_value);
41 RealN2x2 v2(v1);
42 ASSERT_EQ(v2.vx(), v1.vx());
43 ASSERT_EQ(v2.vy(), v1.vy());
44 RealN2 rx(3.5, 1.2);
45 RealN2 ry(1.6, 2.1);
46 v2.setRow(0, rx);
47 v2.setRow(1, ry);
48 v1 = v2;
49 ASSERT_EQ(v2.vx(), rx);
50 ASSERT_EQ(v2.vy(), ry);
51 ASSERT_EQ(v1, v2);
52 }
53}
54
55/*---------------------------------------------------------------------------*/
56/*---------------------------------------------------------------------------*/
57
58TEST(TestNumMatrix, Real2x2ElementAccess)
59{
60 RealN2x2 m;
61 m(0, 0) = 1.0;
62 m(0, 1) = 2.0;
63 m(1, 0) = 3.0;
64 m(1, 1) = 4.0;
65 ASSERT_EQ(m(0, 0), 1.0);
66 ASSERT_EQ(m(0, 1), 2.0);
67 ASSERT_EQ(m(1, 0), 3.0);
68 ASSERT_EQ(m(1, 1), 4.0);
69
70 // Row access
71 RealN2 r0 = m.row(0);
72 ASSERT_EQ(r0.vx(), 1.0);
73 ASSERT_EQ(r0.vy(), 2.0);
74 RealN2 r1 = m.row(1);
75 ASSERT_EQ(r1.vx(), 3.0);
76 ASSERT_EQ(r1.vy(), 4.0);
77}
78
79/*---------------------------------------------------------------------------*/
80/*---------------------------------------------------------------------------*/
81
82TEST(TestNumMatrix, Real2x2SetRow)
83{
84 RealN2x2 m;
85 m.setRow(0, RealN2(5.0, 6.0));
86 m.setRow(1, RealN2(7.0, 8.0));
87 ASSERT_EQ(m(0, 0), 5.0);
88 ASSERT_EQ(m(0, 1), 6.0);
89 ASSERT_EQ(m(1, 0), 7.0);
90 ASSERT_EQ(m(1, 1), 8.0);
91}
92
93/*---------------------------------------------------------------------------*/
94/*---------------------------------------------------------------------------*/
95
96TEST(TestNumMatrix, Real2x2Fill)
97{
98 RealN2x2 m;
99 m.fill(3.5);
100 ASSERT_EQ(m(0, 0), 3.5);
101 ASSERT_EQ(m(0, 1), 3.5);
102 ASSERT_EQ(m(1, 0), 3.5);
103 ASSERT_EQ(m(1, 1), 3.5);
104}
105
106/*---------------------------------------------------------------------------*/
107/*---------------------------------------------------------------------------*/
108
109TEST(TestNumMatrix, Real2x2Zero)
110{
111 RealN2x2 m = RealN2x2::zero();
112 RealN2 zero{0.0};
113 ASSERT_EQ(m.vx(), zero);
114 ASSERT_EQ(m.vy(), zero);
115 ASSERT_TRUE(math::isNearlyZero(m));
116}
117
118/*---------------------------------------------------------------------------*/
119/*---------------------------------------------------------------------------*/
120
121TEST(TestNumMatrix, Real2x2Arithmetic)
122{
123 RealN2x2 a(RealN2(1.0, 2.0), RealN2(3.0, 4.0));
124 RealN2x2 b(RealN2(5.0, 6.0), RealN2(7.0, 8.0));
125
126 // Addition
127 RealN2x2 c = a + b;
128 ASSERT_EQ(c(0, 0), 6.0);
129 ASSERT_EQ(c(0, 1), 8.0);
130 ASSERT_EQ(c(1, 0), 10.0);
131 ASSERT_EQ(c(1, 1), 12.0);
132
133 // Subtraction
134 RealN2x2 d = c - b;
135 ASSERT_EQ(d, a);
136
137 // Negation
138 RealN2x2 e = -a;
139 ASSERT_EQ(e(0, 0), -1.0);
140 ASSERT_EQ(e(0, 1), -2.0);
141
142 // Scalar multiplication
143 RealN2x2 f = a * 2.0;
144 ASSERT_EQ(f(0, 0), 2.0);
145 ASSERT_EQ(f(0, 1), 4.0);
146 ASSERT_EQ(f(1, 0), 6.0);
147 ASSERT_EQ(f(1, 1), 8.0);
148
149 RealN2x2 g = 3.0 * a;
150 ASSERT_EQ(g(0, 0), 3.0);
151 ASSERT_EQ(g(0, 1), 6.0);
152
153 // Scalar division
154 RealN2x2 h = f / 2.0;
155 ASSERT_EQ(h, a);
156}
157
158/*---------------------------------------------------------------------------*/
159/*---------------------------------------------------------------------------*/
160
161TEST(TestNumMatrix, Real2x2CompoundAssignment)
162{
163 RealN2x2 a(RealN2(1.0, 2.0), RealN2(3.0, 4.0));
164 RealN2x2 b(RealN2(5.0, 6.0), RealN2(7.0, 8.0));
165
166 RealN2x2 c = a;
167 c += b;
168 ASSERT_EQ(c(0, 0), 6.0);
169 ASSERT_EQ(c(0, 1), 8.0);
170
171 c -= b;
172 ASSERT_EQ(c, a);
173
174 c *= 2.0;
175 ASSERT_EQ(c(0, 0), 2.0);
176 ASSERT_EQ(c(0, 1), 4.0);
177
178 RealN2x2 d = a;
179 d /= 2.0;
180 ASSERT_EQ(d(0, 0), 0.5);
181 ASSERT_EQ(d(0, 1), 1.0);
182}
183
184/*---------------------------------------------------------------------------*/
185/*---------------------------------------------------------------------------*/
186
187TEST(TestNumMatrix, Real2x2ScalarAssignment)
188{
189 RealN2x2 m;
190 m = 5.0;
191 ASSERT_EQ(m(0, 0), 5.0);
192 ASSERT_EQ(m(0, 1), 5.0);
193 ASSERT_EQ(m(1, 0), 5.0);
194 ASSERT_EQ(m(1, 1), 5.0);
195}
196
197/*---------------------------------------------------------------------------*/
198/*---------------------------------------------------------------------------*/
199
200TEST(TestNumMatrix, Real2x2Conversion)
201{
202 RealN2x2 m(RealN2(1.0, 2.0), RealN2(3.0, 4.0));
203 Real2x2 r = static_cast<Real2x2>(m);
204 ASSERT_EQ(r.x.x, 1.0);
205 ASSERT_EQ(r.x.y, 2.0);
206 ASSERT_EQ(r.y.x, 3.0);
207 ASSERT_EQ(r.y.y, 4.0);
208
209 // Construction from Real2x2
210 RealN2x2 m2(Real2x2(Real2(1.0, 2.0), Real2(3.0, 4.0)));
211 ASSERT_EQ(m2(0, 0), 1.0);
212 ASSERT_EQ(m2(1, 1), 4.0);
213
214 // Assignment from Real2x2
215 RealN2x2 m3;
216 m3 = Real2x2(Real2(5.0, 6.0), Real2(7.0, 8.0));
217 ASSERT_EQ(m3(0, 0), 5.0);
218 ASSERT_EQ(m3(1, 1), 8.0);
219}
220
221/*---------------------------------------------------------------------------*/
222/*---------------------------------------------------------------------------*/
223
224TEST(TestNumMatrix, Real3x3)
225{
226 RealN3 zero{0.0};
227 {
228 RealN3x3 v1{0.0};
229 ASSERT_EQ(v1.vx(), zero);
230 ASSERT_EQ(v1.vy(), zero);
231 ASSERT_EQ(v1.vz(), zero);
232 }
233 {
234 double value = 0.2;
235 RealN3 r3_value(value);
236 RealN3x3 v1(value);
237 ASSERT_EQ(v1.vx(), r3_value);
238 ASSERT_EQ(v1.vy(), r3_value);
239 ASSERT_EQ(v1.vz(), r3_value);
240 RealN3x3 v2(v1);
241 ASSERT_EQ(v2.vx(), v1.vx());
242 ASSERT_EQ(v2.vy(), v1.vy());
243 ASSERT_EQ(v2.vz(), v1.vz());
244 RealN3 rx(3.5, 1.2, -1.5);
245 RealN3 ry(1.6, 2.1, -2.3);
246 RealN3 rz(-2.3, 1.8, 9.4);
247 v2.setRow(0,rx);
248 v2.setRow(1,ry);
249 v2.setRow(2,rz);
250 v1 = v2;
251 ASSERT_EQ(v1.vx(), rx);
252 ASSERT_EQ(v1.vy(), ry);
253 ASSERT_EQ(v1.vz(), rz);
254 ASSERT_EQ(v1, v2);
255 }
256}
257
258/*---------------------------------------------------------------------------*/
259/*---------------------------------------------------------------------------*/
260
261TEST(TestNumMatrix, Real3x3FromColumns)
262{
263 RealN3x3 m = RealN3x3::fromColumns(1.0, 2.0, 3.0,
264 4.0, 5.0, 6.0,
265 7.0, 8.0, 9.0);
266 // Columns: (ax,bx,cx) = (1,4,7), (ay,by,cy) = (2,5,8), (az,bz,cz) = (3,6,9)
267 // So row 0 = (ax, ay, az) = (1,2,3)
268 ASSERT_EQ(m(0, 0), 1.0);
269 ASSERT_EQ(m(0, 1), 4.0);
270 ASSERT_EQ(m(0, 2), 7.0);
271 ASSERT_EQ(m(1, 0), 2.0);
272 ASSERT_EQ(m(1, 1), 5.0);
273 ASSERT_EQ(m(1, 2), 8.0);
274 ASSERT_EQ(m(2, 0), 3.0);
275 ASSERT_EQ(m(2, 1), 6.0);
276 ASSERT_EQ(m(2, 2), 9.0);
277}
278
279/*---------------------------------------------------------------------------*/
280/*---------------------------------------------------------------------------*/
281
282TEST(TestNumMatrix, Real3x3FromLines)
283{
284 RealN3x3 m = RealN3x3::fromLines(1.0, 2.0, 3.0,
285 4.0, 5.0, 6.0,
286 7.0, 8.0, 9.0);
287 ASSERT_EQ(m(0, 0), 1.0);
288 ASSERT_EQ(m(0, 1), 2.0);
289 ASSERT_EQ(m(0, 2), 3.0);
290 ASSERT_EQ(m(1, 0), 4.0);
291 ASSERT_EQ(m(1, 1), 5.0);
292 ASSERT_EQ(m(1, 2), 6.0);
293 ASSERT_EQ(m(2, 0), 7.0);
294 ASSERT_EQ(m(2, 1), 8.0);
295 ASSERT_EQ(m(2, 2), 9.0);
296}
297
298/*---------------------------------------------------------------------------*/
299/*---------------------------------------------------------------------------*/
300
301TEST(TestNumMatrix, Real3x3Conversion)
302{
303 RealN3x3 m(RealN3(1.0, 2.0, 3.0),
304 RealN3(4.0, 5.0, 6.0),
305 RealN3(7.0, 8.0, 9.0));
306 Real3x3 r = static_cast<Real3x3>(m);
307 ASSERT_EQ(r.x.x, 1.0);
308 ASSERT_EQ(r.x.y, 2.0);
309 ASSERT_EQ(r.x.z, 3.0);
310 ASSERT_EQ(r.y.x, 4.0);
311 ASSERT_EQ(r.y.y, 5.0);
312 ASSERT_EQ(r.y.z, 6.0);
313 ASSERT_EQ(r.z.x, 7.0);
314 ASSERT_EQ(r.z.y, 8.0);
315 ASSERT_EQ(r.z.z, 9.0);
316
317 // Construction from Real3x3
318 Real3x3 r3(Real3(1.0, 2.0, 3.0), Real3(4.0, 5.0, 6.0), Real3(7.0, 8.0, 9.0));
319 RealN3x3 m2(r3);
320 ASSERT_EQ(m2(0, 0), 1.0);
321 ASSERT_EQ(m2(1, 1), 5.0);
322 ASSERT_EQ(m2(2, 2), 9.0);
323
324 // Assignment from Real3x3
325 RealN3x3 m3;
326 m3 = r3;
327 ASSERT_EQ(m3, m2);
328}
329
330/*---------------------------------------------------------------------------*/
331/*---------------------------------------------------------------------------*/
332
333TEST(TestNumMatrix, Real3x3ElementAccess)
334{
335 RealN3x3 m;
336 for (int i = 0; i < 3; ++i)
337 for (int j = 0; j < 3; ++j)
338 m(i, j) = double(i * 3 + j + 1);
339
340 ASSERT_EQ(m(0, 0), 1.0);
341 ASSERT_EQ(m(0, 1), 2.0);
342 ASSERT_EQ(m(0, 2), 3.0);
343 ASSERT_EQ(m(1, 0), 4.0);
344 ASSERT_EQ(m(1, 1), 5.0);
345 ASSERT_EQ(m(1, 2), 6.0);
346 ASSERT_EQ(m(2, 0), 7.0);
347 ASSERT_EQ(m(2, 1), 8.0);
348 ASSERT_EQ(m(2, 2), 9.0);
349
350 ASSERT_EQ(m.row(0), RealN3(1.0, 2.0, 3.0));
351 ASSERT_EQ(m.row(1), RealN3(4.0, 5.0, 6.0));
352 ASSERT_EQ(m.row(2), RealN3(7.0, 8.0, 9.0));
353}
354
355/*---------------------------------------------------------------------------*/
356/*---------------------------------------------------------------------------*/
357
358TEST(TestNumMatrix, Real3x3Arithmetic)
359{
360 RealN3x3 a(RealN3(1.0, 2.0, 3.0),
361 RealN3(4.0, 5.0, 6.0),
362 RealN3(7.0, 8.0, 9.0));
363 RealN3x3 b(RealN3(9.0, 8.0, 7.0),
364 RealN3(6.0, 5.0, 4.0),
365 RealN3(3.0, 2.0, 1.0));
366
367 RealN3x3 c = a + b;
368 ASSERT_EQ(c(0, 0), 10.0);
369 ASSERT_EQ(c(1, 1), 10.0);
370 ASSERT_EQ(c(2, 2), 10.0);
371
372 RealN3x3 d = c - b;
373 ASSERT_EQ(d, a);
374
375 RealN3x3 e = -a;
376 ASSERT_EQ(e(0, 0), -1.0);
377 ASSERT_EQ(e(1, 1), -5.0);
378 ASSERT_EQ(e(2, 2), -9.0);
379
380 RealN3x3 f = a * 2.0;
381 ASSERT_EQ(f(0, 0), 2.0);
382 ASSERT_EQ(f(1, 1), 10.0);
383
384 RealN3x3 g = 0.5 * f;
385 ASSERT_EQ(g, a);
386}
387
388/*---------------------------------------------------------------------------*/
389/*---------------------------------------------------------------------------*/
390
391TEST(TestNumMatrix, Real3x3Fill)
392{
393 RealN3x3 m;
394 m.fill(-1.0);
395 for (int i = 0; i < 3; ++i)
396 for (int j = 0; j < 3; ++j)
397 ASSERT_EQ(m(i, j), -1.0);
398}
399
400/*---------------------------------------------------------------------------*/
401/*---------------------------------------------------------------------------*/
402
403TEST(TestNumMatrix, Real3x3NearlyZero)
404{
405 RealN3x3 m{0.0};
406 ASSERT_TRUE(math::isNearlyZero(m));
407 m(0, 0) = 1e-20;
408 ASSERT_TRUE(math::isNearlyZero(m));
409 m(0, 0) = 1.0;
410 ASSERT_FALSE(math::isNearlyZero(m));
411}
412
413/*---------------------------------------------------------------------------*/
414/*---------------------------------------------------------------------------*/
415
416TEST(TestNumMatrix, NonSquare2x5)
417{
418 using M2x5 = NumMatrix<Real, 2, 5>;
419
420 M2x5 m;
421 for (int j = 0; j < 5; ++j) {
422 m(0, j) = double(j);
423 m(1, j) = double(j * 10);
424 }
425 for (int j = 0; j < 5; ++j) {
426 ASSERT_EQ(m(0, j), double(j));
427 ASSERT_EQ(m(1, j), double(j * 10));
428 }
429
430 ASSERT_EQ(m.row(0).vx(), 0.0);
431 ASSERT_EQ(m.row(0)(4), 4.0);
432 ASSERT_EQ(m.row(1)(3), 30.0);
433
434 M2x5 n;
435 n.fill(7.0);
436 for (int j = 0; j < 5; ++j) {
437 ASSERT_EQ(n(0, j), 7.0);
438 ASSERT_EQ(n(1, j), 7.0);
439 }
440}
441
442/*---------------------------------------------------------------------------*/
443/*---------------------------------------------------------------------------*/
444
445TEST(TestNumMatrix, NonSquare5x2)
446{
447 using M5x2 = NumMatrix<Real, 5, 2>;
448
449 M5x2 m;
450 for (int i = 0; i < 5; ++i)
451 for (int j = 0; j < 2; ++j)
452 m(i, j) = double(i + j);
453
454 for (int i = 0; i < 5; ++i)
455 for (int j = 0; j < 2; ++j)
456 ASSERT_EQ(m(i, j), double(i + j));
457
458 ASSERT_EQ(m.vx()(1), 1.0);
459 ASSERT_EQ(m.vy()(1), 1.0 + 1.0);
460 ASSERT_EQ(m.row(3)(1), 4.0);
461}
462
463/*---------------------------------------------------------------------------*/
464/*---------------------------------------------------------------------------*/
465
466TEST(TestNumMatrix, Int32x2)
467{
468 using Int32x2 = NumMatrix<Int32, 2, 2>;
469
470 Int32x2 m{ {} };
471 ASSERT_EQ(m(0, 0), 0);
472 ASSERT_EQ(m(1, 1), 0);
473
474 m(0, 0) = 1;
475 m(0, 1) = 2;
476 m(1, 0) = 3;
477 m(1, 1) = 4;
478 ASSERT_EQ(m(0, 0), 1);
479 ASSERT_EQ(m(1, 1), 4);
480
481 Int32x2 n(Int32x2::VectorType(5, 6), Int32x2::VectorType(7, 8));
482 ASSERT_EQ(n(0, 0), 5);
483 ASSERT_EQ(n(1, 1), 8);
484
485 Int32x2 p = m + n;
486 ASSERT_EQ(p(0, 0), 6);
487 ASSERT_EQ(p(0, 1), 8);
488 ASSERT_EQ(p(1, 0), 10);
489 ASSERT_EQ(p(1, 1), 12);
490
491 p *= 2;
492 ASSERT_EQ(p(0, 0), 12);
493
494 Int32x2 r;
495 ASSERT_EQ(r(0, 0), 0);
496 ASSERT_EQ(r(1, 1), 0);
497}
498
499/*---------------------------------------------------------------------------*/
500/*---------------------------------------------------------------------------*/
501
502namespace Arcane
503{
504template class NumMatrix<Real, 2, 2>;
505template class NumMatrix<Real, 3, 3>;
506template class NumMatrix<Real, 1, 1>;
507template class NumMatrix<Real, 2, 5>;
508template class NumMatrix<Real, 5, 2>;
509template class NumMatrix<float, 2, 6>;
510template class NumMatrix<Int32, 2, 2>;
511} // namespace Arcane
512
513/*---------------------------------------------------------------------------*/
514/*---------------------------------------------------------------------------*/
ASSERT_FALSE
#define ASSERT_FALSE(condition)
Checks that condition is false.
Definition Assertion.h:140
ASSERT_TRUE
#define ASSERT_TRUE(condition)
Checks that condition is true.
Definition Assertion.h:128
Arcane::NumMatrix
Small fixed-size matrix containing RowSize rows and ColumnSize columns.
Definition arccore/src/base/arccore/base/NumMatrix.h:38
Arcane::NumMatrix< Real, 2 >::zero
constexpr __host__ static __device__ ThatClass zero()
Definition arccore/src/base/arccore/base/NumMatrix.h:182
Arcane::NumMatrix< Real, 3 >::fromLines
constexpr __host__ static __device__ ThatClass fromLines(Real ax, Real bx, Real cx, Real ay, Real by, Real cy, Real az, Real bz, Real cz)
Definition arccore/src/base/arccore/base/NumMatrix.h:195
Arcane::NumMatrix::setRow
constexpr __host__ __device__ void setRow(Int32 i, const VectorType &v)
Sets the value of the i-th row to v.
Definition arccore/src/base/arccore/base/NumMatrix.h:332
Arcane::NumMatrix< Real, 3 >::fromColumns
constexpr __host__ static __device__ ThatClass fromColumns(Real ax, Real ay, Real az, Real bx, Real by, Real bz, Real cx, Real cy, Real cz)
Definition arccore/src/base/arccore/base/NumMatrix.h:188
Arcane::NumMatrix::fill
constexpr __host__ __device__ void fill(const DataType &v)
Fill the matrix with the value v.
Definition arccore/src/base/arccore/base/NumMatrix.h:341
Arcane::NumVector::vx
constexpr __host__ __device__ DataType & vx()
Value of the first component.
Definition arccore/src/base/arccore/base/NumVector.h:361
Arcane::NumVector::vy
constexpr __host__ __device__ DataType & vy()
Value of the second component.
Definition arccore/src/base/arccore/base/NumVector.h:372
Arcane::Real2
Class managing a 2-dimensional real vector.
Definition arccore/src/base/arccore/base/Real2.h:123
Arcane::Real2x2
Class managing a 2x2 matrix of reals.
Definition arccore/src/base/arccore/base/Real2x2.h:56
Arcane::Real3
Class managing a 3-dimensional real vector.
Definition arccore/src/base/arccore/base/Real3.h:128
Arcane::Real3x3
Class managing a 3x3 real matrix.
Definition arccore/src/base/arccore/base/Real3x3.h:67
Arcane::Real3x3::z
Real3 z
first element of the triplet
Definition arccore/src/base/arccore/base/Real3x3.h:133
Arcane::Real3x3::y
Real3 y
first element of the triplet
Definition arccore/src/base/arccore/base/Real3x3.h:132
Arcane::Real3x3::x
Real3 x
first element of the triplet
Definition arccore/src/base/arccore/base/Real3x3.h:131
Arcane
-- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature --
Definition arcane/src/arcane/accelerator/AcceleratorGlobal.h:37
Arcane::Real2POD::y
Real y
second component of the pair
Definition arccore/src/base/arccore/base/Real2.h:37
Arcane::Real2POD::x
Real x
first component of the pair
Definition arccore/src/base/arccore/base/Real2.h:36
Arcane::Real3POD::y
Real y
second component of the triplet
Definition arccore/src/base/arccore/base/Real3.h:34
Arcane::Real3POD::z
Real z
third component of the triplet
Definition arccore/src/base/arccore/base/Real3.h:35
Arcane::Real3POD::x
Real x
first component of the triplet
Definition arccore/src/base/arccore/base/Real3.h:33