Arcane  4.2.1.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
MathUtils.h
Aller à la documentation de ce fichier.
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/* MathUtils.h (C) 2000-2025 */
9/* */
10/* Fonctions mathématiques diverses. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_CORE_MATHUTILS_H
13#define ARCANE_CORE_MATHUTILS_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arcane/utils/Math.h"
18#include "arcane/utils/ArrayView.h"
19#include "arcane/utils/NumericTypes.h"
20#include "arcane/utils/Real2x2.h"
21#include "arcane/utils/Real3.h"
22#include "arcane/utils/Real2.h"
23
24#include "arcane/core/Algorithm.h"
25
26/*---------------------------------------------------------------------------*/
27/*---------------------------------------------------------------------------*/
28
35namespace Arcane::math
36{
37
38/*---------------------------------------------------------------------------*/
39/*---------------------------------------------------------------------------*/
40
47ARCCORE_HOST_DEVICE inline Real3
48vecMul(Real3 u, Real3 v)
49{
50 return Real3(
51 u.y * v.z - u.z * v.y,
52 u.z * v.x - u.x * v.z,
53 u.x * v.y - u.y * v.x);
54}
55
56/*---------------------------------------------------------------------------*/
57/*---------------------------------------------------------------------------*/
58
65ARCCORE_HOST_DEVICE inline Real
66vecMul2D(Real3 u, Real3 v)
67{
68 return Real(u.x * v.y - u.y * v.x);
69}
70
71/*---------------------------------------------------------------------------*/
72/*---------------------------------------------------------------------------*/
73
78ARCCORE_HOST_DEVICE inline Real
79cross2D(Real3 u, Real3 v)
80{
81 return Real(u.x * v.y - u.y * v.x);
82}
83
84/*---------------------------------------------------------------------------*/
85/*---------------------------------------------------------------------------*/
86
93ARCCORE_HOST_DEVICE inline Real
94dot(Real2 u, Real2 v)
95{
96 return (u.x * v.x + u.y * v.y);
97}
98
99/*---------------------------------------------------------------------------*/
100/*---------------------------------------------------------------------------*/
101
111ARCCORE_HOST_DEVICE inline Real
112scaMul(Real2 u, Real2 v)
113{
114 return (u.x * v.x + u.y * v.y);
115}
116
117/*---------------------------------------------------------------------------*/
118/*---------------------------------------------------------------------------*/
119
127ARCCORE_HOST_DEVICE inline Real
128dot(Real3 u, Real3 v)
129{
130 return (u.x * v.x + u.y * v.y + u.z * v.z);
131}
132
133/*---------------------------------------------------------------------------*/
134/*---------------------------------------------------------------------------*/
135
145ARCCORE_HOST_DEVICE inline Real
146scaMul(Real3 u, Real3 v)
147{
148 return (u.x * v.x + u.y * v.y + u.z * v.z);
149}
150
151/*---------------------------------------------------------------------------*/
152/*---------------------------------------------------------------------------*/
153
160ARCCORE_HOST_DEVICE inline Real
161mixteMul(Real3 u, Real3 v, Real3 w)
162{
163 return dot(u, vecMul(v, w));
164}
165
166/*---------------------------------------------------------------------------*/
167/*---------------------------------------------------------------------------*/
168
172ARCCORE_HOST_DEVICE inline Real
173matDet(Real3 u, Real3 v, Real3 w)
174{
175 return (
176 (u.x * (v.y * w.z - v.z * w.y)) +
177 (u.y * (v.z * w.x - v.x * w.z)) +
178 (u.z * (v.x * w.y - v.y * w.x)));
179}
180
181/*---------------------------------------------------------------------------*/
182/*---------------------------------------------------------------------------*/
183
195inline Real3x3
196prodTens(Real3 u, Real3 v)
197{
198 return Real3x3(u.x * v, u.y * v, u.z * v);
199}
200
201/*---------------------------------------------------------------------------*/
202/*---------------------------------------------------------------------------*/
203
210ARCCORE_HOST_DEVICE inline Real3
211prodTensVec(Real3x3 t, Real3 v)
212{
213 return Real3(dot(t.x, v), dot(t.y, v), dot(t.z, v));
214}
215ARCCORE_HOST_DEVICE inline Real2
216prodTensVec(Real2x2 t, Real2 v)
217{
218 return Real2(dot(t.x, v), dot(t.y, v));
219}
220
221/*---------------------------------------------------------------------------*/
222/*---------------------------------------------------------------------------*/
223
230ARCCORE_HOST_DEVICE inline Real3
231prodVecTens(Real3 v, Real3x3 t)
232{
233 return Real3(dot(v, Real3(t.x.x, t.y.x, t.z.x)), dot(v, Real3(t.x.y, t.y.y, t.z.y)), dot(v, Real3(t.x.z, t.y.z, t.z.z)));
234}
235
236/*---------------------------------------------------------------------------*/
237/*---------------------------------------------------------------------------*/
238
243ARCCORE_HOST_DEVICE inline Real3x3
244matrixProduct(const Real3x3& t, const Real3x3& v)
245{
246 return Real3x3::fromLines(t.x.x * v.x.x + t.x.y * v.y.x + t.x.z * v.z.x,
247 t.x.x * v.x.y + t.x.y * v.y.y + t.x.z * v.z.y,
248 t.x.x * v.x.z + t.x.y * v.y.z + t.x.z * v.z.z,
249 t.y.x * v.x.x + t.y.y * v.y.x + t.y.z * v.z.x,
250 t.y.x * v.x.y + t.y.y * v.y.y + t.y.z * v.z.y,
251 t.y.x * v.x.z + t.y.y * v.y.z + t.y.z * v.z.z,
252 t.z.x * v.x.x + t.z.y * v.y.x + t.z.z * v.z.x,
253 t.z.x * v.x.y + t.z.y * v.y.y + t.z.z * v.z.y,
254 t.z.x * v.x.z + t.z.y * v.y.z + t.z.z * v.z.z);
255}
256
257/*---------------------------------------------------------------------------*/
258/*---------------------------------------------------------------------------*/
259
264ARCCORE_HOST_DEVICE inline Real3x3
265transpose(const Real3x3& t)
266{
267 return Real3x3(Real3(t.x.x, t.y.x, t.z.x),
268 Real3(t.x.y, t.y.y, t.z.y),
269 Real3(t.x.z, t.y.z, t.z.z));
270}
271
272/*---------------------------------------------------------------------------*/
273/*---------------------------------------------------------------------------*/
274
279ARCCORE_HOST_DEVICE inline Real3x3
280matrixTranspose(const Real3x3& t)
281{
282 return Real3x3(Real3(t.x.x, t.y.x, t.z.x),
283 Real3(t.x.y, t.y.y, t.z.y),
284 Real3(t.x.z, t.y.z, t.z.z));
285}
286
287/*---------------------------------------------------------------------------*/
288/*---------------------------------------------------------------------------*/
289
296ARCCORE_HOST_DEVICE inline Real
297doubleContraction(const Real3x3& u, const Real3x3& v)
298{
299 Real x1 = u.x.x * v.x.x;
300 Real x2 = u.x.y * v.x.y;
301 Real x3 = u.x.z * v.x.z;
302
303 Real y1 = u.y.x * v.y.x;
304 Real y2 = u.y.y * v.y.y;
305 Real y3 = u.y.z * v.y.z;
306
307 Real z1 = u.z.x * v.z.x;
308 Real z2 = u.z.y * v.z.y;
309 Real z3 = u.z.z * v.z.z;
310
311 return x1 + x2 + x3 + y1 + y2 + y3 + z1 + z2 + z3;
312}
313
314/*---------------------------------------------------------------------------*/
315/*---------------------------------------------------------------------------*/
316
323ARCCORE_HOST_DEVICE inline Real
324doubleContraction(const Real2x2& u, const Real2x2& v)
325{
326 Real x1 = u.x.x * v.x.x;
327 Real x2 = u.x.y * v.x.y;
328
329 Real y1 = u.y.x * v.y.x;
330 Real y2 = u.y.y * v.y.y;
331
332 return x1 + x2 + y1 + y2;
333}
334
335/*---------------------------------------------------------------------------*/
336/*---------------------------------------------------------------------------*/
337
338/*---------------------------------------------------------------------------*/
339/*---------------------------------------------------------------------------*/
340
345ARCCORE_HOST_DEVICE inline Real2
346min(Real2 a, Real2 b)
347{
348 return Real2(math::min(a.x, b.x), math::min(a.y, b.y));
349}
350
355ARCCORE_HOST_DEVICE inline Real3
356min(Real3 a, Real3 b)
357{
358 return Real3(math::min(a.x, b.x), math::min(a.y, b.y), math::min(a.z, b.z));
359}
360
365ARCCORE_HOST_DEVICE inline Real2x2
366min(const Real2x2& a, const Real2x2& b)
367{
368 return Real2x2(math::min(a.x, b.x), math::min(a.y, b.y));
369}
370
375ARCCORE_HOST_DEVICE inline Real3x3
376min(const Real3x3& a, const Real3x3& b)
377{
378 return Real3x3(math::min(a.x, b.x), math::min(a.y, b.y), math::min(a.z, b.z));
379}
380
381/*---------------------------------------------------------------------------*/
382/*---------------------------------------------------------------------------*/
383
391template <class T> inline T
392min(const T& a, const T& b, const T& c)
393{
394 return ((a < b) ? ((a < c) ? a : ((b < c) ? b : c)) : ((b < c) ? b : c));
395}
396
397/*---------------------------------------------------------------------------*/
398/*---------------------------------------------------------------------------*/
399
406template <class T> inline T
407max(const T& a, const T& b, const T& c)
408{
409 return ((a > b) ? ((a > c) ? a : c) : ((b > c) ? b : c));
410}
411
412/*---------------------------------------------------------------------------*/
413/*---------------------------------------------------------------------------*/
414
419ARCCORE_HOST_DEVICE inline Real2
420max(Real2 a, Real2 b)
421{
422 return Real2(math::max(a.x, b.x), math::max(a.y, b.y));
423}
424
429ARCCORE_HOST_DEVICE inline Real3
430max(Real3 a, Real3 b)
431{
432 return Real3(math::max(a.x, b.x), math::max(a.y, b.y), math::max(a.z, b.z));
433}
434
439ARCCORE_HOST_DEVICE inline Real2x2
440max(const Real2x2& a, const Real2x2& b)
441{
442 return Real2x2(math::max(a.x, b.x), math::max(a.y, b.y));
443}
444
449ARCCORE_HOST_DEVICE inline Real3x3
450max(const Real3x3& a, const Real3x3& b)
451{
452 return Real3x3(math::max(a.x, b.x), math::max(a.y, b.y), math::max(a.z, b.z));
453}
454
455/*---------------------------------------------------------------------------*/
456/*---------------------------------------------------------------------------*/
457
458/*---------------------------------------------------------------------------*/
459/*---------------------------------------------------------------------------*/
460
464ARCCORE_HOST_DEVICE inline Real
465min4Real(Real a, Real b, Real c, Real d)
466{
467 return min(min(a, b), min(c, d));
468}
469
470/*---------------------------------------------------------------------------*/
471/*---------------------------------------------------------------------------*/
472
476ARCCORE_HOST_DEVICE inline Real
477max4Real(Real a, Real b, Real c, Real d)
478{
479 return max(max(a, b), max(c, d));
480}
481
482/*---------------------------------------------------------------------------*/
483/*---------------------------------------------------------------------------*/
484
488ARCCORE_HOST_DEVICE inline Real
489min8Real(const Real a[8])
490{
491 return min(min4Real(a[0], a[1], a[2], a[3]), min4Real(a[4], a[5], a[6], a[7]));
492}
493
494/*---------------------------------------------------------------------------*/
495/*---------------------------------------------------------------------------*/
496
500inline Real max8Real(const Real a[8])
501{
502 return max(max4Real(a[0], a[1], a[2], a[3]), max4Real(a[4], a[5], a[6], a[7]));
503}
504
505/*---------------------------------------------------------------------------*/
506/*---------------------------------------------------------------------------*/
507
512ARCCORE_HOST_DEVICE inline Real
513minMod(Real a, Real b, Real c, Real d)
514{
515 Real zero = 0.;
516 return min4Real(max(a, zero), max(b, zero), max(c, zero), max(d, zero)) + max4Real(min(a, zero), min(b, zero), min(c, zero), min(d, zero));
517}
518/*---------------------------------------------------------------------------*/
519/*---------------------------------------------------------------------------*/
520
525ARCCORE_HOST_DEVICE inline Real
526minMod2(Real a, Real b)
527{
528 Real zero = 0.;
529 return min(max(a, zero), max(b, zero)) + max(min(a, zero), min(b, zero));
530}
531/*---------------------------------------------------------------------------*/
532/*---------------------------------------------------------------------------*/
533
539ARCCORE_HOST_DEVICE inline Real
540maxMod2(Real a, Real b)
541{
542 Real zero = 0.;
543 return max(max(a, zero), max(b, zero)) + min(min(a, zero), min(b, zero));
544}
545
546/*---------------------------------------------------------------------------*/
547/*---------------------------------------------------------------------------*/
548
556inline Real
557relativeError(Real a, Real b)
558{
559 Real sum = math::abs(a) + math::abs(b);
560 return (isZero(sum)) ? (a - b) : (a - b) / sum;
561}
562
563/*---------------------------------------------------------------------------*/
564/*---------------------------------------------------------------------------*/
565
573inline Real
574relativeError(const Real3x3& T1, const Real3x3& T2)
575{
576 Real err = 0;
577 err = math::max(err, math::abs(relativeError(T1.x.x, T2.x.x)));
578 err = math::max(err, math::abs(relativeError(T1.x.y, T2.x.y)));
579 err = math::max(err, math::abs(relativeError(T1.x.z, T2.x.z)));
580 err = math::max(err, math::abs(relativeError(T1.y.x, T2.y.x)));
581 err = math::max(err, math::abs(relativeError(T1.y.y, T2.y.y)));
582 err = math::max(err, math::abs(relativeError(T1.y.z, T2.y.z)));
583 err = math::max(err, math::abs(relativeError(T1.z.x, T2.z.x)));
584 err = math::max(err, math::abs(relativeError(T1.z.y, T2.z.y)));
585 err = math::max(err, math::abs(relativeError(T1.z.z, T2.z.z)));
586
587 return (err);
588}
589
590/*---------------------------------------------------------------------------*/
591/*---------------------------------------------------------------------------*/
592
600inline Real
601relativeError2(Real a, Real b)
602{
603 Real sum = math::abs(b);
604 return (isZero(sum)) ? (a - b) : (a - b) / sum;
605}
606
607/*---------------------------------------------------------------------------*/
608/*---------------------------------------------------------------------------*/
609
617inline Real
618relativeError1(Real a, Real b)
619{
620 Real sum = math::abs(a);
621 return (isZero(sum)) ? (a - b) : (a - b) / sum;
622}
623
624/*---------------------------------------------------------------------------*/
625/*---------------------------------------------------------------------------*/
626
630inline bool
631searchExtrema(ConstArrayView<Real2> array, Real& xmin, Real& xmax,
632 Real& ymin, Real& ymax, bool need_init)
633{
634 if (need_init) {
635 xmin = ymin = 0.;
636 xmax = ymax = 1.;
637 }
638
639 Integer size = array.size();
640 if (size == 0)
641 return false;
642
643 if (need_init) {
644 xmin = xmax = array[0].x;
645 ymin = ymax = array[0].y;
646 }
647
648 for (Integer i = 1; i < size; ++i) {
649 if (array[i].x < xmin)
650 xmin = array[i].x;
651 if (array[i].x > xmax)
652 xmax = array[i].x;
653
654 if (array[i].y < ymin)
655 ymin = array[i].y;
656 if (array[i].y > ymax)
657 ymax = array[i].y;
658 }
659 return true;
660}
661
662/*---------------------------------------------------------------------------*/
663/*---------------------------------------------------------------------------*/
664
668ARCCORE_HOST_DEVICE inline Real
669matrixDeterminant(Real3x3 m)
670{
671 return m.determinant();
672}
673
674/*---------------------------------------------------------------------------*/
675/*---------------------------------------------------------------------------*/
676
682inline Real
683normeR3(Real3 v1)
684{
685 Real norme = math::sqrt((v1.x) * (v1.x) + (v1.y) * (v1.y) + (v1.z) * (v1.z));
686 return norme;
687}
688/*---------------------------------------------------------------------------*/
689/*---------------------------------------------------------------------------*/
690
694ARCCORE_HOST_DEVICE inline Real3x3
695matrix3x3Id()
696{
697 return Real3x3(Real3(1.0, 0.0, 0.0),
698 Real3(0.0, 1.0, 0.0),
699 Real3(0.0, 0.0, 1.0));
700}
701
702/*---------------------------------------------------------------------------*/
703/*---------------------------------------------------------------------------*/
704
708ARCCORE_HOST_DEVICE inline Real3x3
709inverseMatrix(const Real3x3& m, Real d)
710{
711 Real3x3 inv(Real3(m.y.y * m.z.z - m.y.z * m.z.y, -m.x.y * m.z.z + m.x.z * m.z.y, m.x.y * m.y.z - m.x.z * m.y.y),
712 Real3(m.z.x * m.y.z - m.y.x * m.z.z, -m.z.x * m.x.z + m.x.x * m.z.z, m.y.x * m.x.z - m.x.x * m.y.z),
713 Real3(-m.z.x * m.y.y + m.y.x * m.z.y, m.z.x * m.x.y - m.x.x * m.z.y, -m.y.x * m.x.y + m.x.x * m.y.y));
714 inv /= d;
715 return inv;
716}
717
718/*---------------------------------------------------------------------------*/
719/*---------------------------------------------------------------------------*/
720
724ARCCORE_HOST_DEVICE inline Real3x3
725inverseMatrix(const Real3x3& m)
726{
727 Real d = m.determinant();
728 return inverseMatrix(m, d);
729}
730
731/*---------------------------------------------------------------------------*/
732/*---------------------------------------------------------------------------*/
733
739inline Real3
740crossProduct3(Real3 v1, Real3 v2)
741{
742 Real3 v;
743 v.x = v1.y * v2.z - v1.z * v2.y;
744 v.y = v2.x * v1.z - v2.z * v1.x;
745 v.z = v1.x * v2.y - v1.y * v2.x;
746
747 return v;
748}
749
750/*---------------------------------------------------------------------------*/
751/*---------------------------------------------------------------------------*/
752
757ARCCORE_HOST_DEVICE inline Real3
758cross(Real3 v1, Real3 v2)
759{
760 Real3 v;
761 v.x = v1.y * v2.z - v1.z * v2.y;
762 v.y = v2.x * v1.z - v2.z * v1.x;
763 v.z = v1.x * v2.y - v1.y * v2.x;
764
765 return v;
766}
767
768/*---------------------------------------------------------------------------*/
769/*---------------------------------------------------------------------------*/
770
776ARCCORE_HOST_DEVICE inline Real3
777normalizeReal3(Real3 v)
778{
779 Real norme = math::sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
780
781 return Real3(v.x / norme, v.y / norme, v.z / norme);
782}
783
784/*---------------------------------------------------------------------------*/
785/*---------------------------------------------------------------------------*/
786
791inline Real3
792normalizedCrossProduct3(Real3 v1, Real3 v2)
793{
794 return normalizeReal3(cross(v1, v2));
795}
796
797/*---------------------------------------------------------------------------*/
798/*---------------------------------------------------------------------------*/
799
807inline Real3x3
808matrix3x3Transp(Real3x3 m)
809{
810 return Real3x3::fromColumns(m.x.x, m.x.y, m.x.z,
811 m.y.x, m.y.y, m.y.z,
812 m.z.x, m.z.y, m.z.z);
813}
814
815/*---------------------------------------------------------------------------*/
816/*---------------------------------------------------------------------------*/
817
825inline Real3x3
826matrix3x3Prod(Real3x3 m1, Real3x3 m2)
827{
828 return Real3x3::fromColumns(
829 m1.x.x * m2.x.x + m1.y.x * m2.x.y + m1.z.x * m2.x.z,
830 m1.x.y * m2.x.x + m1.y.y * m2.x.y + m1.z.y * m2.x.z,
831 m1.x.z * m2.x.x + m1.y.z * m2.x.y + m1.z.z * m2.x.z,
832 m1.x.x * m2.y.x + m1.y.x * m2.y.y + m1.z.x * m2.y.z,
833 m1.x.y * m2.y.x + m1.y.y * m2.y.y + m1.z.y * m2.y.z,
834 m1.x.z * m2.y.x + m1.y.z * m2.y.y + m1.z.z * m2.y.z,
835 m1.x.x * m2.z.x + m1.y.x * m2.z.y + m1.z.x * m2.z.z,
836 m1.x.y * m2.z.x + m1.y.y * m2.z.y + m1.z.y * m2.z.z,
837 m1.x.z * m2.z.x + m1.y.z * m2.z.y + m1.z.z * m2.z.z);
838}
839
840/*---------------------------------------------------------------------------*/
841/*---------------------------------------------------------------------------*/
842
846ARCCORE_HOST_DEVICE inline Real3
847multiply(const Real3x3& m, Real3 v)
848{
849 return Real3(m.x.x * v.x + m.x.y * v.y + m.x.z * v.z,
850 m.y.x * v.x + m.y.y * v.y + m.y.z * v.z,
851 m.z.x * v.x + m.z.y * v.y + m.z.z * v.z);
852}
853/*---------------------------------------------------------------------------*/
854/*---------------------------------------------------------------------------*/
855
859inline bool
860isNearlyId(Real3x3 m, Real epsilon = 1.e-10)
861{
862 static Real3x3 id = Real3x3(Real3(1., 0., 0.), Real3(0., 1., 0.), Real3(0., 0., 1.));
863 // static Real epsilon = 1.e-10;
864
865 Real3x3 m0 = m - id;
866
867 return (m0.x.x < epsilon) && (m0.x.y < epsilon) && (m0.x.z < epsilon) &&
868 (m0.y.x < epsilon) && (m0.y.y < epsilon) && (m0.y.z < epsilon) &&
869 (m0.z.x < epsilon) && (m0.z.y < epsilon) && (m0.z.z < epsilon);
870}
871
872/*---------------------------------------------------------------------------*/
873/*---------------------------------------------------------------------------*/
874
879inline Real3
880planarSymmetric(Real3 u, Real3 n)
881{
882 Real3 u_tilde;
883#ifdef ARCANE_CHECK
884 if (n.normL2() == 0) {
885 arcaneMathError(static_cast<double>(n.normL2()), "planarSymetric");
886 }
887#endif
888 Real3 norm = n / n.normL2();
889 u_tilde = u - 2.0 * dot(norm, u) * norm;
890 return u_tilde;
891}
892
893/*---------------------------------------------------------------------------*/
894/*---------------------------------------------------------------------------*/
895
900inline Real3
901axisSymmetric(Real3 u, Real3 a)
902{
903 Real3 u_tilde;
904#ifdef ARCANE_CHECK
905 if (a.normL2() == 0) {
906 arcaneMathError(static_cast<double>(a.normL2()), "axisSymetric");
907 }
908#endif
909 Real3 norm = a / a.normL2();
910 u_tilde = 2.0 * dot(u, norm) * norm - u;
911 return u_tilde;
912}
913
914/*---------------------------------------------------------------------------*/
915/*---------------------------------------------------------------------------*/
916
925template <typename T> inline void
926add(ArrayView<T> lhs, ConstArrayView<T> copy_array)
927{
928 Integer size = lhs.size();
929 ARCANE_ASSERT((copy_array.size() >= size), ("Bad size %d %d", copy_array.size(), size));
930 const T* copy_begin = copy_array.data();
931 T* to_ptr = lhs.data();
932 for (Integer i = 0; i < size; ++i)
933 to_ptr[i] += copy_begin[i];
934}
935
944template <typename T> inline void
945add(ArrayView<T> lhs, ArrayView<T> copy_array)
946{
947 Integer size = lhs.size();
948 ARCANE_ASSERT((copy_array.size() >= size), ("Bad size %d %d", copy_array.size(), size));
949 const T* copy_begin = copy_array.data();
950 T* to_ptr = lhs.data();
951 for (Integer i = 0; i < size; ++i)
952 to_ptr[i] += copy_begin[i];
953}
954
963template <typename T> inline void
964sub(ArrayView<T> lhs, ConstArrayView<T> copy_array)
965{
966 Integer size = lhs.size();
967 ARCANE_ASSERT((copy_array.size() >= size), ("Bad size %d %d", copy_array.size(), size));
968 const T* copy_begin = copy_array.data();
969 T* to_ptr = lhs.data();
970 for (Integer i = 0; i < size; ++i)
971 to_ptr[i] -= copy_begin[i];
972}
973
982template <typename T> inline void
983sub(ArrayView<T> lhs, ArrayView<T> copy_array)
984{
985 Integer size = lhs.size();
986 ARCANE_ASSERT((copy_array.size() >= size), ("Bad size %d %d", copy_array.size(), size));
987 const T* copy_begin = copy_array.data();
988 T* to_ptr = lhs.data();
989 for (Integer i = 0; i < size; ++i)
990 to_ptr[i] -= copy_begin[i];
991}
992
1003template <typename T> inline void
1004mult(ArrayView<T> lhs, ConstArrayView<T> copy_array)
1005{
1006 Integer size = lhs.size();
1007 ARCANE_ASSERT((copy_array.size() >= size), ("Bad size %d %d", copy_array.size(), size));
1008 const T* copy_begin = copy_array.data();
1009 T* to_ptr = lhs.data();
1010 for (Integer i = 0; i < size; ++i)
1011 to_ptr[i] *= copy_begin[i];
1012}
1013
1024template <typename T> inline void
1025mult(ArrayView<T> lhs, ArrayView<T> copy_array)
1026{
1027 math::mult(lhs, copy_array.constView());
1028}
1029
1033template <typename T> inline void
1034mult(ArrayView<T> lhs, T o)
1035{
1036 T* ptr = lhs.data();
1037 for (Integer i = 0, size = lhs.size(); i < size; ++i)
1038 ptr[i] *= o;
1039}
1040
1044template <typename T> inline void
1045power(ArrayView<T> lhs, T o)
1046{
1047 T* ptr = lhs.data();
1048 for (Integer i = 0, size = lhs.size(); i < size; ++i)
1049 ptr[i] = math::pow(ptr[i], o);
1050}
1051
1052/*---------------------------------------------------------------------------*/
1053/*---------------------------------------------------------------------------*/
1054
1055} // namespace Arcane::math
1056
1057/*---------------------------------------------------------------------------*/
1058/*---------------------------------------------------------------------------*/
1059
1060#endif
Arcane::ArrayView
Vue modifiable d'un tableau d'un type T.
Definition arccore/src/base/arccore/base/ArrayView.h:95
Arcane::ArrayView::data
constexpr const_pointer data() const noexcept
Pointeur sur le début de la vue.
Definition arccore/src/base/arccore/base/ArrayView.h:448
Arcane::ArrayView::constView
constexpr ConstArrayView< T > constView() const noexcept
Vue constante sur cette vue.
Definition arccore/src/base/arccore/base/ArrayView.h:320
Arcane::ArrayView::size
constexpr Integer size() const noexcept
Retourne la taille du tableau.
Definition arccore/src/base/arccore/base/ArrayView.h:244
Arcane::ConstArrayView
Vue constante d'un tableau de type T.
Definition arccore/src/base/arccore/base/ArrayView.h:548
Arcane::ConstArrayView::data
constexpr const_pointer data() const noexcept
Pointeur sur la mémoire allouée.
Definition arccore/src/base/arccore/base/ArrayView.h:783
Arcane::ConstArrayView::size
constexpr Integer size() const noexcept
Nombre d'éléments du tableau.
Definition arccore/src/base/arccore/base/ArrayView.h:737
Arcane::Real2
Classe gérant un vecteur réel 2-dimensionnel.
Definition arccore/src/base/arccore/base/Real2.h:122
Arcane::Real2x2
Classe gérant une matrice 2x2 de réels.
Definition arccore/src/base/arccore/base/Real2x2.h:55
Arcane::Real3
Classe gérant un vecteur réel de 3 dimensions.
Definition arccore/src/base/arccore/base/Real3.h:128
Arcane::Real3::normL2
__host__ __device__ Real normL2() const
Retourne la norme L2 du triplet $ .
Definition MathReal3.h:100
Arcane::Real3x3
Classe gérant une matrice réelle 3x3.
Definition arccore/src/base/arccore/base/Real3x3.h:67
Arcane::Real3x3::z
Real3 z
premier élément du triplet
Definition arccore/src/base/arccore/base/Real3x3.h:133
Arcane::Real3x3::fromLines
constexpr __host__ static __device__ Real3x3 fromLines(Real ax, Real bx, Real cx, Real ay, Real by, Real cy, Real az, Real bz, Real cz)
Construit la matrice ((ax,bx,cx),(ay,by,cy),(az,bz,cz)).
Definition arccore/src/base/arccore/base/Real3x3.h:153
Arcane::Real3x3::y
Real3 y
premier élément du triplet
Definition arccore/src/base/arccore/base/Real3x3.h:132
Arcane::Real3x3::determinant
constexpr __host__ __device__ Real determinant() const
Déterminant de la matrice.
Definition arccore/src/base/arccore/base/Real3x3.h:368
Arcane::Real3x3::fromColumns
constexpr __host__ static __device__ Real3x3 fromColumns(Real ax, Real ay, Real az, Real bx, Real by, Real bz, Real cx, Real cy, Real cz)
Construit la matrice ((ax,bx,cx),(ay,by,cy),(az,bz,cz)).
Definition arccore/src/base/arccore/base/Real3x3.h:147
Arcane::Real3x3::x
Real3 x
premier élément du triplet
Definition arccore/src/base/arccore/base/Real3x3.h:131
Arcane::math::vecMul2D
__host__ __device__ Real vecMul2D(Real3 u, Real3 v)
Produit vectoriel de u par v dans .
Definition MathUtils.h:66
Arcane::math::dot
__host__ __device__ Real dot(Real2 u, Real2 v)
Produit scalaire de u par v dans .
Definition MathUtils.h:94
Arcane::math::min
__host__ __device__ Real2 min(Real2 a, Real2 b)
Retourne le minimum de deux Real2.
Definition MathUtils.h:346
Arcane::math::max
T max(const T &a, const T &b, const T &c)
Retourne le maximum de trois éléments.
Definition MathUtils.h:407
Arcane::math::vecMul
__host__ __device__ Real3 vecMul(Real3 u, Real3 v)
Produit vectoriel de u par v dans .
Definition MathUtils.h:48
Arcane::math::normalizedCrossProduct3
Real3 normalizedCrossProduct3(Real3 v1, Real3 v2)
Produit vectoriel normalisé.
Definition MathUtils.h:792
Arcane::math::minMod
__host__ __device__ Real minMod(Real a, Real b, Real c, Real d)
retourne le Min mod de quatre Real
Definition MathUtils.h:513
Arcane::math::minMod2
__host__ __device__ Real minMod2(Real a, Real b)
retourne le Min mod de deux Reals
Definition MathUtils.h:526
Arcane::math::cross2D
__host__ __device__ Real cross2D(Real3 u, Real3 v)
Produit vectoriel de u par v dans .
Definition MathUtils.h:79
Arcane::math::scaMul
__host__ __device__ Real scaMul(Real2 u, Real2 v)
Produit scalaire de u par v dans .
Definition MathUtils.h:112
Arcane::math::prodVecTens
__host__ __device__ Real3 prodVecTens(Real3 v, Real3x3 t)
Produit transposé(vecteur) matrice entre la transposée d'un vecteur et une matrice.
Definition MathUtils.h:231
Arcane::math::cross
__host__ __device__ Real3 cross(Real3 v1, Real3 v2)
Produit vectoriel de deux vecteurs à 3 composantes.
Definition MathUtils.h:758
Arcane::math::normalizeReal3
__host__ __device__ Real3 normalizeReal3(Real3 v)
Normalisation d'un Real3.
Definition MathUtils.h:777
Arcane::math::prodTens
Real3x3 prodTens(Real3 u, Real3 v)
Produit tensoriel de deux vecteurs Real3.
Definition MathUtils.h:196
Arcane::math::maxMod2
__host__ __device__ Real maxMod2(Real a, Real b)
retourne le Max mod de deux Reals
Definition MathUtils.h:540
Arcane::math::matrixProduct
__host__ __device__ Real3x3 matrixProduct(const Real3x3 &t, const Real3x3 &v)
Produit matrice-matrice entre deux tenseurs.
Definition MathUtils.h:244
Arcane::math::matrix3x3Transp
Real3x3 matrix3x3Transp(Real3x3 m)
Definition MathUtils.h:808
Arcane::math::planarSymmetric
Real3 planarSymmetric(Real3 u, Real3 n)
Symétrie d'un vecteur u par rapport à un plan de normale n.
Definition MathUtils.h:880
Arcane::math::prodTensVec
__host__ __device__ Real3 prodTensVec(Real3x3 t, Real3 v)
Produit matrice-vecteur entre un tenseur et un vecteur.
Definition MathUtils.h:211
Arcane::math::axisSymmetric
Real3 axisSymmetric(Real3 u, Real3 a)
Symétrie d'un vecteur u par rapport à un axe de vecteur directeur a .
Definition MathUtils.h:901
Arcane::math::mixteMul
__host__ __device__ Real mixteMul(Real3 u, Real3 v, Real3 w)
Produit mixte de u, v et w.
Definition MathUtils.h:161
Arcane::math::matrixTranspose
__host__ __device__ Real3x3 matrixTranspose(const Real3x3 &t)
Transpose la matrice.
Definition MathUtils.h:280
Arcane::math
Espace de nom pour les fonctions mathématiques.
Definition MathUtils.h:36
Arcane::math::relativeError
Real relativeError(Real a, Real b)
Retourne l'erreur relative entre deux scalaires a et b.
Definition MathUtils.h:557
Arcane::math::min8Real
__host__ __device__ Real min8Real(const Real a[8])
retourne le min de huit Real
Definition MathUtils.h:489
Arcane::math::pow
apfloat pow(apfloat x, apfloat y)
Fonction puissance.
Definition MathApfloat.h:84
Arcane::math::relativeError2
Real relativeError2(Real a, Real b)
Retourne l'erreur relative entre deux scalaires a et b relativement à b.
Definition MathUtils.h:601
Arcane::math::power
void power(ArrayView< T > lhs, T o)
Met à la puissance o tous les éléments du tableau.
Definition MathUtils.h:1045
Arcane::math::normeR3
Real normeR3(Real3 v1)
Norme d'un vecteur.
Definition MathUtils.h:683
Arcane::math::relativeError1
Real relativeError1(Real a, Real b)
Retourne l'erreur relative entre deux scalaires a et b relativement à a.
Definition MathUtils.h:618
Arcane::math::isNearlyId
bool isNearlyId(Real3x3 m, Real epsilon=1.e-10)
Vérifie qu'une matrice vaut bien la matrice identité.
Definition MathUtils.h:860
Arcane::math::searchExtrema
bool searchExtrema(ConstArrayView< Real2 > array, Real &xmin, Real &xmax, Real &ymin, Real &ymax, bool need_init)
Recherche les valeurs extrèmes d'un tableau de couple (x,y).
Definition MathUtils.h:631
Arcane::math::doubleContraction
__host__ __device__ Real doubleContraction(const Real3x3 &u, const Real3x3 &v)
Definition MathUtils.h:297
Arcane::math::multiply
__host__ __device__ Real3 multiply(const Real3x3 &m, Real3 v)
Produit matrice 3x3 . vecteur.
Definition MathUtils.h:847
Arcane::math::isZero
bool isZero(const BuiltInProxy< _Type > &a)
Teste si une valeur est exactement égale à zéro.
Definition BuiltInProxy.h:164
Arcane::math::matDet
__host__ __device__ Real matDet(Real3 u, Real3 v, Real3 w)
Déterminant de la matrice u,v,w.
Definition MathUtils.h:173
Arcane::math::max8Real
Real max8Real(const Real a[8])
retourne le max de huit Real
Definition MathUtils.h:500
Arcane::math::matrix3x3Id
__host__ __device__ Real3x3 matrix3x3Id()
Matrice identite.
Definition MathUtils.h:695
Arcane::math::matrixDeterminant
__host__ __device__ Real matrixDeterminant(Real3x3 m)
Calcul du déterminant d'une matrice 3x3.
Definition MathUtils.h:669
Arcane::math::mult
void mult(ArrayView< T > lhs, ConstArrayView< T > copy_array)
Multiplie terme à terme les éléments de l'instance par les éléments du tableau copy_array.
Definition MathUtils.h:1004
Arcane::math::min4Real
__host__ __device__ Real min4Real(Real a, Real b, Real c, Real d)
retourne le min de quatre Real
Definition MathUtils.h:465
Arcane::math::crossProduct3
Real3 crossProduct3(Real3 v1, Real3 v2)
Produit vectoriel de deux vecteurs à 3 composantes.
Definition MathUtils.h:740
Arcane::math::max4Real
__host__ __device__ Real max4Real(Real a, Real b, Real c, Real d)
retourne le max de quatre Real
Definition MathUtils.h:477
Arcane::math::matrix3x3Prod
Real3x3 matrix3x3Prod(Real3x3 m1, Real3x3 m2)
Multiplication de 2 matrices 3x3.
Definition MathUtils.h:826
Arcane::math::sqrt
apfloat sqrt(apfloat v)
Racine carrée de v.
Definition MathApfloat.h:65
Arcane::math::inverseMatrix
__host__ __device__ Real3x3 inverseMatrix(const Real3x3 &m, Real d)
Calcul de l'inverse d'une matrice m en supposant connu son déterminant d.
Definition MathUtils.h:709
Arcane::math::sub
void sub(ArrayView< T > lhs, ConstArrayView< T > copy_array)
Soustrait le tableau copy_array de l'instance.
Definition MathUtils.h:964
Arcane::math::transpose
__host__ __device__ Real3x3 transpose(const Real3x3 &t)
Transpose la matrice.
Definition MathUtils.h:265
Arcane::math::add
void add(ArrayView< T > lhs, ConstArrayView< T > copy_array)
Ajoute le tableau copy_array dans l'instance.
Definition MathUtils.h:926
Arcane::Integer
Int32 Integer
Type représentant un entier.
Definition ArccoreGlobal.h:293
Arcane::Real
double Real
Type représentant un réel.
Definition ArccoreGlobal.h:275
Arcane::arcaneMathError
__host__ __device__ void arcaneMathError(long double arg_value, const char *func_name)
Signale un argument invalide d'une fonction mathématique.
Definition ArcaneGlobal.h:292
Arcane::Real2POD::y
Real y
deuxième composante du couple
Definition arccore/src/base/arccore/base/Real2.h:37
Arcane::Real2POD::x
Real x
première composante du couple
Definition arccore/src/base/arccore/base/Real2.h:36
Arcane::Real3POD::y
Real y
deuxième composante du triplet
Definition arccore/src/base/arccore/base/Real3.h:34
Arcane::Real3POD::z
Real z
troisième composante du triplet
Definition arccore/src/base/arccore/base/Real3.h:35
Arcane::Real3POD::x
Real x
première composante du triplet
Definition arccore/src/base/arccore/base/Real3.h:33