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