Arcane  v4.1.4.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
TestRealN.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/NumericTypes.h"
12
13#include <type_traits>
14
15/*---------------------------------------------------------------------------*/
16/*---------------------------------------------------------------------------*/
17
18using namespace Arcane;
19
20TEST(TestRealN,Real2)
21{
22 {
23 Real2 v1;
24 ASSERT_EQ(v1.x,0.0);
25 ASSERT_EQ(v1.y,0.0);
26 }
27 {
28 double value = 0.2;
29 Real2 v1(value);
30 ASSERT_EQ(v1.x,value);
31 ASSERT_EQ(v1.y,value);
32 Real2 v2(v1);
33 ASSERT_EQ(v2.x,value);
34 ASSERT_EQ(v2.y,value);
35 v2.x = 3.5;
36 v2.y = 1.2;
37 v1 = v2;
38 ASSERT_EQ(v1.x,3.5);
39 ASSERT_EQ(v1.y,1.2);
40 ASSERT_EQ(v1,v2);
41 }
42 {
43 double value = 0.3;
44 Real2 v2;
45 v2 = value;
46 ASSERT_EQ(v2.x,value);
47 ASSERT_EQ(v2.x,value);
48 }
49 // Operator + and -
50 {
51 Real2 v2(1.2,4.5);
52 Real2 v1(1.3,2.3);
53 Real2 v3 = v1 + v2;
54 ASSERT_EQ(v3.x,2.5);
55 ASSERT_EQ(v3.y,6.8);
56 Real2 v4 = v3 - v2;
57 ASSERT_EQ(v4,v1);
58 }
59 // Operator * and /
60 {
61 Real2 v2(1.2,4.5);
62 Real2 v1(1.3,2.3);
63 Real2 v3 = v1 * v2;
64 ASSERT_EQ(v3.x,1.2*1.3);
65 ASSERT_EQ(v3.y,4.5*2.3);
66 Real2 v4 = v3 * 2.3;
67 ASSERT_EQ(v4.x,v3.x*2.3);
68 ASSERT_EQ(v4.y,v3.y*2.3);
69 Real2 v5 = v4 / 2.4;
70 ASSERT_EQ(v5.x,v4.x/2.4);
71 ASSERT_EQ(v5.y,v4.y/2.4);
72 }
73 {
74 Real3 v3(1.2,2.3,4.5);
75 Real2 v2(v3);
76 ASSERT_EQ(v2.x,1.2);
77 ASSERT_EQ(v2.y,2.3);
78 }
79 {
80 Real x = 1.2;
81 Real y = -3.4;
82 Real2 v4(x,y);
83 Real norm_l2 = math::sqrt(x*x+y*y);
84 ASSERT_TRUE(math::isNearlyEqual(norm_l2,v4.normL2()));
85 ASSERT_TRUE(math::isNearlyEqual(1.0,math::normL2(math::normalizeL2(v4))));
86 Real2 v5(v4);
87 math::mutableNormalize(v5);
88 ASSERT_TRUE(math::isNearlyEqual(1.0,math::normL2(v5)));
89 Real2 v6;
90 ASSERT_EQ(0.0,math::normL2(v6));
91 }
92}
93
94TEST(TestRealN,Real3)
95{
96 {
97 Real3 v1;
98 ASSERT_EQ(v1.x,0.0);
99 ASSERT_EQ(v1.y,0.0);
100 ASSERT_EQ(v1.z,0.0);
101 }
102 {
103 double value = 0.2;
104 Real3 v1(value);
105 ASSERT_EQ(v1.x,value);
106 ASSERT_EQ(v1.y,value);
107 ASSERT_EQ(v1.z,value);
108 Real3 v2(v1);
109 ASSERT_EQ(v2.x,value);
110 ASSERT_EQ(v2.y,value);
111 ASSERT_EQ(v2.z,value);
112 v2.x = 3.5;
113 v2.y = 1.2;
114 v2.z = -1.5;
115 v1 = v2;
116 ASSERT_EQ(v1.x,3.5);
117 ASSERT_EQ(v1.y,1.2);
118 ASSERT_EQ(v1.z,-1.5);
119 ASSERT_EQ(v1,v2);
120 }
121 {
122 Real2 v2(1.2,2.3);
123 Real3 v3(v2);
124 ASSERT_EQ(v3.x,1.2);
125 ASSERT_EQ(v3.y,2.3);
126 ASSERT_EQ(v3.z,0.0);
127 }
128 {
129 Real x = 1.2;
130 Real y = -3.4;
131 Real z = 9.1;
132 Real3 v4(x,y,z);
133 Real norm_l2 = math::sqrt(x*x+y*y+z*z);
134 ASSERT_TRUE(math::isNearlyEqual(norm_l2,v4.normL2()));
135 ASSERT_TRUE(math::isNearlyEqual(1.0,math::normL2(math::normalizeL2(v4))));
136 Real3 v5(v4);
137 math::mutableNormalize(v5);
138 ASSERT_TRUE(math::isNearlyEqual(1.0,math::normL2(v5)));
139 Real3 v6;
140 ASSERT_EQ(0.0,math::normL2(v6));
141 }
142}
143
144TEST(TestRealN,Real2x2)
145{
146 Real2 zero;
147 {
148 Real2x2 v1;
149 ASSERT_EQ(v1.x,zero);
150 ASSERT_EQ(v1.y,zero);
151 }
152 {
153 double value = 0.2;
154 Real2 r2_value(value);
155 Real2x2 v1(value);
156 ASSERT_EQ(v1.x,r2_value);
157 ASSERT_EQ(v1.y,r2_value);
158 Real2x2 v2(v1);
159 ASSERT_EQ(v2.x,v1.x);
160 ASSERT_EQ(v2.y,v1.y);
161 Real2 rx(3.5, 1.2);
162 Real2 ry(1.6, 2.1);
163 v2.x = rx;
164 v2.y = ry;
165 v1 = v2;
166 ASSERT_EQ(v1.x,rx);
167 ASSERT_EQ(v1.y,ry);
168 ASSERT_EQ(v1,v2);
169 }
170}
171
172TEST(TestRealN,Real3x3)
173{
174 Real3 zero;
175 {
176 Real3x3 v1;
177 ASSERT_EQ(v1.x,zero);
178 ASSERT_EQ(v1.y,zero);
179 ASSERT_EQ(v1.z,zero);
180 }
181 {
182 double value = 0.2;
183 Real3 r3_value(value);
184 Real3x3 v1(value);
185 ASSERT_EQ(v1.x,r3_value);
186 ASSERT_EQ(v1.y,r3_value);
187 ASSERT_EQ(v1.z,r3_value);
188 Real3x3 v2(v1);
189 ASSERT_EQ(v2.x,v1.x);
190 ASSERT_EQ(v2.y,v1.y);
191 ASSERT_EQ(v2.z,v1.z);
192 Real3 rx(3.5, 1.2, -1.5);
193 Real3 ry(1.6, 2.1, -2.3);
194 Real3 rz(-2.3, 1.8, 9.4);
195 v2.x = rx;
196 v2.y = ry;
197 v2.z = rz;
198 v1 = v2;
199 ASSERT_EQ(v1.x,rx);
200 ASSERT_EQ(v1.y,ry);
201 ASSERT_EQ(v1.z,rz);
202 ASSERT_EQ(v1,v2);
203 }
204}
205
206TEST(TestRealN,Copyable)
207{
208 ASSERT_TRUE(std::is_trivially_copyable_v<Real2>);
209 ASSERT_TRUE(std::is_trivially_copyable_v<Real3>);
210 ASSERT_TRUE(std::is_trivially_copyable_v<Real2x2>);
211 ASSERT_TRUE(std::is_trivially_copyable_v<Real3x3>);
212}
213
214TEST(TestRealN,ContiguousAddress)
215{
216 // Vérifie que les adresses des champs des classes 'RealN' sont
217 // contigues et qu'on peut utiliser operator[] pour accéder à la i-ème composante.
218 Real2 r2;
219 ASSERT_TRUE(sizeof(r2)==2*sizeof(Real));
220 ASSERT_TRUE(&r2.y==(&r2.x+1));
221
222 Real3 r3;
223 ASSERT_TRUE(sizeof(r3)==3*sizeof(Real));
224 Real* r3_base = &r3.x;
225 ASSERT_TRUE(&r3.y==(r3_base+1));
226 ASSERT_TRUE(&r3.z==(r3_base+2));
227
228 Real2x2 r2x2;
229 Real* r2x2_base = &r2x2.x.x;
230 ASSERT_TRUE(sizeof(r2x2)==4*sizeof(Real));
231 ASSERT_TRUE(&r2x2.x.y==r2x2_base+1);
232 ASSERT_TRUE(&r2x2.y.x==r2x2_base+2);
233 ASSERT_TRUE(&r2x2.y.y==r2x2_base+3);
234
235 Real3x3 r3x3;
236 Real* r3x3_base = &r3x3.x.x;
237 ASSERT_TRUE(sizeof(r3x3)==9*sizeof(Real));
238 ASSERT_TRUE(&r3x3.x.y==r3x3_base+1);
239 ASSERT_TRUE(&r3x3.x.z==r3x3_base+2);
240 ASSERT_TRUE(&r3x3.y.x==r3x3_base+3);
241 ASSERT_TRUE(&r3x3.y.y==r3x3_base+4);
242 ASSERT_TRUE(&r3x3.y.z==r3x3_base+5);
243 ASSERT_TRUE(&r3x3.z.x==r3x3_base+6);
244 ASSERT_TRUE(&r3x3.z.y==r3x3_base+7);
245 ASSERT_TRUE(&r3x3.z.z==r3x3_base+8);
246}
247
248/*---------------------------------------------------------------------------*/
249/*---------------------------------------------------------------------------*/
ASSERT_TRUE
#define ASSERT_TRUE(condition)
Vérifie que condition est vrai.
Definition Assertion.h:125
Arcane::Real2
Classe gérant un vecteur de réel de dimension 2.
Definition Real2.h:121
Arcane::Real2x2
Classe gérant une matrice de réel de dimension 2x2.
Definition Real2x2.h:53
Arcane::Real2x2::x
Real2 x
Première composante.
Definition Real2x2.h:110
Arcane::Real2x2::y
Real2 y
Deuxième composante.
Definition Real2x2.h:111
Arcane::Real3
Classe gérant un vecteur de réel de dimension 3.
Definition Real3.h:132
Arcane::Real3x3
Classe gérant une matrice de réel de dimension 3x3.
Definition Real3x3.h:66
Arcane::Real3x3::z
Real3 z
premier élément du triplet
Definition Real3x3.h:129
Arcane::Real3x3::y
Real3 y
premier élément du triplet
Definition Real3x3.h:128
Arcane::Real3x3::x
Real3 x
premier élément du triplet
Definition Real3x3.h:127
Arcane::math::normalizeL2
Real2 normalizeL2(const Real2 &v)
Retourne le couple v normalisé avec la norme L2.
Definition Real2.h:482
Arcane::math::isNearlyEqual
constexpr __host__ __device__ bool isNearlyEqual(const _Type &a, const _Type &b)
Teste si deux valeurs sont à un peu près égales. Pour les types entiers, cette fonction est équivalen...
Definition Numeric.h:212
Arcane::math::mutableNormalize
Real2 & mutableNormalize(Real2 &v)
Normalise le couple.
Definition Real2.h:469
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
deuxième composante du couple
Definition Real2.h:35
Arcane::Real2POD::x
Real x
première composante du couple
Definition Real2.h:34
Arcane::Real3POD::y
Real y
deuxième composante du triplet
Definition Real3.h:36
Arcane::Real3POD::z
Real z
troisième composante du triplet
Definition Real3.h:37
Arcane::Real3POD::x
Real x
première composante du triplet
Definition Real3.h:35