12#ifndef ARCANE_CORE_VARIABLEDATATYPETRAITS_H
13#define ARCANE_CORE_VARIABLEDATATYPETRAITS_H
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"
39template <
typename DataType>
inline void
42 std::ostringstream sbuf;
55template <
typename DataType>
92 typedef Byte BasicType;
94 static constexpr Integer nbBasicType() {
return 1; }
96 typedef Byte NormType;
101 static constexpr const char*
typeName() {
return "Byte"; }
113 static bool verifDifferent(
Byte v1,
Byte v2,
Byte& diff,
114 [[maybe_unused]]
bool is_nan_equal =
false)
116 return _verifDifferent(v1, v2, diff, v1);
118 static bool verifDifferentNorm(Type v1, Type v2, Type& diff, Type norm,
119 [[maybe_unused]]
bool is_nan_equal =
false)
121 return _verifDifferent(v1, v2, diff, norm);
124 static NormType normeMax(Byte v)
126 return static_cast<Byte>(math::abs(v));
131 static bool _verifDifferent(Type v1, Type v2, Type& diff, Type divider)
134 auto abs_diff = v1 - v2;
135 if (!math::isZero(divider))
136 abs_diff = abs_diff / divider;
137 diff =
static_cast<Byte>(diff);
159 typedef TrueType HasDump;
162 typedef TrueType HasReduce;
165 typedef TrueType HasReduceMinMax;
168 typedef TrueType IsNumeric;
170 typedef Real BasicType;
172 static constexpr Integer nbBasicType() {
return 1; }
174 typedef Real NormType;
179 static constexpr const char* typeName() {
return "Real"; }
189 static bool getValue(Type& v,
const String& s) {
return builtInGetValue(v, s); }
191 static bool verifDifferentNorm(Type v1, Type v2, Type& diff, Type norm,
bool is_nan_equal =
false)
193 return _verifDifferent(v1, v2, diff, norm, is_nan_equal);
196 static bool verifDifferent(Type v1, Type v2, Type& diff,
bool is_nan_equal =
false)
198 return _verifDifferent(v1, v2, diff, math::abs(v1), is_nan_equal);
201 static NormType normeMax(Real v)
208 static bool _verifDifferent(Type v1, Type v2, Type& diff, Type divider,
bool is_nan_equal)
211 if (std::isnan(v1) && std::isnan(v2))
216 if (platform::isDenormalized(v1) || platform::isDenormalized(v2)) {
221 if (divider < 1.e-100)
224 diff = (v1 - v2) / divider;
259 static constexpr Int32 nbBasicType() {
return 1; }
266 static constexpr const char*
typeName() {
return "Float128"; }
278 static bool verifDifferent(Type v1, Type v2, Type& diff, [[maybe_unused]]
bool is_nan_equal =
false)
280 return _verifDifferent(v1, v2, diff, math::abs(v1));
283 static bool verifDifferentNorm(Type v1, Type v2, Type& diff, NormType norm, [[maybe_unused]]
bool is_nan_equal)
285 return _verifDifferent(v1, v2, diff, norm);
288 static NormType normeMax(Float128 v)
295 static bool _verifDifferent(Type v1, Type v2, Type& diff, Type divider)
298 if (divider < 1.e-100)
301 diff = (v1 - v2) / divider;
334 typedef Int8 BasicType;
336 static constexpr Int32 nbBasicType() {
return 1; }
338 typedef Int8 NormType;
343 static constexpr const char*
typeName() {
return "Int8"; }
354 static bool verifDifferent(
Int8 v1,
Int8 v2,
Int8& diff,
355 [[maybe_unused]]
bool is_nan_equal =
false)
359 diff = (
Int8)(v1 - v2);
361 diff = (
Int8)((v1 - v2) / v1);
366 static bool verifDifferentNorm(Type v1, Type v2, Type& diff,
367 [[maybe_unused]] NormType norm,
368 [[maybe_unused]]
bool is_nan_equal =
false)
370 return verifDifferent(v1, v2, diff, is_nan_equal);
372 static NormType normeMax(Int8 v)
374 return static_cast<Int8>(math::abs(v));
404 typedef Int16 BasicType;
406 static constexpr Integer nbBasicType() {
return 1; }
408 typedef Int16 NormType;
413 static constexpr const char*
typeName() {
return "Int16"; }
425 [[maybe_unused]]
bool is_nan_equal =
false)
429 diff = (
Int16)(v1 - v2);
431 diff = (
Int16)((v1 - v2) / v1);
436 static bool verifDifferentNorm(Type v1, Type v2, Type& diff,
437 [[maybe_unused]] NormType norm,
438 [[maybe_unused]]
bool is_nan_equal =
false)
440 return verifDifferent(v1, v2, diff, is_nan_equal);
442 static NormType normeMax(Int16 v)
474 typedef Int32 BasicType;
476 static constexpr Integer nbBasicType() {
return 1; }
478 typedef Int32 NormType;
483 static constexpr const char*
typeName() {
return "Int32"; }
495 [[maybe_unused]]
bool is_nan_equal =
false)
501 diff = (v1 - v2) / v1;
506 static bool verifDifferentNorm(Type v1, Type v2, Type& diff,
507 [[maybe_unused]] NormType norm,
508 [[maybe_unused]]
bool is_nan_equal =
false)
510 return verifDifferent(v1, v2, diff, is_nan_equal);
513 static NormType normeMax(Int32 v)
545 typedef Int64 BasicType;
547 static constexpr Integer nbBasicType() {
return 1; }
549 typedef Int64 NormType;
554 static constexpr const char*
typeName() {
return "Int64"; }
566 static bool verifDifferent(Type v1, Type v2, Type& diff,
567 [[maybe_unused]]
bool is_nan_equal =
false)
573 diff = (v1 - v2) / v1;
579 static bool verifDifferentNorm(Type v1, Type v2, Type& diff,
580 [[maybe_unused]] NormType norm,
581 [[maybe_unused]]
bool is_nan_equal =
false)
583 return verifDifferent(v1, v2, diff, is_nan_equal);
586 static NormType normeMax(Int64 v)
620 static constexpr Int32 nbBasicType() {
return 1; }
627 static constexpr const char*
typeName() {
return "Int128"; }
639 static bool verifDifferent(Type v1, Type v2, Type& diff,
640 [[maybe_unused]]
bool is_nan_equal =
false)
646 diff = (v1 - v2) / v1;
652 static bool verifDifferentNorm(Type v1, Type v2, Type& diff,
653 [[maybe_unused]] NormType norm,
654 [[maybe_unused]]
bool is_nan_equal =
false)
656 return verifDifferent(v1, v2, diff, is_nan_equal);
659 static NormType normeMax(Int16 v)
661 return static_cast<Int16
>(math::abs(v));
696 static constexpr Integer nbBasicType() {
return 1; }
701 static constexpr const char*
typeName() {
return "String"; }
713 static bool verifDifferent(
const Type v1,
const Type& v2, Type& diff,
714 [[maybe_unused]]
bool is_nan_equal =
false)
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)
723 return verifDifferent(v1, v2, diff, is_nan_equal);
755 static constexpr Integer nbBasicType() {
return 1; }
762 static constexpr const char*
typeName() {
return "BFloat16"; }
774 static bool verifDifferent(
float v1,
float v2,
BFloat16& diff,
775 [[maybe_unused]]
bool is_nan_equal =
false)
777 return _verifDifferent(v1, v2, diff, math::abs(v1));
780 static bool verifDifferentNorm(
float v1,
float v2, BFloat16& diff, NormType norm,
781 [[maybe_unused]]
bool is_nan_equal =
false)
783 return _verifDifferent(v1, v2, diff, norm);
788 return static_cast<Type
>(math::abs(v));
793 static bool _verifDifferent(
float v1,
float v2, BFloat16& diff,
float divider)
800 fdiff = (v1 - v2) / divider;
801 diff =
static_cast<Type
>(fdiff);
836 static constexpr Integer nbBasicType() {
return 1; }
843 static constexpr const char*
typeName() {
return "Float16"; }
855 static bool verifDifferent(
float v1,
float v2,
Float16& diff,
856 [[maybe_unused]]
bool is_nan_equal =
false)
858 return _verifDifferent(v1, v2, diff, math::abs(v1));
861 static bool verifDifferentNorm(
float v1,
float v2, Float16& diff, NormType norm,
862 [[maybe_unused]]
bool is_nan_equal =
false)
864 return _verifDifferent(v1, v2, diff, norm);
867 static Float16 normeMax(Float16 v)
869 return static_cast<Float16>(math::abs(v));
874 static bool _verifDifferent(
float v1,
float v2, Float16& diff,
float divider)
881 fdiff = (v1 - v2) / divider;
882 diff =
static_cast<Type
>(fdiff);
915 typedef Real BasicType;
917 static constexpr Integer nbBasicType() {
return 1; }
924 static constexpr const char*
typeName() {
return "Float32"; }
936 static bool verifDifferentNorm(Type v1, Type v2, Type& diff, NormType norm,
bool is_nan_equal =
false)
938 return _verifDifferent(v1, v2, diff, norm, is_nan_equal);
941 static bool verifDifferent(Type v1, Type v2, Type& diff,
bool is_nan_equal =
false)
943 return _verifDifferent(v1, v2, diff, math::abs(v1), is_nan_equal);
946 static Float32 normeMax(Float32 v)
953 static bool _verifDifferent(Type v1, Type v2, Type& diff, Type divider,
bool is_nan_equal)
956 if (std::isnan(v1) && std::isnan(v2))
961 if (platform::isDenormalized(v1) || platform::isDenormalized(v2)) {
966 if (divider < 1.e-40)
969 diff = (v1 - v2) / divider;
991 typedef TrueType HasDump;
994 typedef TrueType HasReduce;
997 typedef TrueType HasReduceMinMax;
1000 typedef TrueType IsNumeric;
1002 typedef Real BasicType;
1004 static constexpr Integer nbBasicType() {
return 2; }
1006 typedef Real NormType;
1010 using SubTraits = VariableDataTypeTraitsT<Real>;
1015 static constexpr const char* typeName() {
return "Real2"; }
1019 static void dumpValue(String& s,
const Type&) { s =
"N/A"; }
1025 static bool getValue(Type& v,
const String& s) {
return builtInGetValue(v, s); }
1027 static bool verifDifferent(Real2 v1, Real2 v2, Real2& diff,
bool is_nan_equal =
false)
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;
1035 static bool verifDifferentNorm(
const Real2& v1,
const Real2& v2, Real2& diff,
1036 NormType norm, [[maybe_unused]]
bool is_nan_equal)
1038 if (norm < 1.e-100) {
1039 diff.x = math::abs(v2.x);
1040 diff.y = math::abs(v2.y);
1043 diff.x = math::abs(v2.x - v1.x) / norm;
1044 diff.y = math::abs(v2.y - v1.y) / norm;
1046 bool is_different = (normeMax(diff) != 0.);
1047 return is_different;
1050 static NormType normeMax(
const Real2& v)
1052 Real vx = SubTraits::normeMax(v.x);
1053 Real vy = SubTraits::normeMax(v.y);
1054 return math::max(vx, vy);
1073 typedef TrueType HasDump;
1076 typedef TrueType HasReduce;
1079 typedef TrueType HasReduceMinMax;
1082 typedef TrueType IsNumeric;
1084 typedef Real BasicType;
1086 static constexpr Integer nbBasicType() {
return 3; }
1088 typedef Real NormType;
1092 using SubTraits = VariableDataTypeTraitsT<Real>;
1097 static constexpr const char* typeName() {
return "Real3"; }
1101 static void dumpValue(String& s,
const Type&) { s =
"N/A"; }
1107 static bool getValue(Type& v,
const String& s) {
return builtInGetValue(v, s); }
1109 static bool verifDifferent(Real3 v1, Real3 v2, Real3& diff,
bool is_nan_equal =
false)
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;
1118 static bool verifDifferentNorm(
const Real3& v1,
const Real3& v2, Real3& diff,
1119 NormType norm, [[maybe_unused]]
bool is_nan_equal)
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);
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;
1131 bool is_different = (normeMax(diff) != 0.);
1132 return is_different;
1135 static NormType normeMax(
const Real3& v)
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));
1170 typedef Real BasicType;
1172 static constexpr Integer nbBasicType() {
return 4; }
1174 typedef Real NormType;
1183 static constexpr const char*
typeName() {
return "Real2x2"; }
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;
1203 static bool verifDifferentNorm(
const Real2x2& v1,
const Real2x2& v2, Real2x2& diff,
1204 NormType norm, [[maybe_unused]]
bool is_nan_equal)
1206 if (norm < 1.e-100) {
1207 diff.x.x = math::abs(v2.x.x);
1208 diff.x.y = math::abs(v2.x.y);
1210 diff.y.x = math::abs(v2.y.x);
1211 diff.y.y = math::abs(v2.y.y);
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;
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;
1220 bool is_different = (normeMax(diff) != 0.);
1221 return is_different;
1224 static NormType normeMax(
const Real2x2& v)
1226 Real vx = SubTraits::normeMax(v.x);
1227 Real vy = SubTraits::normeMax(v.y);
1228 return SubTraits::normeMax(Real2(vx, vy));
1258 typedef Real BasicType;
1260 static constexpr Integer nbBasicType() {
return 9; }
1262 typedef Real NormType;
1271 static constexpr const char*
typeName() {
return "Real3x3"; }
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;
1292 static bool verifDifferentNorm(
const Real3x3& v1,
const Real3x3& v2, Real3x3& diff,
1293 NormType norm, [[maybe_unused]]
bool is_nan_equal)
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);
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);
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);
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;
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;
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;
1321 bool is_different = (normeMax(diff) != 0.);
1322 return is_different;
1325 static NormType normeMax(
const Real3x3& v)
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));
Fichier contenant les définitions des types de données gérés par Arcane.
Type flottant sur 128 bits.
Type flottant demi-précision.
Type entier sur 128 bits.
Classe gérant un vecteur de réel de dimension 2.
Classe gérant une matrice de réel de dimension 2x2.
Real2 x
Première composante.
Real2 y
Deuxième composante.
Classe gérant un vecteur de réel de dimension 3.
Classe gérant une matrice de réel de dimension 3x3.
Real3 z
premier élément du triplet
Real3 y
premier élément du triplet
Real3 x
premier élément du triplet
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.
Int16 Type
Type du paramètre template.
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.
Int32 Type
Type du paramètre template.
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.
Int64 Type
Type du paramètre template.
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.
Int8 Type
Type du paramètre template.
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.
Real2x2 Type
Type du paramètre template.
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.
Real3x3 Type
Type du paramètre template.
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.
float Float32
Type flottant IEEE-753 simple précision.
eDataType
Type d'une donnée.
@ DT_Float32
Donnée de type 'Float32'.
@ DT_Int128
Donnée de type entier sur 128 bits.
@ DT_Real2x2
Donnée de type tenseur 3x3.
@ DT_Int16
Donnée de type entier 16 bits.
@ DT_Int8
Donnée de type entier sur 8 bits.
@ DT_Real3x3
Donnée de type tenseur 3x3.
@ DT_Int32
Donnée de type entier 32 bits.
@ DT_Real3
Donnée de type vecteur 3.
@ DT_Float16
Donnée de type 'Float16'.
@ DT_Int64
Donnée de type entier 64 bits.
@ DT_Unknown
Donnée de type inconnue ou non initialisée.
@ DT_String
Donnée de type chaîne de caractère UTF-8.
@ DT_BFloat16
Donnée de type 'BFloat16'.
@ DT_Real2
Donnée de type vecteur 2.
@ DT_Real
Donnée de type réel.
@ DT_Byte
Donnée de type octet.
@ DT_Float128
Donnée de type flottant sur 128 bits.
std::int32_t Int32
Type entier signé sur 32 bits.
Arcane::BFloat16 BFloat16
Type 'Brain Float16'.
Arcane::Float16 Float16
Type 'Float16' (binary16)