Namespaces
Variants

std::numeric_limits<T>:: tinyness_before

From cppreference.net
Utilities library
static const bool tinyness_before ;
(jusqu'à C++11)
static constexpr bool tinyness_before ;
(depuis C++11)

La valeur de std:: numeric_limits < T > :: tinyness_before est true pour tous les types à virgule flottante T qui testent les résultats des expressions à virgule flottante pour le dépassement inférieur avant l'arrondi.

Table des matières

Spécialisations standards

T valeur de std:: numeric_limits < T > :: tinyness_before
/* non-spécialisé */ false
bool false
char false
signed char false
unsigned char false
wchar_t false
char8_t (depuis C++20) false
char16_t (depuis C++11) false
char32_t (depuis C++11) false
short false
unsigned short false
int false
unsigned int false
long false
unsigned long false
long long (depuis C++11) false
unsigned long long (depuis C++11) false
float défini par l'implémentation
double défini par l'implémentation
long double défini par l'implémentation

Notes

Les implémentations conformes aux normes IEEE 754 en virgule flottante doivent détecter le dépassement inférieur en virgule flottante, et présentent deux situations alternatives où cela peut être réalisé

  1. Un dépassement inférieur se produit (et FE_UNDERFLOW peut être déclenché) si un calcul produit un résultat dont la valeur absolue, calculée comme si la plage d'exposants et la précision étaient illimitées, est inférieure à std:: numeric_limits < T > :: min ( ) . Une telle implémentation détecte la petitesse avant l'arrondi (par exemple UltraSparc, POWER).
  2. Un dépassement inférieur se produit (et FE_UNDERFLOW peut être déclenché) si après l'arrondi du résultat vers le type à virgule flottante cible (c'est-à-dire l'arrondi à std:: numeric_limits < T > :: digits bits), la valeur absolue du résultat est inférieure à std:: numeric_limits < T > :: min ( ) . Formellement, la valeur absolue d'un résultat non nul calculé comme si la plage d'exposants était illimitée est inférieure à std:: numeric_limits < T > :: min ( ) . Une telle implémentation détecte la petitesse après l'arrondi (par exemple SuperSparc).

Exemple

La multiplication du plus grand nombre sous-normal par un nombre supérieur d'un epsilon machine à 1.0 donne la petite valeur 0x0.fffffffffffff8p-1022 avant arrondi, mais la valeur normalisée 1p-1022 après arrondi. L'implémentation utilisée pour exécuter ce test ( IBM Power7 ) détecte la petitesse avant arrondi.

#include <iostream>
#include <limits>
#include <cmath>
#include <cfenv>
int main()
{
    std::cout << "Tinyness before: " << std::boolalpha
              << std::numeric_limits<double>::tinyness_before << '\n';
    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";
    std::cout << std::hexfloat << denorm_max << " x " << multiplier  <<  " = "
              << result << '\n';
}

Sortie possible :

Tinyness before: true
Underflow detected
0xf.ffffffffffffp-1030 x 0x1.0000000000001p+0 = 0x1p-1022

Voir aussi

identifie les types à virgule flottante qui détectent la perte de précision comme une perte par dénormalisation plutôt qu'un résultat inexact
(constante de membre public static)
[static]
identifie le style de dénormalisation utilisé par le type à virgule flottante
(constante de membre public static)