std:: frexp, std:: frexpf, std:: frexpl
|
Definido en el encabezado
<cmath>
|
||
| (1) | ||
|
float
frexp
(
float
num,
int
*
exp
)
;
double
frexp
(
double
num,
int
*
exp
)
;
|
(hasta C++23) | |
|
constexpr
/* floating-point-type */
frexp ( /* floating-point-type */ num, int * exp ) ; |
(desde C++23) | |
|
float
frexpf
(
float
num,
int
*
exp
)
;
|
(2) |
(desde C++11)
(constexpr desde C++23) |
|
long
double
frexpl
(
long
double
num,
int
*
exp
)
;
|
(3) |
(desde C++11)
(constexpr desde C++23) |
|
Sobrecargas adicionales
(desde C++11)
|
||
|
Definido en el encabezado
<cmath>
|
||
|
template
<
class
Integer
>
double frexp ( Integer num, int * exp ) ; |
(A) | (constexpr desde C++23) |
std::frexp
para todos los tipos de punto flotante sin calificadores cv como el tipo del parámetro
num
.
(desde C++23)
|
A)
Se proporcionan sobrecargas adicionales para todos los tipos enteros, los cuales son tratados como
double
.
|
(since C++11) |
Contenidos |
Parámetros
| num | - | valor de punto flotante o entero |
| exp | - | puntero a valor entero para almacenar el exponente |
Valor de retorno
Si num es cero, retorna cero y almacena cero en * exp .
De lo contrario (si
num
no es cero), si no ocurren errores, devuelve el valor
x
en el rango
(-1, -0.5], [0.5, 1)
y almacena un valor entero en
*
exp
tal que
x×2
(*exp)
== num
.
Si el valor a almacenar en * exp está fuera del rango de int , el comportamiento no está especificado.
Manejo de errores
Esta función no está sujeta a ningún error especificado en math_errhandling .
Si la implementación soporta aritmética de punto flotante IEEE (IEC 60559),
- Si num es ±0, se devuelve sin modificar y se almacena 0 en * exp .
- Si num es ±∞, se devuelve y se almacena un valor no especificado en * exp .
- Si num es NaN, se devuelve NaN y se almacena un valor no especificado en * exp .
- No se generan excepciones de punto flotante.
- Si FLT_RADIX es 2 (o una potencia de 2), el valor devuelto es exacto y el modo de redondeo actual se ignora.
Notas
En un sistema binario (donde
FLT_RADIX
es
2
),
std::frexp
puede implementarse como
{ *exp = (value == 0) ? 0 : (int)(1 + std::logb(value)); return std::scalbn(value, -(*exp)); }
La función
std::frexp
, junto con su dual,
std::ldexp
, puede utilizarse para manipular la representación de un número de punto flotante sin manipulaciones directas de bits.
Las sobrecargas adicionales no requieren ser proporcionadas exactamente como (A) . Solo necesitan ser suficientes para garantizar que para su argumento num de tipo entero, std :: frexp ( num, exp ) tenga el mismo efecto que std :: frexp ( static_cast < double > ( num ) , exp ) .
Ejemplo
Compara diferentes funciones de descomposición de números de punto flotante:
#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'; }
Salida posible:
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
Véase también
|
(C++11)
(C++11)
|
multiplica un número por
2
elevado a una potencia entera
(función) |
|
(C++11)
(C++11)
(C++11)
|
extrae el exponente del número
(función) |
|
(C++11)
(C++11)
(C++11)
|
extrae el exponente del número
(función) |
|
(C++11)
(C++11)
|
descompone un número en partes entera y fraccionaria
(función) |
|
Documentación C
para
frexp
|
|