std:: scalbn, std:: scalbnf, std:: scalbnl, std:: scalbln, std:: scalblnf, std:: scalblnl

Paramètres

Valeur de retour

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

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::scalbn est équivalent à std::ldexp .

Bien que std::scalbn et std::scalbln soient conçus pour effectuer l'opération efficacement, dans de nombreuses implémentations ils sont moins efficaces qu'une multiplication ou division par une puissance de deux utilisant les opérateurs arithmétiques.

Le nom de la fonction signifie « new scalb », où scalb était une ancienne fonction non standard dont le deuxième argument était de type flottant.

La fonction std::scalbln est fournie car le facteur requis pour passer de la plus petite valeur positive en virgule flottante à la plus grande valeur finie peut être supérieur à 32767, le INT_MAX garanti par la norme. En particulier, pour le long double 80 bits, le facteur est de 32828.

L'implémentation GNU ne définit pas errno indépendamment de math_errhandling .

Les surcharges supplémentaires ne sont pas tenues d'être fournies exactement sous la forme (A,B) . Elles doivent seulement être suffisantes pour garantir que pour leur argument num de type entier :

• std :: scalbn ( num, exp ) a le même effet que std :: scalbn ( static_cast < double > ( num ) , exp ) .
• std :: scalbln ( num, exp ) a le même effet que std :: scalbln ( static_cast < double > ( num ) , exp ) .

Exemple

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

scalbn(7, -4) = 0.4375
scalbn(1, -1074) = 4.94066e-324 (minimum positive subnormal double)
scalbn(nextafter(1,0), 1024) = 1.79769e+308 (largest finite double)
scalbn(-0, 10) = -0
scalbn(-Inf, -1) = -inf
scalbn(1, 1024) = inf
    errno == ERANGE: Numerical result out of range
    FE_OVERFLOW raised

Voir aussi