std:: ldexp, std:: ldexpf, std:: ldexpl

Paramètres

Valeur de retour

Si aucune erreur ne se produit, num multiplié par 2 à la puissance exp ( num×2 exp
) est renvoyé.

Si une erreur de plage due à un dépassement de capacité se produit, ±HUGE_VAL , ±HUGE_VALF , ou ±HUGE_VALL est renvoyé.

Si une erreur de plage due à un dépassement inférieur se produit, le résultat correct (après arrondi) est retourné.

Gestion des erreurs

Les erreurs sont signalées comme spécifié dans math_errhandling .

Si l'implémentation prend en charge l'arithmétique à virgule flottante IEEE (IEC 60559),

• Sauf en cas d'erreur de plage, FE_INEXACT n'est jamais déclenché (le résultat est exact).
• Sauf en cas d'erreur de plage, le mode d'arrondi actuel est ignoré.
• Si num vaut ±0, il est retourné inchangé.
• Si num vaut ±∞, il est retourné inchangé.
• Si exp vaut 0, alors num est retourné inchangé.
• Si num est NaN, NaN est retourné.

Notes

Sur les systèmes binaires (où FLT_RADIX est 2 ), std::ldexp est équivalent à std::scalbn .

La fonction std::ldexp ("charger l'exposant"), ainsi que son dual, std::frexp , peut être utilisée pour manipuler la représentation d'un nombre à virgule flottante sans manipulations directes de bits.

Sur de nombreuses implémentations, std::ldexp est moins efficace que la multiplication ou la division par une puissance de deux en utilisant les opérateurs arithmétiques.

Les surcharges supplémentaires ne sont pas requises d'être fournies exactement comme (A) . Elles doivent seulement être suffisantes pour garantir que pour leur argument num de type entier, std :: ldexp ( num, exp ) ait le même effet que std :: ldexp ( static_cast < double > ( num ) , exp ) .

Pour l'exponentiation de 2 par un exposant à virgule flottante, std::exp2 peut être utilisé.

Exemple

#include <cerrno>
#include <cfenv>
#include <cmath>
#include <cstring>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
int main()
{
    std::cout
        << "ldexp(5, 3) = 5 * 8 = " << std::ldexp(5, 3) << '\n'
        << "ldexp(7, -4) = 7 / 16 = " << std::ldexp(7, -4) << '\n'
        << "ldexp(1, -1074) = " << std::ldexp(1, -1074)
        << " (minimum positive subnormal float64_t)\n"
        << "ldexp(nextafter(1,0), 1024) = "
        << std::ldexp(std::nextafter(1,0), 1024)
        << " (largest finite float64_t)\n";
    // special values
    std::cout << "ldexp(-0, 10) = " << std::ldexp(-0.0, 10) << '\n'
              << "ldexp(-Inf, -1) = " << std::ldexp(-INFINITY, -1) << '\n';
    // error handling
    std::feclearexcept(FE_ALL_EXCEPT);
    errno = 0;
    const double inf = std::ldexp(1, 1024);
    const bool is_range_error = errno == ERANGE;
    std::cout << "ldexp(1, 1024) = " << inf << '\n';
    if (is_range_error)
        std::cout << "    errno == ERANGE: " << std::strerror(ERANGE) << '\n';
    if (std::fetestexcept(FE_OVERFLOW))
        std::cout << "    FE_OVERFLOW raised\n";
}

ldexp(5, 3) = 5 * 8 = 40
ldexp(7, -4) = 7 / 16 = 0.4375
ldexp(1, -1074) = 4.94066e-324 (minimum positive subnormal float64_t)
ldexp(nextafter(1,0), 1024) = 1.79769e+308 (largest finite float64_t)
ldexp(-0, 10) = -0
ldexp(-Inf, -1) = -inf
ldexp(1, 1024) = inf
    errno == ERANGE: Résultat numérique hors limites
    FE_OVERFLOW raised

Voir aussi