Namespaces
Variants

std:: frexp, std:: frexpf, std:: frexpl

From cppreference.net
C++
Numerics library
Common mathematical functions
Nearest integer floating point operations
(C++11)
(C++11)
(C++11) (C++11) (C++11)
Floating point manipulation functions
(C++11) (C++11)
(C++11)
(C++11)
frexp
(C++11) (C++11)
(C++11)
Classification and comparison
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Types
(C++11)
(C++11)
(C++11)
Macro constants
Défini dans l'en-tête <cmath>
(1)
float frexp ( float num, int * exp ) ;

double frexp ( double num, int * exp ) ;

long double frexp ( long double num, int * exp ) ;
(jusqu'à C++23)
constexpr /* floating-point-type */
frexp ( /* floating-point-type */ num, int * exp ) ;
(depuis C++23)
float frexpf ( float num, int * exp ) ;
(2) (depuis C++11)
(constexpr depuis C++23)
long double frexpl ( long double num, int * exp ) ;
(3) (depuis C++11)
(constexpr depuis C++23)
Défini dans l'en-tête <cmath>
template < class Integer >
double frexp ( Integer num, int * exp ) ;
(A) (constexpr depuis C++23)
1-3) Décompose la valeur à virgule flottante donnée num en une fraction normalisée et un exposant entier de deux. La bibliothèque fournit des surcharges de std::frexp pour tous les types à virgule flottante non qualifiés cv comme type du paramètre num . (depuis C++23)
A) Des surcharges supplémentaires sont fournies pour tous les types entiers, qui sont traités comme double .
(depuis C++11)

Table des matières

Paramètres

num - valeur à virgule flottante ou entière
exp - pointeur vers une valeur entière pour stocker l'exposant

Valeur de retour

Si num est zéro, retourne zéro et stocke zéro dans * exp .

Sinon (si num n'est pas zéro), si aucune erreur ne se produit, retourne la valeur x dans l'intervalle (-1, -0.5], [0.5, 1) et stocke une valeur entière dans * exp telle que x×2 (*exp)
== num .

Si la valeur à stocker dans * exp est en dehors de la plage de int , le comportement n'est pas spécifié.

Gestion des erreurs

Cette fonction n'est sujette à aucune erreur spécifiée dans math_errhandling .

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

  • Si num est ±0, il est retourné inchangé, et ​ 0 ​ est stocké dans * exp .
  • Si num est ±∞, il est retourné, et une valeur non spécifiée est stockée dans * exp .
  • Si num est NaN, NaN est retourné, et une valeur non spécifiée est stockée dans * exp .
  • Aucune exception en virgule flottante n'est levée.
  • Si FLT_RADIX vaut 2 (ou une puissance de 2), la valeur retournée est exacte, le mode d'arrondi actuel est ignoré.

Notes

Sur un système binaire (où FLT_RADIX est 2 ), std::frexp peut être implémenté comme 

{
    *exp = (value == 0) ? 0 : (int)(1 + std::logb(value));
    return std::scalbn(value, -(*exp));
}

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

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

Exemple

Compare différentes fonctions de décomposition en virgule flottante :

Exécuter ce code 
#include <cmath>
#include <iostream>
#include <limits>
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';
}

Sortie possible : 

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

Voir aussi

(C++11) (C++11)
multiplie un nombre par 2 élevé à une puissance entière
(fonction)
(C++11) (C++11) (C++11)
extrait l'exposant du nombre
(fonction)
(C++11) (C++11) (C++11)
extrait l'exposant du nombre
(fonction)
(C++11) (C++11)
décompose un nombre en parties entière et fractionnaire
(fonction)
Documentation C pour frexp