std::numeric_limits::tinyness_before - cppreference.com

Da cppreference.com.

Questa pagina è stata tradotta in modo automatico dalla versione in ineglese della wiki usando Google Translate.

La traduzione potrebbe contenere errori e termini strani. Muovi il puntatore sopra al testo per vedere la versione originale. Puoi aiutarci a correggere gli gli errori. Per ulteriori istruzioni clicca qui.

Click here for the English version of this page


`static const bool tinyness_before`		(fino al c++11)

`static constexpr bool tinyness_before`		(dal C++11)

Il valore di std::numeric_limits<T>::has_denorm_loss è true per tutti i tipi a virgola mobile T che i risultati dei test di virgola mobile espressioni per underflow prima arrotondamento.

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.

Specializzazioni standard


`T`	valore di `std::numeric_limits<T>::tinyness_before` Original: value of `std::numeric_limits<T>::tinyness_before` The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

/* 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`	implementazione definita Original: implementation-defined The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

`double`	implementazione definita Original: implementation-defined The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

`long double`	implementazione definita Original: implementation-defined The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

Note

Standard-compliant IEEE 754 in virgola mobile implementazioni può rilevare in virgola mobile underflow in tre momenti predefiniti:

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.

dopo il calcolo di un risultato di valore assoluto inferiore a std::numeric_limits<T>::min(), tale attuazione rileva tinyness prima di arrotondare (ad es 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.

dopo l'arrotondamento del risultato a pezzi std::numeric_limits<T>::digits, se il risultato è molto piccolo, tale attuazione rileva tinyness dopo l'arrotondamento (per esempio SuperSPARC)

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.

se la conversione del risultato arrotondato minuscolo a forma subnormal provocato la perdita di precisione, tale attuazione rileva la perdita 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.

Esempio

Moltiplicazione del maggior numero subnormale dal numero epsilon una macchina superiore a 1,0 indica il valore del piccolo 0x0.fffffffffffff8p-1022 prima di arrotondare, ma il valore normale 1p-1022 dopo l'arrotondamento .

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';
}

Output:

Inexact result detected
0x0.fffffffffffffp-1022 x 0x1.0000000000001p+0 = 0x1p-1022

Vedi anche


	identifies the floating-point types that detect loss of precision as denormalization loss rather than inexact result (pubblico membro statico costante) [modifica]

	identifica lo stile denormalizzazione utilizzato dal tipo a virgola mobile Original: identifies the denormalization style used by the floating-point type The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (pubblico membro statico costante) [modifica]