Arcane  v3.16.2.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
VariableDataTypeTraits.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/* VariableDataTypeTraits.h (C) 2000-2025 */
9/* */
10/* Classes spécialisées pour caractériser les types de données. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_CORE_VARIABLEDATATYPETRAITS_H
13#define ARCANE_CORE_VARIABLEDATATYPETRAITS_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arcane/utils/PlatformUtils.h"
18#include "arcane/utils/ValueConvert.h"
19#include "arcane/utils/BFloat16.h"
20#include "arcane/utils/Float16.h"
21#include "arcane/utils/Float128.h"
22#include "arcane/utils/Int128.h"
23
25
26#include <cmath>
27
28/*---------------------------------------------------------------------------*/
29/*---------------------------------------------------------------------------*/
30
31namespace Arcane
32{
33
34/*---------------------------------------------------------------------------*/
35/*---------------------------------------------------------------------------*/
36/*!
37 * \brief Ecriture dans la chaine \a s d'un type basique de valeur \a v.
38 */
39template <typename DataType> inline void
40builtInDumpValue(String& s, const DataType& v)
41{
42 std::ostringstream sbuf;
43 sbuf << v << '\0';
44 s = sbuf.str();
45}
46
47/*---------------------------------------------------------------------------*/
48/*---------------------------------------------------------------------------*/
49/*!
50 * \internal
51 * \brief Classe template d'informations sur un type d'une variable.
52 *
53 * Cette classe doit être spécialisée pour chaque type.
54 */
55template <typename DataType>
57{
58 public:
59
60 static eDataType type() { return DT_Unknown; }
61};
62
63/*---------------------------------------------------------------------------*/
64/*---------------------------------------------------------------------------*/
65
66/*---------------------------------------------------------------------------*/
67/*---------------------------------------------------------------------------*/
68/*!
69 * \internal
70 * \brief Spécialisation de VariableDataTypeTraitsT pour le type <tt>byte</tt>.
71 */
72template <>
73class ARCANE_CORE_EXPORT VariableDataTypeTraitsT<Byte>
74{
75 public:
76
77 //! Type du paramètre template
78 typedef Byte Type;
79
80 //! Indique si le type peut être sauvé et relu
82
83 //! Indique si le type peut être subir une réduction
85
86 //! Indique si le type peut être subir une réduction Min/Max
88
89 //! Indique si le type est numérique
91
92 typedef Byte BasicType;
93
94 static constexpr Integer nbBasicType() { return 1; }
95
96 typedef Byte NormType;
97
98 public:
99
100 //! Retourne le nom du type de la variable
101 static constexpr const char* typeName() { return "Byte"; }
102 //! Retourne le type de la variable
103 static constexpr eDataType type() { return DT_Byte; }
104 //! Ecrit dans la chaîne \a s la valeur de \a v
105 static void dumpValue(String& s, const Type& v) { builtInDumpValue(s, v); }
106 /*!
107 * \brief Stocke la conversion de la chaîne \a s en le type #Type dans \a v
108 * \retval true en cas d'échec,
109 * \retval false si la conversion est un succès
110 */
111 static bool getValue(Type& v, const String& s) { return builtInGetValue(v, s); }
112
113 static bool verifDifferent(Byte v1, Byte v2, Byte& diff,
114 [[maybe_unused]] bool is_nan_equal = false)
115 {
116 return _verifDifferent(v1, v2, diff, v1);
117 }
118 static bool verifDifferentNorm(Type v1, Type v2, Type& diff, Type norm,
119 [[maybe_unused]] bool is_nan_equal = false)
120 {
121 return _verifDifferent(v1, v2, diff, norm);
122 }
123
124 static NormType normeMax(Byte v)
125 {
126 return static_cast<Byte>(math::abs(v));
127 }
128
129 private:
130
131 static bool _verifDifferent(Type v1, Type v2, Type& diff, Type divider)
132 {
133 if (v1 != v2) {
134 auto abs_diff = v1 - v2;
135 if (!math::isZero(divider))
136 abs_diff = abs_diff / divider;
137 diff = static_cast<Byte>(diff);
138 return true;
139 }
140 return false;
141 }
142};
143
144/*---------------------------------------------------------------------------*/
145/*---------------------------------------------------------------------------*/
146/*!
147 * \internal
148 * \brief Spécialisation de VariableDataTypeTraitsT pour le type \c Real.
149 */
150template <>
151class ARCANE_CORE_EXPORT VariableDataTypeTraitsT<Real>
152{
153 public:
154
155 //! Type du paramètre template
156 typedef Real Type;
157
158 //! Indique si le type peut être sauvé et relu
159 typedef TrueType HasDump;
160
161 //! Indique si le type peut être subir une réduction
162 typedef TrueType HasReduce;
163
164 //! Indique si le type peut être subir une réduction Min/Max
165 typedef TrueType HasReduceMinMax;
166
167 //! Indique si le type est numérique
168 typedef TrueType IsNumeric;
169
170 typedef Real BasicType;
171
172 static constexpr Integer nbBasicType() { return 1; }
173
174 typedef Real NormType;
175
176 public:
177
178 //! Retourne le nom du type de la variable
179 static constexpr const char* typeName() { return "Real"; }
180 //! Retourne le type de la variable
181 static constexpr eDataType type() { return DT_Real; }
182 //! Ecrit dans la chaîne \a s la valeur de \a v
183 static void dumpValue(String& s, const Type& v) { builtInDumpValue(s, v); }
184 /*!
185 * \brief Stocke la conversion de la chaîne \a s en le type #Type dans \a v
186 * \retval true en cas d'échec,
187 * \retval false si la conversion est un succès
188 */
189 static bool getValue(Type& v, const String& s) { return builtInGetValue(v, s); }
190
191 static bool verifDifferentNorm(Type v1, Type v2, Type& diff, Type norm, bool is_nan_equal = false)
192 {
193 return _verifDifferent(v1, v2, diff, norm, is_nan_equal);
194 }
195
196 static bool verifDifferent(Type v1, Type v2, Type& diff, bool is_nan_equal = false)
197 {
198 return _verifDifferent(v1, v2, diff, math::abs(v1), is_nan_equal);
199 }
200
201 static NormType normeMax(Real v)
202 {
203 return math::abs(v);
204 }
205
206 private:
207
208 static bool _verifDifferent(Type v1, Type v2, Type& diff, Type divider, bool is_nan_equal)
209 {
210 if (is_nan_equal) {
211 if (std::isnan(v1) && std::isnan(v2))
212 return false;
213 }
214 // Vérifie avant de les comparer que les deux nombres sont valides
215 // pour éviter une exception flottante sur certaines plates-formes
216 if (platform::isDenormalized(v1) || platform::isDenormalized(v2)) {
217 diff = 1.0;
218 return true;
219 }
220 if (v1 != v2) {
221 if (divider < 1.e-100) // TH: plantait pour v1 tres petit(math::isZero(v1))
222 diff = v1 - v2;
223 else
224 diff = (v1 - v2) / divider;
225 return true;
226 }
227 return false;
228 }
229};
230
231/*---------------------------------------------------------------------------*/
232/*---------------------------------------------------------------------------*/
233/*!
234 * \internal
235 * \brief Spécialisation de VariableDataTypeTraitsT pour le type \c Real.
236 */
237template <>
238class ARCANE_CORE_EXPORT VariableDataTypeTraitsT<Float128>
239{
240 public:
241
242 //! Type du paramètre template
243 typedef Float128 Type;
244
245 //! Indique si le type peut être sauvé et relu
247
248 //! Indique si le type peut être subir une réduction
250
251 //! Indique si le type peut être subir une réduction Min/Max
253
254 //! Indique si le type est numérique
256
257 typedef Float128 BasicType;
258
259 static constexpr Int32 nbBasicType() { return 1; }
260
261 typedef Float128 NormType;
262
263 public:
264
265 //! Retourne le nom du type de la variable
266 static constexpr const char* typeName() { return "Float128"; }
267 //! Retourne le type de la variable
268 static constexpr eDataType type() { return DT_Float128; }
269 //! Ecrit dans la chaîne \a s la valeur de \a v
270 static void dumpValue(String& s, const Type& v) { builtInDumpValue(s, v); }
271 /*!
272 * \brief Stocke la conversion de la chaîne \a s en le type #Type dans \a v
273 * \retval true en cas d'échec,
274 * \retval false si la conversion est un succès
275 */
276 static bool getValue(Type& v, const String& s) { return builtInGetValue(v, s); }
277
278 static bool verifDifferent(Type v1, Type v2, Type& diff, [[maybe_unused]] bool is_nan_equal = false)
279 {
280 return _verifDifferent(v1, v2, diff, math::abs(v1));
281 }
282
283 static bool verifDifferentNorm(Type v1, Type v2, Type& diff, NormType norm, [[maybe_unused]] bool is_nan_equal)
284 {
285 return _verifDifferent(v1, v2, diff, norm);
286 }
287
288 static NormType normeMax(Float128 v)
289 {
290 return math::abs(v);
291 }
292
293 private:
294
295 static bool _verifDifferent(Type v1, Type v2, Type& diff, Type divider)
296 {
297 if (v1 != v2) {
298 if (divider < 1.e-100) // TH: plantait pour v1 tres petit(math::isZero(v1))
299 diff = v1 - v2;
300 else
301 diff = (v1 - v2) / divider;
302 return true;
303 }
304 return false;
305 }
306};
307
308/*---------------------------------------------------------------------------*/
309/*---------------------------------------------------------------------------*/
310/*!
311 * \internal
312 * \brief Spécialisation de VariableDataTypeTraitsT pour le type <tt>Int8</tt>.
313 */
314template <>
315class ARCANE_CORE_EXPORT VariableDataTypeTraitsT<Int8>
316{
317 public:
318
319 //! Type du paramètre template
320 typedef Int8 Type;
321
322 //! Indique si le type peut être sauvé et relu
324
325 //! Indique si le type peut être subir une réduction
327
328 //! Indique si le type peut être subir une réduction Min/Max
330
331 //! Indique si le type est numérique
333
334 typedef Int8 BasicType;
335
336 static constexpr Int32 nbBasicType() { return 1; }
337
338 typedef Int8 NormType;
339
340 public:
341
342 //! Retourne le nom du type de la variable
343 static constexpr const char* typeName() { return "Int8"; }
344 //! Retourne le type de la variable
345 static constexpr eDataType type() { return DT_Int8; }
346 //! Ecrit dans la chaîne \a s la valeur de \a v
347 static void dumpValue(String& s, const Type& v) { builtInDumpValue(s, v); }
348 /*!
349 * \brief Stocke la conversion de la chaîne \a s en le type #Type dans \a v
350 * \retval true en cas d'échec,
351 * \retval false si la conversion est un succès
352 */
353 static bool getValue(Type& v, const String& s) { return builtInGetValue(v, s); }
354 static bool verifDifferent(Int8 v1, Int8 v2, Int8& diff,
355 [[maybe_unused]] bool is_nan_equal = false)
356 {
357 if (v1 != v2) {
358 if (math::isZero(v1))
359 diff = (Int8)(v1 - v2);
360 else
361 diff = (Int8)((v1 - v2) / v1);
362 return true;
363 }
364 return false;
365 }
366 static bool verifDifferentNorm(Type v1, Type v2, Type& diff,
367 [[maybe_unused]] NormType norm,
368 [[maybe_unused]] bool is_nan_equal = false)
369 {
370 return verifDifferent(v1, v2, diff, is_nan_equal);
371 }
372 static NormType normeMax(Int8 v)
373 {
374 return static_cast<Int8>(math::abs(v));
375 }
376};
377
378/*---------------------------------------------------------------------------*/
379/*---------------------------------------------------------------------------*/
380/*!
381 * \internal
382 * \brief Spécialisation de VariableDataTypeTraitsT pour le type <tt>Int16</tt>.
383 */
384template <>
385class ARCANE_CORE_EXPORT VariableDataTypeTraitsT<Int16>
386{
387 public:
388
389 //! Type du paramètre template
390 typedef Int16 Type;
391
392 //! Indique si le type peut être sauvé et relu
394
395 //! Indique si le type peut être subir une réduction
397
398 //! Indique si le type peut être subir une réduction Min/Max
400
401 //! Indique si le type est numérique
403
404 typedef Int16 BasicType;
405
406 static constexpr Integer nbBasicType() { return 1; }
407
408 typedef Int16 NormType;
409
410 public:
411
412 //! Retourne le nom du type de la variable
413 static constexpr const char* typeName() { return "Int16"; }
414 //! Retourne le type de la variable
415 static constexpr eDataType type() { return DT_Int16; }
416 //! Ecrit dans la chaîne \a s la valeur de \a v
417 static void dumpValue(String& s, const Type& v) { builtInDumpValue(s, v); }
418 /*!
419 * \brief Stocke la conversion de la chaîne \a s en le type #Type dans \a v
420 * \retval true en cas d'échec,
421 * \retval false si la conversion est un succès
422 */
423 static bool getValue(Type& v, const String& s) { return builtInGetValue(v, s); }
424 static bool verifDifferent(Int16 v1, Int16 v2, Int16& diff,
425 [[maybe_unused]] bool is_nan_equal = false)
426 {
427 if (v1 != v2) {
428 if (math::isZero(v1))
429 diff = (Int16)(v1 - v2);
430 else
431 diff = (Int16)((v1 - v2) / v1);
432 return true;
433 }
434 return false;
435 }
436 static bool verifDifferentNorm(Type v1, Type v2, Type& diff,
437 [[maybe_unused]] NormType norm,
438 [[maybe_unused]] bool is_nan_equal = false)
439 {
440 return verifDifferent(v1, v2, diff, is_nan_equal);
441 }
442 static NormType normeMax(Int16 v)
443 {
444 return math::abs(v);
445 }
446};
447
448/*---------------------------------------------------------------------------*/
449/*---------------------------------------------------------------------------*/
450/*!
451 * \internal
452 * \brief Spécialisation de VariableDataTypeTraitsT pour le type <tt>Int32</tt>.
453 */
454template <>
455class ARCANE_CORE_EXPORT VariableDataTypeTraitsT<Int32>
456{
457 public:
458
459 //! Type du paramètre template
460 typedef Int32 Type;
461
462 //! Indique si le type peut être sauvé et relu
464
465 //! Indique si le type peut être subir une réduction
467
468 //! Indique si le type peut être subir une réduction Min/Max
470
471 //! Indique si le type est numérique
473
474 typedef Int32 BasicType;
475
476 static constexpr Integer nbBasicType() { return 1; }
477
478 typedef Int32 NormType;
479
480 public:
481
482 //! Retourne le nom du type de la variable
483 static constexpr const char* typeName() { return "Int32"; }
484 //! Retourne le type de la variable
485 static constexpr eDataType type() { return DT_Int32; }
486 //! Ecrit dans la chaîne \a s la valeur de \a v
487 static void dumpValue(String& s, const Type& v) { builtInDumpValue(s, v); }
488 /*!
489 * \brief Stocke la conversion de la chaîne \a s en le type #Type dans \a v
490 * \retval true en cas d'échec,
491 * \retval false si la conversion est un succès
492 */
493 static bool getValue(Type& v, const String& s) { return builtInGetValue(v, s); }
494 static bool verifDifferent(Int32 v1, Int32 v2, Int32& diff,
495 [[maybe_unused]] bool is_nan_equal = false)
496 {
497 if (v1 != v2) {
498 if (math::isZero(v1))
499 diff = v1 - v2;
500 else
501 diff = (v1 - v2) / v1;
502 return true;
503 }
504 return false;
505 }
506 static bool verifDifferentNorm(Type v1, Type v2, Type& diff,
507 [[maybe_unused]] NormType norm,
508 [[maybe_unused]] bool is_nan_equal = false)
509 {
510 return verifDifferent(v1, v2, diff, is_nan_equal);
511 }
512
513 static NormType normeMax(Int32 v)
514 {
515 return math::abs(v);
516 }
517};
518
519/*---------------------------------------------------------------------------*/
520/*---------------------------------------------------------------------------*/
521/*!
522 * \internal
523 * \brief Spécialisation de VariableDataTypeTraitsT pour le type <tt>Int64</tt>.
524 */
525template <>
526class ARCANE_CORE_EXPORT VariableDataTypeTraitsT<Int64>
527{
528 public:
529
530 //! Type du paramètre template
531 typedef Int64 Type;
532
533 //! Indique si le type peut être sauvé et relu
535
536 //! Indique si le type peut être subir une réduction
538
539 //! Indique si le type peut être subir une réduction Min/Max
541
542 //! Indique si le type est numérique
544
545 typedef Int64 BasicType;
546
547 static constexpr Integer nbBasicType() { return 1; }
548
549 typedef Int64 NormType;
550
551 public:
552
553 //! Retourne le nom du type de la variable
554 static constexpr const char* typeName() { return "Int64"; }
555 //! Retourne le type de la variable
556 static constexpr eDataType type() { return DT_Int64; }
557 //! Ecrit dans la chaîne \a s la valeur de \a v
558 static void dumpValue(String& s, const Type& v) { builtInDumpValue(s, v); }
559 /*!
560 * \brief Stocke la conversion de la chaîne \a s en le type #Type dans \a v
561 * \retval true en cas d'échec,
562 * \retval false si la conversion est un succès
563 */
564 static bool getValue(Type& v, const String& s) { return builtInGetValue(v, s); }
565
566 static bool verifDifferent(Type v1, Type v2, Type& diff,
567 [[maybe_unused]] bool is_nan_equal = false)
568 {
569 if (v1 != v2) {
570 if (math::isZero(v1))
571 diff = v1 - v2;
572 else
573 diff = (v1 - v2) / v1;
574 return true;
575 }
576 return false;
577 }
578
579 static bool verifDifferentNorm(Type v1, Type v2, Type& diff,
580 [[maybe_unused]] NormType norm,
581 [[maybe_unused]] bool is_nan_equal = false)
582 {
583 return verifDifferent(v1, v2, diff, is_nan_equal);
584 }
585
586 static NormType normeMax(Int64 v)
587 {
588 return v;
589 }
590};
591
592/*---------------------------------------------------------------------------*/
593/*---------------------------------------------------------------------------*/
594/*!
595 * \internal
596 * \brief Spécialisation de VariableDataTypeTraitsT pour le type <tt>Int128</tt>.
597 */
598template <>
599class ARCANE_CORE_EXPORT VariableDataTypeTraitsT<Int128>
600{
601 public:
602
603 //! Type du paramètre template
604 typedef Int128 Type;
605
606 //! Indique si le type peut être sauvé et relu
608
609 //! Indique si le type peut être subir une réduction
611
612 //! Indique si le type peut être subir une réduction Min/Max
614
615 //! Indique si le type est numérique
617
618 typedef Int128 BasicType;
619
620 static constexpr Int32 nbBasicType() { return 1; }
621
622 typedef Int128 NormType;
623
624 public:
625
626 //! Retourne le nom du type de la variable
627 static constexpr const char* typeName() { return "Int128"; }
628 //! Retourne le type de la variable
629 static constexpr eDataType type() { return DT_Int128; }
630 //! Ecrit dans la chaîne \a s la valeur de \a v
631 static void dumpValue(String& s, const Type& v) { builtInDumpValue(s, v); }
632 /*!
633 * \brief Stocke la conversion de la chaîne \a s en le type #Type dans \a v
634 * \retval true en cas d'échec,
635 * \retval false si la conversion est un succès
636 */
637 static bool getValue(Type& v, const String& s) { return builtInGetValue(v, s); }
638
639 static bool verifDifferent(Type v1, Type v2, Type& diff,
640 [[maybe_unused]] bool is_nan_equal = false)
641 {
642 if (v1 != v2) {
643 if (math::isZero(v1))
644 diff = v1 - v2;
645 else
646 diff = (v1 - v2) / v1;
647 return true;
648 }
649 return false;
650 }
651
652 static bool verifDifferentNorm(Type v1, Type v2, Type& diff,
653 [[maybe_unused]] NormType norm,
654 [[maybe_unused]] bool is_nan_equal = false)
655 {
656 return verifDifferent(v1, v2, diff, is_nan_equal);
657 }
658
659 static NormType normeMax(Int16 v)
660 {
661 return static_cast<Int16>(math::abs(v));
662 }
663};
664
665/*---------------------------------------------------------------------------*/
666/*---------------------------------------------------------------------------*/
667/*!
668 * \internal
669 * \brief Spécialisation de VariableDataTypeTraitsT pour le type <tt>String</tt>.
670 */
671template <>
672class ARCANE_CORE_EXPORT VariableDataTypeTraitsT<String>
673{
674 public:
675
676 //! Type du paramètre template
677 typedef String Type;
678
679 //! Indique si le type peut être sauvé et relu
681
682 //! Indique si le type peut être subir une réduction
684
685 //! Indique si le type peut être subir une réduction Min/Max
687
688 //! Indique si le type est numérique
690
691 typedef String BasicType;
692
693 // Uniquement utilisé pour compiler les routines de comparaison de valeurs.
694 using NormType = String;
695
696 static constexpr Integer nbBasicType() { return 1; }
697
698 public:
699
700 //! Retourne le nom du type de la variable
701 static constexpr const char* typeName() { return "String"; }
702 //! Retourne le type de la variable
703 static constexpr eDataType type() { return DT_String; }
704 //! Ecrit dans la chaîne \a s la valeur de \a v
705 static void dumpValue(String& s, const Type& v) { s = v; }
706 /*!
707 * \brief Stocke la conversion de la chaîne \a s en le type #Type dans \a v
708 * \retval true en cas d'échec,
709 * \retval false si la conversion est un succès
710 */
711 static bool getValue(Type& v, const String& s) { return builtInGetValue(v, s); }
712
713 static bool verifDifferent(const Type v1, const Type& v2, Type& diff,
714 [[maybe_unused]] bool is_nan_equal = false)
715 {
716 diff = v1;
717 return (v1 != v2);
718 }
719 static bool verifDifferentNorm(const Type v1, const Type& v2, Type& diff,
720 [[maybe_unused]] const String& divider,
721 [[maybe_unused]] bool is_nan_equal = false)
722 {
723 return verifDifferent(v1, v2, diff, is_nan_equal);
724 }
725};
726
727/*---------------------------------------------------------------------------*/
728/*---------------------------------------------------------------------------*/
729/*!
730 * \internal
731 * \brief Spécialisation de VariableDataTypeTraitsT pour le type \c BFloat16.
732 */
733template <>
734class ARCANE_CORE_EXPORT VariableDataTypeTraitsT<BFloat16>
735{
736 public:
737
738 //! Type du paramètre template
739 typedef BFloat16 Type;
740
741 //! Indique si le type peut être sauvé et relu
743
744 //! Indique si le type peut être subir une réduction
746
747 //! Indique si le type peut être subir une réduction Min/Max
749
750 //! Indique si le type est numérique
752
753 typedef BFloat16 BasicType;
754
755 static constexpr Integer nbBasicType() { return 1; }
756
757 typedef BFloat16 NormType;
758
759 public:
760
761 //! Retourne le nom du type de la variable
762 static constexpr const char* typeName() { return "BFloat16"; }
763 //! Retourne le type de la variable
764 static constexpr eDataType type() { return DT_BFloat16; }
765 //! Ecrit dans la chaîne \a s la valeur de \a v
766 static void dumpValue(String& s, const Type& v) { builtInDumpValue(s, v); }
767 /*!
768 * \brief Stocke la conversion de la chaîne \a s en le type #Type dans \a v
769 * \retval true en cas d'échec,
770 * \retval false si la conversion est un succès
771 */
772 static bool getValue(Type& v, const String& s) { return builtInGetValue(v, s); }
773
774 static bool verifDifferent(float v1, float v2, BFloat16& diff,
775 [[maybe_unused]] bool is_nan_equal = false)
776 {
777 return _verifDifferent(v1, v2, diff, math::abs(v1));
778 }
779
780 static bool verifDifferentNorm(float v1, float v2, BFloat16& diff, NormType norm,
781 [[maybe_unused]] bool is_nan_equal = false)
782 {
783 return _verifDifferent(v1, v2, diff, norm);
784 }
785
786 static BFloat16 normeMax(float v)
787 {
788 return static_cast<Type>(math::abs(v));
789 }
790
791 private:
792
793 static bool _verifDifferent(float v1, float v2, BFloat16& diff, float divider)
794 {
795 if (v1 != v2) {
796 float fdiff = 0.0;
797 if (divider != 0.0)
798 fdiff = v1 - v2;
799 else
800 fdiff = (v1 - v2) / divider;
801 diff = static_cast<Type>(fdiff);
802 return true;
803 }
804 return false;
805 }
806};
807
808/*---------------------------------------------------------------------------*/
809/*---------------------------------------------------------------------------*/
810/*!
811 * \internal
812 * \brief Spécialisation de VariableDataTypeTraitsT pour le type \c Float16.
813 */
814template <>
815class ARCANE_CORE_EXPORT VariableDataTypeTraitsT<Float16>
816{
817 public:
818
819 //! Type du paramètre template
820 typedef Float16 Type;
821
822 //! Indique si le type peut être sauvé et relu
824
825 //! Indique si le type peut être subir une réduction
827
828 //! Indique si le type peut être subir une réduction Min/Max
830
831 //! Indique si le type est numérique
833
834 typedef Float16 BasicType;
835
836 static constexpr Integer nbBasicType() { return 1; }
837
838 typedef Float16 NormType;
839
840 public:
841
842 //! Retourne le nom du type de la variable
843 static constexpr const char* typeName() { return "Float16"; }
844 //! Retourne le type de la variable
845 static constexpr eDataType type() { return DT_Float16; }
846 //! Ecrit dans la chaîne \a s la valeur de \a v
847 static void dumpValue(String& s, const Type& v) { builtInDumpValue(s, v); }
848 /*!
849 * \brief Stocke la conversion de la chaîne \a s en le type #Type dans \a v
850 * \retval true en cas d'échec,
851 * \retval false si la conversion est un succès
852 */
853 static bool getValue(Type& v, const String& s) { return builtInGetValue(v, s); }
854
855 static bool verifDifferent(float v1, float v2, Float16& diff,
856 [[maybe_unused]] bool is_nan_equal = false)
857 {
858 return _verifDifferent(v1, v2, diff, math::abs(v1));
859 }
860
861 static bool verifDifferentNorm(float v1, float v2, Float16& diff, NormType norm,
862 [[maybe_unused]] bool is_nan_equal = false)
863 {
864 return _verifDifferent(v1, v2, diff, norm);
865 }
866
867 static Float16 normeMax(Float16 v)
868 {
869 return static_cast<Float16>(math::abs(v));
870 }
871
872 private:
873
874 static bool _verifDifferent(float v1, float v2, Float16& diff, float divider)
875 {
876 if (v1 != v2) {
877 float fdiff = 0.0;
878 if (divider != 0.0)
879 fdiff = v1 - v2;
880 else
881 fdiff = (v1 - v2) / divider;
882 diff = static_cast<Type>(fdiff);
883 return true;
884 }
885 return false;
886 }
887};
888
889/*---------------------------------------------------------------------------*/
890/*---------------------------------------------------------------------------*/
891/*!
892 * \internal
893 * \brief Spécialisation de VariableDataTypeTraitsT pour le type \c Float32.
894 */
895template <>
896class ARCANE_CORE_EXPORT VariableDataTypeTraitsT<Float32>
897{
898 public:
899
900 //! Type du paramètre template
901 typedef Float32 Type;
902
903 //! Indique si le type peut être sauvé et relu
905
906 //! Indique si le type peut être subir une réduction
908
909 //! Indique si le type peut être subir une réduction Min/Max
911
912 //! Indique si le type est numérique
914
915 typedef Real BasicType;
916
917 static constexpr Integer nbBasicType() { return 1; }
918
919 typedef Float32 NormType;
920
921 public:
922
923 //! Retourne le nom du type de la variable
924 static constexpr const char* typeName() { return "Float32"; }
925 //! Retourne le type de la variable
926 static constexpr eDataType type() { return DT_Float32; }
927 //! Ecrit dans la chaîne \a s la valeur de \a v
928 static void dumpValue(String& s, const Type& v) { builtInDumpValue(s, v); }
929 /*!
930 * \brief Stocke la conversion de la chaîne \a s en le type #Type dans \a v
931 * \retval true en cas d'échec,
932 * \retval false si la conversion est un succès
933 */
934 static bool getValue(Type& v, const String& s) { return builtInGetValue(v, s); }
935
936 static bool verifDifferentNorm(Type v1, Type v2, Type& diff, NormType norm, bool is_nan_equal = false)
937 {
938 return _verifDifferent(v1, v2, diff, norm, is_nan_equal);
939 }
940
941 static bool verifDifferent(Type v1, Type v2, Type& diff, bool is_nan_equal = false)
942 {
943 return _verifDifferent(v1, v2, diff, math::abs(v1), is_nan_equal);
944 }
945
946 static Float32 normeMax(Float32 v)
947 {
948 return math::abs(v);
949 }
950
951 private:
952
953 static bool _verifDifferent(Type v1, Type v2, Type& diff, Type divider, bool is_nan_equal)
954 {
955 if (is_nan_equal) {
956 if (std::isnan(v1) && std::isnan(v2))
957 return false;
958 }
959 // Vérifie avant de les comparer que les deux nombres sont valides
960 // pour éviter une exception flottante sur certaines plates-formes
961 if (platform::isDenormalized(v1) || platform::isDenormalized(v2)) {
962 diff = 1.0;
963 return true;
964 }
965 if (v1 != v2) {
966 if (divider < 1.e-40)
967 diff = v1 - v2;
968 else
969 diff = (v1 - v2) / divider;
970 return true;
971 }
972 return false;
973 }
974};
975
976/*---------------------------------------------------------------------------*/
977/*---------------------------------------------------------------------------*/
978/*!
979 * \internal
980 * \brief Spécialisation de VariableDataTypeTraitsT pour le type <tt>Real2</tt>.
981 */
982template <>
983class ARCANE_CORE_EXPORT VariableDataTypeTraitsT<Real2>
984{
985 public:
986
987 //! Type du paramètre template
988 typedef Real2 Type;
989
990 //! Indique si le type peut être sauvé et relu
991 typedef TrueType HasDump;
992
993 //! Indique si le type peut être subir une réduction
994 typedef TrueType HasReduce;
995
996 //! Indique si le type peut être subir une réduction Min/Max
997 typedef TrueType HasReduceMinMax;
998
999 //! Indique si le type est numérique
1000 typedef TrueType IsNumeric;
1001
1002 typedef Real BasicType;
1003
1004 static constexpr Integer nbBasicType() { return 2; }
1005
1006 typedef Real NormType;
1007
1008 private:
1009
1010 using SubTraits = VariableDataTypeTraitsT<Real>;
1011
1012 public:
1013
1014 //! Retourne le nom du type de la variable
1015 static constexpr const char* typeName() { return "Real2"; }
1016 //! Retourne le type de la variable
1017 static constexpr eDataType type() { return DT_Real2; }
1018 //! Ecrit dans la chaîne \a s la valeur de \a v
1019 static void dumpValue(String& s, const Type&) { s = "N/A"; }
1020 /*!
1021 * \brief Stocke la conversion de la chaîne \a s en le type #Type dans \a v
1022 * \retval true en cas d'échec,
1023 * \retval false si la conversion est un succès
1024 */
1025 static bool getValue(Type& v, const String& s) { return builtInGetValue(v, s); }
1026
1027 static bool verifDifferent(Real2 v1, Real2 v2, Real2& diff, bool is_nan_equal = false)
1028 {
1029 bool is_different = false;
1030 is_different |= SubTraits::verifDifferent(v1.x, v2.x, diff.x, is_nan_equal);
1031 is_different |= SubTraits::verifDifferent(v1.y, v2.y, diff.y, is_nan_equal);
1032 return is_different;
1033 }
1034
1035 static bool verifDifferentNorm(const Real2& v1, const Real2& v2, Real2& diff,
1036 NormType norm, [[maybe_unused]] bool is_nan_equal)
1037 {
1038 if (norm < 1.e-100) {
1039 diff.x = math::abs(v2.x);
1040 diff.y = math::abs(v2.y);
1041 }
1042 else {
1043 diff.x = math::abs(v2.x - v1.x) / norm;
1044 diff.y = math::abs(v2.y - v1.y) / norm;
1045 }
1046 bool is_different = (normeMax(diff) != 0.);
1047 return is_different;
1048 }
1049
1050 static NormType normeMax(const Real2& v)
1051 {
1052 Real vx = SubTraits::normeMax(v.x);
1053 Real vy = SubTraits::normeMax(v.y);
1054 return math::max(vx, vy);
1055 }
1056};
1057
1058/*---------------------------------------------------------------------------*/
1059/*---------------------------------------------------------------------------*/
1060/*!
1061 * \internal
1062 * \brief Spécialisation de VariableDataTypeTraitsT pour le type <tt>Real3</tt>.
1063 */
1064template <>
1065class ARCANE_CORE_EXPORT VariableDataTypeTraitsT<Real3>
1066{
1067 public:
1068
1069 //! Type du paramètre template
1070 typedef Real3 Type;
1071
1072 //! Indique si le type peut être sauvé et relu
1073 typedef TrueType HasDump;
1074
1075 //! Indique si le type peut être subir une réduction
1076 typedef TrueType HasReduce;
1077
1078 //! Indique si le type peut être subir une réduction Min/Max
1079 typedef TrueType HasReduceMinMax;
1080
1081 //! Indique si le type est numérique
1082 typedef TrueType IsNumeric;
1083
1084 typedef Real BasicType;
1085
1086 static constexpr Integer nbBasicType() { return 3; }
1087
1088 typedef Real NormType;
1089
1090 private:
1091
1092 using SubTraits = VariableDataTypeTraitsT<Real>;
1093
1094 public:
1095
1096 //! Retourne le nom du type de la variable
1097 static constexpr const char* typeName() { return "Real3"; }
1098 //! Retourne le type de la variable
1099 static constexpr eDataType type() { return DT_Real3; }
1100 //! Ecrit dans la chaîne \a s la valeur de \a v
1101 static void dumpValue(String& s, const Type&) { s = "N/A"; }
1102 /*!
1103 * \brief Stocke la conversion de la chaîne \a s en le type #Type dans \a v
1104 * \retval true en cas d'échec,
1105 * \retval false si la conversion est un succès
1106 */
1107 static bool getValue(Type& v, const String& s) { return builtInGetValue(v, s); }
1108
1109 static bool verifDifferent(Real3 v1, Real3 v2, Real3& diff, bool is_nan_equal = false)
1110 {
1111 bool is_different = false;
1112 is_different |= SubTraits::verifDifferent(v1.x, v2.x, diff.x, is_nan_equal);
1113 is_different |= SubTraits::verifDifferent(v1.y, v2.y, diff.y, is_nan_equal);
1114 is_different |= SubTraits::verifDifferent(v1.z, v2.z, diff.z, is_nan_equal);
1115 return is_different;
1116 }
1117
1118 static bool verifDifferentNorm(const Real3& v1, const Real3& v2, Real3& diff,
1119 NormType norm, [[maybe_unused]] bool is_nan_equal)
1120 {
1121 if (norm < 1.e-100) {
1122 diff.x = math::abs(v2.x);
1123 diff.y = math::abs(v2.y);
1124 diff.z = math::abs(v2.z);
1125 }
1126 else {
1127 diff.x = math::abs(v2.x - v1.x) / norm;
1128 diff.y = math::abs(v2.y - v1.y) / norm;
1129 diff.z = math::abs(v2.z - v1.z) / norm;
1130 }
1131 bool is_different = (normeMax(diff) != 0.);
1132 return is_different;
1133 }
1134
1135 static NormType normeMax(const Real3& v)
1136 {
1137 Real vx = SubTraits::normeMax(v.x);
1138 Real vy = SubTraits::normeMax(v.y);
1139 Real vz = SubTraits::normeMax(v.z);
1140 return math::max(vx, math::max(vy, vz));
1141 }
1142};
1143
1144/*---------------------------------------------------------------------------*/
1145/*---------------------------------------------------------------------------*/
1146/*!
1147 * \internal
1148 * \brief Spécialisation de VariableDataTypeTraitsT pour le type <tt>Real3x3</tt>.
1149 */
1150template <>
1151class ARCANE_CORE_EXPORT VariableDataTypeTraitsT<Real2x2>
1152{
1153 public:
1154
1155 //! Type du paramètre template
1156 typedef Real2x2 Type;
1157
1158 //! Indique si le type peut être sauvé et relu
1160
1161 //! Indique si le type peut être subir une réduction
1163
1164 //! Indique si le type peut être subir une réduction Min/Max
1166
1167 //! Indique si le type est numérique
1169
1170 typedef Real BasicType;
1171
1172 static constexpr Integer nbBasicType() { return 4; }
1173
1174 typedef Real NormType;
1175
1176 private:
1177
1178 using SubTraits = VariableDataTypeTraitsT<Real2>;
1179
1180 public:
1181
1182 //! Retourne le nom du type de la variable
1183 static constexpr const char* typeName() { return "Real2x2"; }
1184 //! Retourne le type de la variable
1185 static constexpr eDataType type() { return DT_Real2x2; }
1186 //! Ecrit dans la chaîne \a s la valeur de \a v
1187 static void dumpValue(String& s, const Type&) { s = "N/A"; }
1188 /*!
1189 * \brief Stocke la conversion de la chaîne \a s en le type #Type dans \a v
1190 * \retval true en cas d'échec,
1191 * \retval false si la conversion est un succès
1192 */
1193 static bool getValue(Type&, const String&) { return true; }
1194
1195 static bool verifDifferent(Real2x2 v1, Real2x2 v2, Real2x2& diff, bool is_nan_equal = false)
1196 {
1197 bool is_different = false;
1198 is_different |= SubTraits::verifDifferent(v1.x, v2.x, diff.x, is_nan_equal);
1199 is_different |= SubTraits::verifDifferent(v1.y, v2.y, diff.y, is_nan_equal);
1200 return is_different;
1201 }
1202
1203 static bool verifDifferentNorm(const Real2x2& v1, const Real2x2& v2, Real2x2& diff,
1204 NormType norm, [[maybe_unused]] bool is_nan_equal)
1205 {
1206 if (norm < 1.e-100) {
1207 diff.x.x = math::abs(v2.x.x);
1208 diff.x.y = math::abs(v2.x.y);
1209
1210 diff.y.x = math::abs(v2.y.x);
1211 diff.y.y = math::abs(v2.y.y);
1212 }
1213 else {
1214 diff.x.x = math::abs(v2.x.x - v1.x.x) / norm;
1215 diff.x.y = math::abs(v2.x.y - v1.x.y) / norm;
1216
1217 diff.y.x = math::abs(v2.y.x - v1.y.x) / norm;
1218 diff.y.y = math::abs(v2.y.y - v1.y.y) / norm;
1219 }
1220 bool is_different = (normeMax(diff) != 0.);
1221 return is_different;
1222 }
1223
1224 static NormType normeMax(const Real2x2& v)
1225 {
1226 Real vx = SubTraits::normeMax(v.x);
1227 Real vy = SubTraits::normeMax(v.y);
1228 return SubTraits::normeMax(Real2(vx, vy));
1229 }
1230};
1231
1232/*---------------------------------------------------------------------------*/
1233/*---------------------------------------------------------------------------*/
1234/*!
1235 * \internal
1236 * \brief Spécialisation de VariableDataTypeTraitsT pour le type <tt>Real3x3</tt>.
1237 */
1238template <>
1239class ARCANE_CORE_EXPORT VariableDataTypeTraitsT<Real3x3>
1240{
1241 public:
1242
1243 //! Type du paramètre template
1244 typedef Real3x3 Type;
1245
1246 //! Indique si le type peut être sauvé et relu
1248
1249 //! Indique si le type peut être subir une réduction
1251
1252 //! Indique si le type peut être subir une réduction Min/Max
1254
1255 //! Indique si le type est numérique
1257
1258 typedef Real BasicType;
1259
1260 static constexpr Integer nbBasicType() { return 9; }
1261
1262 typedef Real NormType;
1263
1264 private:
1265
1266 using SubTraits = VariableDataTypeTraitsT<Real3>;
1267
1268 public:
1269
1270 //! Retourne le nom du type de la variable
1271 static constexpr const char* typeName() { return "Real3x3"; }
1272 //! Retourne le type de la variable
1273 static constexpr eDataType type() { return DT_Real3x3; }
1274 //! Ecrit dans la chaîne \a s la valeur de \a v
1275 static void dumpValue(String& s, const Type&) { s = "N/A"; }
1276 /*!
1277 * \brief Stocke la conversion de la chaîne \a s en le type #Type dans \a v
1278 * \retval true en cas d'échec,
1279 * \retval false si la conversion est un succès
1280 */
1281 static bool getValue(Type&, const String&) { return true; }
1282
1283 static bool verifDifferent(Real3x3 v1, Real3x3 v2, Real3x3& diff, bool is_nan_equal = false)
1284 {
1285 bool is_different = false;
1286 is_different |= SubTraits::verifDifferent(v1.x, v2.x, diff.x, is_nan_equal);
1287 is_different |= SubTraits::verifDifferent(v1.y, v2.y, diff.y, is_nan_equal);
1288 is_different |= SubTraits::verifDifferent(v1.z, v2.z, diff.z, is_nan_equal);
1289 return is_different;
1290 }
1291
1292 static bool verifDifferentNorm(const Real3x3& v1, const Real3x3& v2, Real3x3& diff,
1293 NormType norm, [[maybe_unused]] bool is_nan_equal)
1294 {
1295 if (norm < 1.e-100) {
1296 diff.x.x = math::abs(v2.x.x);
1297 diff.x.y = math::abs(v2.x.y);
1298 diff.x.z = math::abs(v2.x.z);
1299
1300 diff.y.x = math::abs(v2.y.x);
1301 diff.y.y = math::abs(v2.y.y);
1302 diff.y.z = math::abs(v2.y.z);
1303
1304 diff.z.x = math::abs(v2.z.x);
1305 diff.z.y = math::abs(v2.z.y);
1306 diff.z.z = math::abs(v2.z.z);
1307 }
1308 else {
1309 diff.x.x = math::abs(v2.x.x - v1.x.x) / norm;
1310 diff.x.y = math::abs(v2.x.y - v1.x.y) / norm;
1311 diff.x.z = math::abs(v2.x.z - v1.x.z) / norm;
1312
1313 diff.y.x = math::abs(v2.y.x - v1.y.x) / norm;
1314 diff.y.y = math::abs(v2.y.y - v1.y.y) / norm;
1315 diff.y.z = math::abs(v2.y.z - v1.y.z) / norm;
1316
1317 diff.z.x = math::abs(v2.z.x - v1.z.x) / norm;
1318 diff.z.y = math::abs(v2.z.y - v1.z.y) / norm;
1319 diff.z.z = math::abs(v2.z.z - v1.z.z) / norm;
1320 }
1321 bool is_different = (normeMax(diff) != 0.);
1322 return is_different;
1323 }
1324
1325 static NormType normeMax(const Real3x3& v)
1326 {
1327 Real vx = SubTraits::normeMax(v.x);
1328 Real vy = SubTraits::normeMax(v.y);
1329 Real vz = SubTraits::normeMax(v.z);
1330 return VariableDataTypeTraitsT<Real3>::normeMax(Real3(vx, vy, vz));
1331 }
1332};
1333
1334/*---------------------------------------------------------------------------*/
1335/*---------------------------------------------------------------------------*/
1336
1337} // namespace Arcane
1338
1339/*---------------------------------------------------------------------------*/
1340/*---------------------------------------------------------------------------*/
1341
1342#endif
Fichier contenant les définitions des types de données gérés par Arcane.
Type flottant demi-précision.
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
Real2 x
Première composante.
Definition Real2x2.h:98
Real2 y
Deuxième composante.
Definition Real2x2.h:99
Classe gérant un vecteur de réel de dimension 3.
Definition Real3.h:132
Classe gérant une matrice de réel de dimension 3x3.
Definition Real3x3.h:66
Real3 z
premier élément du triplet
Definition Real3x3.h:119
Real3 y
premier élément du triplet
Definition Real3x3.h:118
Real3 x
premier élément du triplet
Definition Real3x3.h:117
Chaîne de caractères unicode.
TrueType IsNumeric
Indique si le type est numérique.
static constexpr eDataType type()
Retourne le type de la variable.
BFloat16 Type
Type du paramètre template.
FalseType HasReduce
Indique si le type peut être subir une réduction.
static bool getValue(Type &v, const String &s)
Stocke la conversion de la chaîne s en le type Type dans v.
static void dumpValue(String &s, const Type &v)
Ecrit dans la chaîne s la valeur de v.
FalseType HasDump
Indique si le type peut être sauvé et relu.
FalseType HasReduceMinMax
Indique si le type peut être subir une réduction Min/Max.
static constexpr const char * typeName()
Retourne le nom du type de la variable.
static constexpr eDataType type()
Retourne le type de la variable.
TrueType IsNumeric
Indique si le type est numérique.
TrueType HasDump
Indique si le type peut être sauvé et relu.
FalseType HasReduceMinMax
Indique si le type peut être subir une réduction Min/Max.
static void dumpValue(String &s, const Type &v)
Ecrit dans la chaîne s la valeur de v.
Byte Type
Type du paramètre template.
static constexpr const char * typeName()
Retourne le nom du type de la variable.
TrueType HasReduce
Indique si le type peut être subir une réduction.
static bool getValue(Type &v, const String &s)
Stocke la conversion de la chaîne s en le type Type dans v.
FalseType HasReduce
Indique si le type peut être subir une réduction.
static constexpr eDataType type()
Retourne le type de la variable.
static bool getValue(Type &v, const String &s)
Stocke la conversion de la chaîne s en le type Type dans v.
FalseType HasReduceMinMax
Indique si le type peut être subir une réduction Min/Max.
TrueType HasDump
Indique si le type peut être sauvé et relu.
TrueType IsNumeric
Indique si le type est numérique.
Float128 Type
Type du paramètre template.
static constexpr const char * typeName()
Retourne le nom du type de la variable.
static void dumpValue(String &s, const Type &v)
Ecrit dans la chaîne s la valeur de v.
static constexpr const char * typeName()
Retourne le nom du type de la variable.
static constexpr eDataType type()
Retourne le type de la variable.
FalseType HasDump
Indique si le type peut être sauvé et relu.
static void dumpValue(String &s, const Type &v)
Ecrit dans la chaîne s la valeur de v.
FalseType HasReduceMinMax
Indique si le type peut être subir une réduction Min/Max.
static bool getValue(Type &v, const String &s)
Stocke la conversion de la chaîne s en le type Type dans v.
Float16 Type
Type du paramètre template.
TrueType IsNumeric
Indique si le type est numérique.
FalseType HasReduce
Indique si le type peut être subir une réduction.
Float32 Type
Type du paramètre template.
TrueType HasReduce
Indique si le type peut être subir une réduction.
FalseType HasDump
Indique si le type peut être sauvé et relu.
TrueType IsNumeric
Indique si le type est numérique.
static constexpr eDataType type()
Retourne le type de la variable.
static bool getValue(Type &v, const String &s)
Stocke la conversion de la chaîne s en le type Type dans v.
static void dumpValue(String &s, const Type &v)
Ecrit dans la chaîne s la valeur de v.
TrueType HasReduceMinMax
Indique si le type peut être subir une réduction Min/Max.
static constexpr const char * typeName()
Retourne le nom du type de la variable.
FalseType HasReduceMinMax
Indique si le type peut être subir une réduction Min/Max.
TrueType IsNumeric
Indique si le type est numérique.
Int128 Type
Type du paramètre template.
static constexpr const char * typeName()
Retourne le nom du type de la variable.
static constexpr eDataType type()
Retourne le type de la variable.
static bool getValue(Type &v, const String &s)
Stocke la conversion de la chaîne s en le type Type dans v.
static void dumpValue(String &s, const Type &v)
Ecrit dans la chaîne s la valeur de v.
TrueType HasDump
Indique si le type peut être sauvé et relu.
FalseType HasReduce
Indique si le type peut être subir une réduction.
static constexpr const char * typeName()
Retourne le nom du type de la variable.
TrueType IsNumeric
Indique si le type est numérique.
static void dumpValue(String &s, const Type &v)
Ecrit dans la chaîne s la valeur de v.
static bool getValue(Type &v, const String &s)
Stocke la conversion de la chaîne s en le type Type dans v.
static constexpr eDataType type()
Retourne le type de la variable.
TrueType HasReduce
Indique si le type peut être subir une réduction.
TrueType HasDump
Indique si le type peut être sauvé et relu.
TrueType HasReduceMinMax
Indique si le type peut être subir une réduction Min/Max.
static bool getValue(Type &v, const String &s)
Stocke la conversion de la chaîne s en le type Type dans v.
TrueType HasReduceMinMax
Indique si le type peut être subir une réduction Min/Max.
static void dumpValue(String &s, const Type &v)
Ecrit dans la chaîne s la valeur de v.
TrueType HasDump
Indique si le type peut être sauvé et relu.
static constexpr const char * typeName()
Retourne le nom du type de la variable.
static constexpr eDataType type()
Retourne le type de la variable.
TrueType IsNumeric
Indique si le type est numérique.
TrueType HasReduce
Indique si le type peut être subir une réduction.
TrueType HasReduce
Indique si le type peut être subir une réduction.
static constexpr eDataType type()
Retourne le type de la variable.
static bool getValue(Type &v, const String &s)
Stocke la conversion de la chaîne s en le type Type dans v.
TrueType HasDump
Indique si le type peut être sauvé et relu.
TrueType IsNumeric
Indique si le type est numérique.
TrueType HasReduceMinMax
Indique si le type peut être subir une réduction Min/Max.
static void dumpValue(String &s, const Type &v)
Ecrit dans la chaîne s la valeur de v.
static constexpr const char * typeName()
Retourne le nom du type de la variable.
static bool getValue(Type &v, const String &s)
Stocke la conversion de la chaîne s en le type Type dans v.
static void dumpValue(String &s, const Type &v)
Ecrit dans la chaîne s la valeur de v.
TrueType HasDump
Indique si le type peut être sauvé et relu.
TrueType IsNumeric
Indique si le type est numérique.
FalseType HasReduceMinMax
Indique si le type peut être subir une réduction Min/Max.
static constexpr const char * typeName()
Retourne le nom du type de la variable.
static constexpr eDataType type()
Retourne le type de la variable.
TrueType HasReduce
Indique si le type peut être subir une réduction.
static constexpr eDataType type()
Retourne le type de la variable.
TrueType IsNumeric
Indique si le type est numérique.
static constexpr const char * typeName()
Retourne le nom du type de la variable.
TrueType HasReduce
Indique si le type peut être subir une réduction.
TrueType HasReduceMinMax
Indique si le type peut être subir une réduction Min/Max.
static bool getValue(Type &, const String &)
Stocke la conversion de la chaîne s en le type Type dans v.
TrueType HasDump
Indique si le type peut être sauvé et relu.
static void dumpValue(String &s, const Type &)
Ecrit dans la chaîne s la valeur de v.
TrueType HasReduceMinMax
Indique si le type peut être subir une réduction Min/Max.
TrueType HasDump
Indique si le type peut être sauvé et relu.
static constexpr eDataType type()
Retourne le type de la variable.
static constexpr const char * typeName()
Retourne le nom du type de la variable.
TrueType HasReduce
Indique si le type peut être subir une réduction.
static bool getValue(Type &, const String &)
Stocke la conversion de la chaîne s en le type Type dans v.
static void dumpValue(String &s, const Type &)
Ecrit dans la chaîne s la valeur de v.
TrueType IsNumeric
Indique si le type est numérique.
FalseType HasReduceMinMax
Indique si le type peut être subir une réduction Min/Max.
static constexpr eDataType type()
Retourne le type de la variable.
static constexpr const char * typeName()
Retourne le nom du type de la variable.
FalseType IsNumeric
Indique si le type est numérique.
TrueType HasDump
Indique si le type peut être sauvé et relu.
FalseType HasReduce
Indique si le type peut être subir une réduction.
static void dumpValue(String &s, const Type &v)
Ecrit dans la chaîne s la valeur de v.
static bool getValue(Type &v, const String &s)
Stocke la conversion de la chaîne s en le type Type dans v.
String Type
Type du paramètre template.
bool isZero(const BuiltInProxy< _Type > &a)
Teste si une valeur est exactement égale à zéro.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
std::int8_t Int8
Type entier signé sur 8 bits.
std::int64_t Int64
Type entier signé sur 64 bits.
Int32 Integer
Type représentant un entier.
void builtInDumpValue(String &s, const DataType &v)
Ecriture dans la chaine s d'un type basique de valeur v.
std::int16_t Int16
Type entier signé sur 16 bits.
double Real
Type représentant un réel.
unsigned char Byte
Type d'un octet.
Definition BaseTypes.h:43
float Float32
Type flottant IEEE-753 simple précision.
eDataType
Type d'une donnée.
Definition DataTypes.h:39
@ DT_Float32
Donnée de type 'Float32'.
Definition DataTypes.h:52
@ DT_Int128
Donnée de type entier sur 128 bits.
Definition DataTypes.h:55
@ DT_Real2x2
Donnée de type tenseur 3x3.
Definition DataTypes.h:48
@ DT_Int16
Donnée de type entier 16 bits.
Definition DataTypes.h:42
@ DT_Int8
Donnée de type entier sur 8 bits.
Definition DataTypes.h:53
@ DT_Real3x3
Donnée de type tenseur 3x3.
Definition DataTypes.h:49
@ DT_Int32
Donnée de type entier 32 bits.
Definition DataTypes.h:43
@ DT_Real3
Donnée de type vecteur 3.
Definition DataTypes.h:47
@ DT_Float16
Donnée de type 'Float16'.
Definition DataTypes.h:51
@ DT_Int64
Donnée de type entier 64 bits.
Definition DataTypes.h:44
@ DT_Unknown
Donnée de type inconnue ou non initialisée.
Definition DataTypes.h:56
@ DT_String
Donnée de type chaîne de caractère UTF-8.
Definition DataTypes.h:45
@ DT_BFloat16
Donnée de type 'BFloat16'.
Definition DataTypes.h:50
@ DT_Real2
Donnée de type vecteur 2.
Definition DataTypes.h:46
@ DT_Real
Donnée de type réel.
Definition DataTypes.h:41
@ DT_Byte
Donnée de type octet.
Definition DataTypes.h:40
@ DT_Float128
Donnée de type flottant sur 128 bits.
Definition DataTypes.h:54
std::int32_t Int32
Type entier signé sur 32 bits.
Arcane::BFloat16 BFloat16
Type 'Brain Float16'.
Arcane::Float16 Float16
Type 'Float16' (binary16)