Arcane  v3.16.6.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
Real2x2.h
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2025 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/* Real2x2.h (C) 2000-2025 */
9/* */
10/* Matrice 2x2 de 'Real'. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_UTILS_REAL2X2_H
13#define ARCANE_UTILS_REAL2X2_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arcane/utils/Real2.h"
18
19/*---------------------------------------------------------------------------*/
20/*---------------------------------------------------------------------------*/
21
22namespace Arcane
23{
24
25/*---------------------------------------------------------------------------*/
26/*---------------------------------------------------------------------------*/
27/*!
28 * \brief Structure POD pour un Real2x2.
29 */
31{
32 public:
33
34 Real2POD x;
35 Real2POD y;
36};
37
38/*---------------------------------------------------------------------------*/
39/*---------------------------------------------------------------------------*/
40/*!
41 * \brief Classe gérant une matrice de réel de dimension 2x2.
42 *
43 * La matrice comprend deux composantes \a x et \a y qui sont du
44 * type \b Real2. Par exemple:
45 *
46 * \code
47 * Real2x2 matrix;
48 * matrix.x.y = 2.;
49 * matrix.y.y = 3.;
50 * \endcode
51 */
52class ARCANE_UTILS_EXPORT Real2x2
53{
54 public:
55
56 //! Construit la matrice nulle
57 constexpr ARCCORE_HOST_DEVICE Real2x2()
58 : x(Real2::null())
59 , y(Real2::null())
60 {}
61
62 //! Construit le couple (ax,ay)
63 constexpr ARCCORE_HOST_DEVICE Real2x2(Real2 ax, Real2 ay)
64 : x(ax)
65 , y(ay)
66 {}
67
68 /*!
69 * \brief Construit le couple ((ax,bx),(ay,by)).
70 * \deprecated Utiliser Real2x2(Real2 a,Real2 b) à la place.
71 */
72 ARCANE_DEPRECATED_116 Real2x2(Real ax, Real ay, Real bx, Real by)
73 : x(ax, bx)
74 , y(ay, by)
75 {}
76
77 //! Construit un couple identique à \a f
78 Real2x2(const Real2x2& f) = default;
79
80 //! Construit un couple identique à \a f
81 constexpr ARCCORE_HOST_DEVICE explicit Real2x2(const Real2x2POD& f)
82 : x(f.x)
83 , y(f.y)
84 {}
85
86 //! Construit l'instance avec le triplet (v,v,v).
87 constexpr ARCCORE_HOST_DEVICE explicit Real2x2(Real v)
88 {
89 x = y = v;
90 }
91
92 //! Construit le couple ((av[0], av[1]), (av[2], av[3]))
93 constexpr ARCCORE_HOST_DEVICE explicit Real2x2(ConstArrayView<Real> av)
94 : x(av[0], av[1])
95 , y(av[2], av[3])
96 {}
97
98 //! Opérateur de recopie
99 Real2x2& operator=(const Real2x2& f) = default;
100
101 //! Affecte à l'instance le couple (v,v,v).
102 constexpr ARCCORE_HOST_DEVICE Real2x2& operator=(Real v)
103 {
104 x = y = v;
105 return (*this);
106 }
107
108 public:
109
110 Real2 x; //!< Première composante
111 Real2 y; //!< Deuxième composante
112
113 public:
114
115 //! Construit la matrice nulle
116 constexpr ARCCORE_HOST_DEVICE static Real2x2 null() { return Real2x2(); }
117
118 //! Construit le couple ((ax,bx),(ay,by)).
119 constexpr ARCCORE_HOST_DEVICE static Real2x2 fromColumns(Real ax, Real ay, Real bx, Real by)
120 {
121 return Real2x2(Real2(ax, bx), Real2(ay, by));
122 }
123
124 //! Construit le couple ((ax,bx),(ay,by)).
125 constexpr ARCCORE_HOST_DEVICE static Real2x2 fromLines(Real ax, Real bx, Real ay, Real by)
126 {
127 return Real2x2(Real2(ax, bx), Real2(ay, by));
128 }
129
130 public:
131
132 //! Retourne une copie du couple.
133 constexpr ARCCORE_HOST_DEVICE Real2x2 copy() const { return (*this); }
134 //! Réinitialise le couple avec les constructeurs par défaut.
135 constexpr ARCCORE_HOST_DEVICE Real2x2& reset()
136 {
137 *this = null();
138 return (*this);
139 }
140 //! Affecte à l'instance le couple (ax,ay,az)
141 constexpr ARCCORE_HOST_DEVICE Real2x2& assign(Real2 ax, Real2 ay)
142 {
143 x = ax;
144 y = ay;
145 return (*this);
146 }
147 //! Copie le couple \a f
148 constexpr ARCCORE_HOST_DEVICE Real2x2& assign(Real2x2 f)
149 {
150 x = f.x;
151 y = f.y;
152 return (*this);
153 }
154
155 //! Retourne une vue sur les quatre élements de la matrice.
156 //! [x.x, x.y, y.x, y.y]
157 constexpr ARCCORE_HOST_DEVICE ArrayView<Real> view()
158 {
159 return { 4, &x.x };
160 }
161
162 //! Retourne une vue constante sur les quatre élements de la matrice.
163 //! [x.x, x.y, y.x, y.y]
164 constexpr ARCCORE_HOST_DEVICE ConstArrayView<Real> constView() const
165 {
166 return { 4, &x.x };
167 }
168
169 /*!
170 * \brief Lit la matrice sur le flot \a i
171 * La matrice est lue sous la forme de trois Real2.
172 */
173 std::istream& assign(std::istream& i);
174 //! Ecrit le couple sur le flot \a o lisible par un assign()
175 std::ostream& print(std::ostream& o) const;
176 //! Ecrit le couple sur le flot \a o sous la forme (x,y,z)
177 std::ostream& printXy(std::ostream& o) const;
178
179 //! Ajoute \a b au couple
180 constexpr ARCCORE_HOST_DEVICE Real2x2& add(Real2x2 b)
181 {
182 x += b.x;
183 y += b.y;
184 return (*this);
185 }
186 //! Soustrait \a b au couple
187 constexpr ARCCORE_HOST_DEVICE Real2x2& sub(Real2x2 b)
188 {
189 x -= b.x;
190 y -= b.y;
191 return (*this);
192 }
193 //! Multiple chaque composante du couple par la composant correspondant de \a b
194 //Real2x2& mul(Real2x2 b) { x*=b.x; y*=b.y; return (*this); }
195 //! Divise chaque composante du couple par la composant correspondant de \a b
196 constexpr ARCCORE_HOST_DEVICE Real2x2& div(Real2x2 b)
197 {
198 x /= b.x;
199 y /= b.y;
200 return (*this);
201 }
202 //! Ajoute \a b à chaque composante du couple
203 constexpr ARCCORE_HOST_DEVICE Real2x2& addSame(Real2 b)
204 {
205 x += b;
206 y += b;
207 return (*this);
208 }
209 //! Soustrait \a b à chaque composante du couple
210 constexpr ARCCORE_HOST_DEVICE Real2x2& subSame(Real2 b)
211 {
212 x -= b;
213 y -= b;
214 return (*this);
215 }
216 //! Multiplie chaque composante du couple par \a b
217 constexpr ARCCORE_HOST_DEVICE Real2x2& mulSame(Real2 b)
218 {
219 x *= b;
220 y *= b;
221 return (*this);
222 }
223 //! Divise chaque composante du couple par \a b
224 constexpr ARCCORE_HOST_DEVICE Real2x2& divSame(Real2 b)
225 {
226 x /= b;
227 y /= b;
228 return (*this);
229 }
230 //! Ajoute \a b au couple.
231 constexpr ARCCORE_HOST_DEVICE Real2x2& operator+=(Real2x2 b) { return add(b); }
232 //! Soustrait \a b au couple
233 constexpr ARCCORE_HOST_DEVICE Real2x2& operator-=(Real2x2 b) { return sub(b); }
234 //! Multiple chaque composante du couple par la composant correspondant de \a b
235 //Real2x2& operator*=(Real2x2 b) { return mul(b); }
236 //! Multiple chaque composante de la matrice par le réel \a b
237 constexpr ARCCORE_HOST_DEVICE void operator*=(Real b)
238 {
239 x *= b;
240 y *= b;
241 }
242 //! Divise chaque composante du couple par la composant correspondant de \a b
243 //Real2x2& operator/= (Real2x2 b) { return div(b); }
244 //! Divise chaque composante de la matrice par le réel \a b
245 constexpr ARCCORE_HOST_DEVICE void operator/=(Real b)
246 {
247 x /= b;
248 y /= b;
249 }
250 //! Créé un couple qui vaut ce couple ajouté à \a b
251 constexpr ARCCORE_HOST_DEVICE Real2x2 operator+(Real2x2 b) const { return Real2x2(x + b.x, y + b.y); }
252 //! Créé un couple qui vaut \a b soustrait de ce couple
253 constexpr ARCCORE_HOST_DEVICE Real2x2 operator-(Real2x2 b) const { return Real2x2(x - b.x, y - b.y); }
254 //! Créé un tenseur opposé au tenseur actuel
255 constexpr ARCCORE_HOST_DEVICE Real2x2 operator-() const { return Real2x2(-x, -y); }
256
257 /*!
258 * \brief Compare composant pas composante l'instance courante à \a b.
259 *
260 * \retval true si this.x==b.x et this.y==b.y.
261 * \retval false sinon.
262 */
263 constexpr ARCCORE_HOST_DEVICE bool operator==(Real2x2 b) const
264 {
265 return (x == b.x) && (y == b.y);
266 }
267 /*!
268 * \brief Compare deux couples.
269 * Pour la notion d'égalité, voir operator==()
270 * \retval true si les deux couples sont différents,
271 * \retval false sinon.
272 */
273 constexpr ARCCORE_HOST_DEVICE bool operator!=(Real2x2 b) const
274 {
275 return !operator==(b);
276 }
277
278 /*!
279 * \brief Accès en lecture seule à la \a i-ème (entre 0 et 1 inclus) ligne de l'instance.
280 * \param i numéro de la ligne à retourner
281 */
282 ARCCORE_HOST_DEVICE Real2 operator[](Integer i) const
283 {
284 ARCCORE_CHECK_AT(i, 2);
285 return (&x)[i];
286 }
287
288 /*!
289 * \brief Accès en lecture seule à la \a i-ème (entre 0 et 1 inclus) ligne de l'instance.
290 * \param i numéro de la ligne à retourner
291 */
292 ARCCORE_HOST_DEVICE Real2 operator()(Integer i) const
293 {
294 ARCCORE_CHECK_AT(i, 2);
295 return (&x)[i];
296 }
297
298 /*!
299 * \brief Accès en lecture seule à la \a i-ème ligne et \a j-ème colonne.
300 * \param i numéro de la ligne à retourner
301 * \param j numéro de la colonne à retourner
302 */
303 ARCCORE_HOST_DEVICE Real operator()(Integer i, Integer j) const
304 {
305 ARCCORE_CHECK_AT(i, 2);
306 ARCCORE_CHECK_AT(j, 2);
307 return (&x)[i][j];
308 }
309
310 /*!
311 * \brief Accès à la \a i-ème ligne (entre 0 et 1 inclus) de l'instance.
312 * \param i numéro de la ligne à retourner
313 */
314 ARCCORE_HOST_DEVICE Real2& operator[](Integer i)
315 {
316 ARCCORE_CHECK_AT(i, 2);
317 return (&x)[i];
318 }
319
320 /*!
321 * \brief Accès à la \a i-ème ligne (entre 0 et 1 inclus) de l'instance.
322 * \param i numéro de la ligne à retourner
323 */
324 ARCCORE_HOST_DEVICE Real2& operator()(Integer i)
325 {
326 ARCCORE_CHECK_AT(i, 2);
327 return (&x)[i];
328 }
329
330 /*!
331 * \brief Accès à la \a i-ème ligne et \a j-ème colonne.
332 * \param i numéro de la ligne à retourner
333 * \param j numéro de la colonne à retourner
334 */
335 ARCCORE_HOST_DEVICE Real& operator()(Integer i, Integer j)
336 {
337 ARCCORE_CHECK_AT(i, 2);
338 ARCCORE_CHECK_AT(j, 2);
339 return (&x)[i][j];
340 }
341
342 public:
343
344 //! Ecrit le couple \a t sur le flot \a o
345 friend std::ostream& operator<<(std::ostream& o, Real2x2 t)
346 {
347 return t.printXy(o);
348 }
349
350 //! Lit le couple \a t à partir du flot \a o.
351 friend std::istream& operator>>(std::istream& i, Real2x2& t)
352 {
353 return t.assign(i);
354 }
355
356 //! Multiplication par un scalaire.
357 friend constexpr ARCCORE_HOST_DEVICE Real2x2 operator*(Real sca, Real2x2 vec)
358 {
359 return Real2x2(vec.x * sca, vec.y * sca);
360 }
361
362 //! Multiplication par un scalaire.
363 friend constexpr ARCCORE_HOST_DEVICE Real2x2 operator*(Real2x2 vec, Real sca)
364 {
365 return Real2x2(vec.x * sca, vec.y * sca);
366 }
367
368 //! Division par un scalaire.
369 friend constexpr ARCCORE_HOST_DEVICE Real2x2 operator/(Real2x2 vec, Real sca)
370 {
371 return Real2x2(vec.x / sca, vec.y / sca);
372 }
373
374 /*!
375 * \brief Opérateur de comparaison.
376 *
377 * Cet opérateur permet de trier les Real2 pour les utiliser par exemple
378 * dans les std::set
379 */
380 friend constexpr ARCCORE_HOST_DEVICE bool operator<(Real2x2 v1, Real2x2 v2)
381 {
382 if (v1.x == v2.x) {
383 return v1.y < v2.y;
384 }
385 return (v1.x < v2.x);
386 }
387
388 public:
389
390 /*!
391 * \brief Compare la matrice avec la matrice nulle.
392 *
393 * La matrice est nulle si et seulement si chacune de ses composant
394 * est inférieure à un espilon donné. La valeur de l'epsilon utilisée est celle
395 * de float_info<value_type>::nearlyEpsilon():
396 * \f[A=0 \Leftrightarrow |A.x|<\epsilon,|A.y|<\epsilon\f]
397 *
398 * \retval true si la matrice est égale à la matrice nulle,
399 * \retval false sinon.
400 */
401 // TODO: rendre obsolète mi-2025: ARCANE_DEPRECATED_REASON("Y2024: Use math::isNearlyZero(const Real2x2&) instead")
402 inline constexpr ARCCORE_HOST_DEVICE bool isNearlyZero() const;
403
404 private:
405
406 /*!
407 * \brief Compare les valeurs de \a a et \a b avec le comparateur TypeEqualT
408 * \retval true si \a a et \a b sont égaux,
409 * \retval false sinon.
410 */
411 constexpr ARCCORE_HOST_DEVICE static bool _eq(Real a, Real b)
412 {
413 return TypeEqualT<Real>::isEqual(a, b);
414 }
415};
416
417/*---------------------------------------------------------------------------*/
418/*---------------------------------------------------------------------------*/
419
420namespace math
421{
422 /*!
423 * \brief Compare la matrice avec la matrice nulle.
424 *
425 * La matrice est nulle si et seulement si chacune de ses composant
426 * est inférieure à un espilon donné. La valeur de l'epsilon utilisée est celle
427 * de float_info<value_type>::nearlyEpsilon():
428 * \f[A=0 \Leftrightarrow |A.x|<\epsilon,|A.y|<\epsilon\f]
429 *
430 * \retval true si la matrice est égale à la matrice nulle,
431 * \retval false sinon.
432 */
433 constexpr ARCCORE_HOST_DEVICE bool isNearlyZero(const Real2x2& v)
434 {
435 return math::isNearlyZero(v.x) && math::isNearlyZero(v.y);
436 }
437}
438
439/*---------------------------------------------------------------------------*/
440/*---------------------------------------------------------------------------*/
441
442inline constexpr ARCCORE_HOST_DEVICE bool Real2x2::
443isNearlyZero() const
444{
445 return math::isNearlyZero(*this);
446}
447
448/*---------------------------------------------------------------------------*/
449/*---------------------------------------------------------------------------*/
450
451} // End namespace Arcane
452
453/*---------------------------------------------------------------------------*/
454/*---------------------------------------------------------------------------*/
455
456#endif
Vue modifiable d'un tableau d'un type T.
Vue constante d'un tableau de type T.
Classe gérant un vecteur de réel de dimension 2.
Definition Real2.h:121
Classe gérant une matrice de réel de dimension 2x2.
Definition Real2x2.h:53
friend constexpr __host__ __device__ Real2x2 operator/(Real2x2 vec, Real sca)
Division par un scalaire.
Definition Real2x2.h:369
constexpr __host__ __device__ Real2x2 & sub(Real2x2 b)
Soustrait b au couple.
Definition Real2x2.h:187
constexpr __host__ __device__ Real2x2 operator+(Real2x2 b) const
Créé un couple qui vaut ce couple ajouté à b.
Definition Real2x2.h:251
constexpr __host__ __device__ Real2x2 & addSame(Real2 b)
Ajoute b à chaque composante du couple.
Definition Real2x2.h:203
friend constexpr __host__ __device__ Real2x2 operator*(Real sca, Real2x2 vec)
Multiplication par un scalaire.
Definition Real2x2.h:357
constexpr __host__ __device__ Real2x2 & div(Real2x2 b)
Multiple chaque composante du couple par la composant correspondant de b.
Definition Real2x2.h:196
__host__ __device__ Real & operator()(Integer i, Integer j)
Accès à la i-ème ligne et j-ème colonne.
Definition Real2x2.h:335
Real2 x
Première composante.
Definition Real2x2.h:110
std::ostream & printXy(std::ostream &o) const
Ecrit le couple sur le flot o sous la forme (x,y,z)
Definition Real2x2.cc:48
ARCANE_DEPRECATED_116 Real2x2(Real ax, Real ay, Real bx, Real by)
Construit le couple ((ax,bx),(ay,by)).
Definition Real2x2.h:72
Real2 y
Deuxième composante.
Definition Real2x2.h:111
constexpr __host__ __device__ Real2x2 & operator-=(Real2x2 b)
Soustrait b au couple.
Definition Real2x2.h:233
constexpr __host__ __device__ Real2x2 & assign(Real2 ax, Real2 ay)
Affecte à l'instance le couple (ax,ay,az)
Definition Real2x2.h:141
constexpr __host__ static __device__ Real2x2 null()
Construit la matrice nulle.
Definition Real2x2.h:116
constexpr __host__ __device__ bool operator!=(Real2x2 b) const
Compare deux couples. Pour la notion d'égalité, voir operator==()
Definition Real2x2.h:273
constexpr __host__ static __device__ Real2x2 fromColumns(Real ax, Real ay, Real bx, Real by)
Construit le couple ((ax,bx),(ay,by)).
Definition Real2x2.h:119
constexpr __host__ __device__ void operator/=(Real b)
Divise chaque composante du couple par la composant correspondant de b.
Definition Real2x2.h:245
constexpr __host__ __device__ Real2x2(ConstArrayView< Real > av)
Construit le couple ((av[0], av[1]), (av[2], av[3]))
Definition Real2x2.h:93
__host__ __device__ Real2 & operator()(Integer i)
Accès à la i-ème ligne (entre 0 et 1 inclus) de l'instance.
Definition Real2x2.h:324
constexpr __host__ __device__ ArrayView< Real > view()
Definition Real2x2.h:157
constexpr __host__ __device__ Real2x2(Real2 ax, Real2 ay)
Construit le couple (ax,ay)
Definition Real2x2.h:63
friend std::istream & operator>>(std::istream &i, Real2x2 &t)
Lit le couple t à partir du flot o.
Definition Real2x2.h:351
constexpr __host__ static __device__ Real2x2 fromLines(Real ax, Real bx, Real ay, Real by)
Construit le couple ((ax,bx),(ay,by)).
Definition Real2x2.h:125
constexpr __host__ __device__ Real2x2 & assign(Real2x2 f)
Copie le couple f.
Definition Real2x2.h:148
constexpr __host__ __device__ Real2x2 operator-(Real2x2 b) const
Créé un couple qui vaut b soustrait de ce couple.
Definition Real2x2.h:253
Real2x2(const Real2x2 &f)=default
Construit un couple identique à f.
__host__ __device__ Real2 & operator[](Integer i)
Accès à la i-ème ligne (entre 0 et 1 inclus) de l'instance.
Definition Real2x2.h:314
constexpr __host__ __device__ ConstArrayView< Real > constView() const
Definition Real2x2.h:164
constexpr __host__ __device__ bool operator==(Real2x2 b) const
Compare composant pas composante l'instance courante à b.
Definition Real2x2.h:263
constexpr __host__ __device__ Real2x2 & mulSame(Real2 b)
Multiplie chaque composante du couple par b.
Definition Real2x2.h:217
Real2x2 & operator=(const Real2x2 &f)=default
Opérateur de recopie.
__host__ __device__ Real operator()(Integer i, Integer j) const
Accès en lecture seule à la i-ème ligne et j-ème colonne.
Definition Real2x2.h:303
friend constexpr __host__ __device__ bool operator<(Real2x2 v1, Real2x2 v2)
Opérateur de comparaison.
Definition Real2x2.h:380
friend constexpr __host__ __device__ Real2x2 operator*(Real2x2 vec, Real sca)
Multiplication par un scalaire.
Definition Real2x2.h:363
__host__ __device__ Real2 operator[](Integer i) const
Accès en lecture seule à la i-ème (entre 0 et 1 inclus) ligne de l'instance.
Definition Real2x2.h:282
constexpr __host__ __device__ Real2x2()
Construit la matrice nulle.
Definition Real2x2.h:57
__host__ __device__ Real2 operator()(Integer i) const
Accès en lecture seule à la i-ème (entre 0 et 1 inclus) ligne de l'instance.
Definition Real2x2.h:292
constexpr __host__ __device__ bool isNearlyZero() const
Compare la matrice avec la matrice nulle.
Definition Real2x2.h:443
constexpr __host__ __device__ Real2x2 copy() const
Retourne une copie du couple.
Definition Real2x2.h:133
constexpr __host__ __device__ Real2x2 & reset()
Réinitialise le couple avec les constructeurs par défaut.
Definition Real2x2.h:135
friend std::ostream & operator<<(std::ostream &o, Real2x2 t)
Ecrit le couple t sur le flot o.
Definition Real2x2.h:345
constexpr __host__ __device__ Real2x2 & operator+=(Real2x2 b)
Ajoute b au couple.
Definition Real2x2.h:231
constexpr __host__ __device__ Real2x2 & divSame(Real2 b)
Divise chaque composante du couple par b.
Definition Real2x2.h:224
constexpr __host__ __device__ Real2x2 & subSame(Real2 b)
Soustrait b à chaque composante du couple.
Definition Real2x2.h:210
constexpr __host__ __device__ void operator*=(Real b)
Multiple chaque composante du couple par la composant correspondant de b.
Definition Real2x2.h:237
constexpr __host__ __device__ Real2x2 & add(Real2x2 b)
Ajoute b au couple.
Definition Real2x2.h:180
constexpr __host__ __device__ Real2x2 & operator=(Real v)
Affecte à l'instance le couple (v,v,v).
Definition Real2x2.h:102
constexpr __host__ __device__ Real2x2(Real v)
Construit l'instance avec le triplet (v,v,v).
Definition Real2x2.h:87
constexpr __host__ __device__ Real2x2(const Real2x2POD &f)
Construit un couple identique à f.
Definition Real2x2.h:81
constexpr __host__ __device__ Real2x2 operator-() const
Créé un tenseur opposé au tenseur actuel.
Definition Real2x2.h:255
constexpr __host__ static __device__ bool isEqual(const T &a, const T &b)
Compare a à b.
Definition Numeric.h:92
Espace de nom pour les fonctions mathématiques.
Definition MathUtils.h:41
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Int32 Integer
Type représentant un entier.
double Real
Type représentant un réel.
Structure POD pour un Real2x2.
Definition Real2x2.h:31