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
Definiert im Header <cmath>
(1)
float frexp ( float num, int * exp ) ;

double frexp ( double num, int * exp ) ;

long double frexp ( long double num, int * exp ) ;
(bis C++23)
constexpr /* floating-point-type */
frexp ( /* floating-point-type */ num, int * exp ) ;
(seit C++23)
float frexpf ( float num, int * exp ) ;
(2) (seit C++11)
(constexpr seit C++23)
long double frexpl ( long double num, int * exp ) ;
(3) (seit C++11)
(constexpr seit C++23)
Definiert im Header <cmath>
template < class Integer >
double frexp ( Integer num, int * exp ) ;
(A) (constexpr seit C++23)
1-3) Zerlegt den gegebenen Gleitkommawert num in einen normalisierten Bruch und einen ganzzahligen Zweier-Exponenten. Die Bibliothek stellt Überladungen von std::frexp für alle cv-unqualifizierten Gleitkommatypen als Typ des Parameters num bereit. (since C++23)
A) Zusätzliche Überladungen werden für alle Ganzzahltypen bereitgestellt, die als double behandelt werden.
(since C++11)

Inhaltsverzeichnis

Parameter

num - Fließkomma- oder Ganzzahlwert
exp - Zeiger auf einen Ganzzahlwert, in dem der Exponent gespeichert wird

Rückgabewert

Wenn num null ist, wird null zurückgegeben und null in * exp gespeichert.

Andernfalls (wenn num nicht null ist), falls keine Fehler auftreten, gibt den Wert x im Bereich (-1, -0.5], [0.5, 1) zurück und speichert einen ganzzahligen Wert in * exp , sodass x×2 (*exp)
== num .

Wenn der zu speichernde Wert in * exp außerhalb des Bereichs von int liegt, ist das Verhalten nicht spezifiziert.

Fehlerbehandlung

Diese Funktion unterliegt keinen Fehlern, die in math_errhandling spezifiziert sind.

Wenn die Implementierung IEEE-Gleitkommaarithmetik (IEC 60559) unterstützt,

  • Wenn num ±0 ist, wird es unverändert zurückgegeben und ​ 0 ​ in * exp gespeichert.
  • Wenn num ±∞ ist, wird es zurückgegeben und ein nicht spezifizierter Wert in * exp gespeichert.
  • Wenn num NaN ist, wird NaN zurückgegeben und ein nicht spezifizierter Wert in * exp gespeichert.
  • Es werden keine Gleitkomma-Ausnahmen ausgelöst.
  • Wenn FLT_RADIX 2 (oder eine Potenz von 2) ist, ist der zurückgegebene Wert exakt, der aktuelle Rundungsmodus wird ignoriert.

Hinweise

In einem binären System (wo FLT_RADIX gleich 2 ist), kann std::frexp implementiert werden als 

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

Die Funktion std::frexp , zusammen mit ihrem Gegenstück, std::ldexp , kann verwendet werden, um die Darstellung einer Fließkommazahl zu manipulieren, ohne direkte Bit-Manipulationen durchzuführen.

Die zusätzlichen Überladungen müssen nicht exakt wie (A) bereitgestellt werden. Sie müssen lediglich sicherstellen, dass für ihr Argument num vom Ganzzahltyp std :: frexp ( num, exp ) die gleiche Wirkung hat wie std :: frexp ( static_cast < double > ( num ) , exp ) .

Beispiel

Vergleicht verschiedene Gleitkomma-Zerlegungsfunktionen:

Diesen Code ausführen 
#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';
}

Mögliche Ausgabe: 

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

Siehe auch

(C++11) (C++11)
multipliziert eine Zahl mit 2 potenziert mit einem ganzzahligen Exponenten
(Funktion)
(C++11) (C++11) (C++11)
extrahiert den Exponenten der Zahl
(Funktion)
(C++11) (C++11) (C++11)
extrahiert den Exponenten der Zahl
(Funktion)
(C++11) (C++11)
zerlegt eine Zahl in Ganzzahl- und Nachkommateil
(Funktion)
C-Dokumentation für frexp