std:: logb, std:: logbf, std:: logbl

Formellement, l'exposant non biaisé est la partie entière signée de log r |num| (retournée par cette fonction comme valeur flottante), pour un num non nul, où r est std:: numeric_limits < T > :: radix et T est le type flottant de num . Si num est sous-normal, il est traité comme s'il était normalisé.

Paramètres

Valeur de retour

Si aucune erreur ne se produit, l'exposant non biaisé de num est renvoyé comme une valeur en virgule flottante signée.

Si une erreur de domaine se produit, une valeur définie par l'implémentation est retournée.

Si une erreur de pôle se produit, -HUGE_VAL , -HUGE_VALF , ou -HUGE_VALL est retourné.

Gestion des erreurs

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

Une erreur de domaine ou de plage peut survenir si num est nul.

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

• Si num est ±0, -∞ est retourné et FE_DIVBYZERO est déclenché.
• Si num est ±∞, +∞ est retourné.
• Si num est NaN, NaN est retourné.
• Dans tous les autres cas, le résultat est exact ( FE_INEXACT n'est jamais déclenché) et le mode d'arrondi actuel est ignoré.

Notes

POSIX exige qu'une erreur de pôle se produise si num est ±0.

La valeur de l'exposant retourné par std::logb est toujours inférieure de 1 à l'exposant retourné par std::frexp en raison des différentes exigences de normalisation : pour l'exposant e retourné par std::logb , |num*r -e
| est compris entre 1 et r (typiquement entre 1 et 2 ), mais pour l'exposant e retourné par std::frexp , |num*2 -e
| est compris entre 0.5 et 1 .

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 :: logb ( num ) ait le même effet que std :: logb ( static_cast < double > ( num ) ) .

Exemple

#include <cfenv>
#include <cmath>
#include <iostream>
#include <limits>
// #pragma STDC FENV_ACCESS ON
int main()
{
    double f = 123.45;
    std::cout << "Given the number " << f << " or " << std::hexfloat
              << f << std::defaultfloat << " in hex,\n";
    double f3;
    double f2 = std::modf(f, &f3);
    std::cout << "modf() makes " << f3 << " + " << f2 << '\n';
    int i;
    f2 = std::frexp(f, &i);
    std::cout << "frexp() makes " << f2 << " * 2^" << i << '\n';
    i = std::ilogb(f);
    std::cout << "logb()/ilogb() make " << f / std::scalbn(1.0, i) << " * "
              << std::numeric_limits<double>::radix
              << "^" << std::ilogb(f) << '\n';
    // error handling
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "logb(0) = " << std::logb(0) << '\n';
    if (std::fetestexcept(FE_DIVBYZERO))
        std::cout << "    FE_DIVBYZERO raised\n";
}

Given the number 123.45 or 0x1.edccccccccccdp+6 in hex,
modf() makes 123 + 0.45
frexp() makes 0.964453 * 2^7
logb()/ilogb() make 1.92891 * 2^6
logb(0) = -Inf
    FE_DIVBYZERO raised

Voir aussi