std::numeric_limits::tinyness_before — cppreference.com
De cppreference.com
<metanoindex/>
<tbody> </tbody>
|
|
(avant C++11) | |
|
|
(depuis C++11) | |
La valeur de std::numeric_limits<T>::has_denorm_loss est true pour tous les types à virgule flottante T que les résultats des tests de virgule flottante expressions de débordement avant arrondissement .
Original:
The value of std::numeric_limits<T>::has_denorm_loss is true for all floating-point types T that test results of floating-point expressions for underflow before rounding.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Spécialisations standard
T
|
valeur de Original: value of The text has been machine-translated via Google Translate. |
| /* non-specialized */ | false
|
bool
|
false
|
char
|
false
|
signed char
|
false
|
unsigned char
|
false
|
wchar_t
|
false
|
char16_t
|
false
|
char32_t
|
false
|
short
|
false
|
unsigned short
|
false
|
int
|
false
|
unsigned int
|
false
|
long
|
false
|
unsigned long
|
false
|
long long
|
false
|
unsigned long long
|
false
|
float
|
défini par l'implémentation Original: implementation-defined The text has been machine-translated via Google Translate. |
double
|
défini par l'implémentation Original: implementation-defined The text has been machine-translated via Google Translate. |
long double
|
défini par l'implémentation Original: implementation-defined The text has been machine-translated via Google Translate. |
Notes
Conformes à la norme IEEE 754 en virgule flottante implémentations peuvent détecter le dépassement inférieur à virgule flottante à trois moments prédéfinis:
Original:
Standard-compliant IEEE 754 floating-point implementations may detect the floating-point underflow at three predefined moments:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
1)
après calcul d'un résultat à la valeur absolue plus petite que std::numeric_limits<T>::min(), cette mise en oeuvre détecte tinyness avant arrondi (par exemple UltraSparc)
Original:
after computation of a result with absolute value smaller than std::numeric_limits<T>::min(), such implementation detects tinyness before rounding (e.g. UltraSparc)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
2)
après arrondi du résultat de bits de std::numeric_limits<T>::digits, si le résultat est minuscule, cette mise en œuvre détecte tinyness après arrondi (p. ex SPARC)
Original:
after rounding of the result to std::numeric_limits<T>::digits bits, if the result is tiny, such implementation detects tinyness after rounding (e.g. SuperSparc)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
3)
si la conversion du résultat arrondi à la forme minuscule inférieure à la normale ont entraîné la perte de précision, cette mise en œuvre détecte une perte denorm .
Original:
if the conversion of the rounded tiny result to subnormal form resulted in the loss of precision, such implementation detects denorm loss.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Exemple
La multiplication du plus grand nombre inférieur à la normale par l'epsilon machine de numéro un supérieur à 1,0 donne la valeur minuscule 0x0.fffffffffffff8p-1022 avant d'arrondir, mais la valeur normale 1p-1022 après avoir contourné .
Original:
Multiplication of the largest subnormal number by the number one machine epsilon greater than 1.0 gives the tiny value 0x0.fffffffffffff8p-1022 before rounding, but normal value 1p-1022 after rounding.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
#include <iostream> #include <limits> #include <cmath> #include <cfenv> int main() { double denorm_max = std::nextafter(std::numeric_limits<double>::min(), 0); double multiplier = 1 + std::numeric_limits<double>::epsilon(); std::feclearexcept(FE_ALL_EXCEPT); double result = denorm_max*multiplier; // Underflow only if tinyness_before if(std::fetestexcept(FE_UNDERFLOW)) std::cout << "Underflow detected\n"; else if (std::fetestexcept(FE_INEXACT)) std::cout << "Inexact result detected\n"; std::cout << std::hexfloat << denorm_max << " x " << multiplier << " = " << result << '\n'; }
Résultat :
Inexact result detected 0x0.fffffffffffffp-1022 x 0x1.0000000000001p+0 = 0x1p-1022
Voir aussi
[ statique Original: static The text has been machine-translated via Google Translate. |
identifie les types à virgule flottante qui détectent une perte de précision que la perte de dénormalisation plutôt que des résultats inexacts Original: identifies the floating-point types that detect loss of precision as denormalization loss rather than inexact result The text has been machine-translated via Google Translate. (constante membre statique publique) [edit] |
[ statique Original: static The text has been machine-translated via Google Translate. |
identifie le style utilisé par la dénormalisation du type à virgule flottante Original: identifies the denormalization style used by the floating-point type The text has been machine-translated via Google Translate. (constante membre statique publique) [edit] |