std::modf, std::modff, std::modfl
De cppreference.com
<tbody>
</tbody>
| Definido en el archivo de encabezado <cmath>
|
||
float modf ( float x, float* iptr ); |
(1) | (constexpr since C++23) |
float modff( float x, float* iptr ); |
(2) | (desde C++11) (constexpr since C++23) |
double modf ( double x, double* iptr ); |
(3) | (constexpr since C++23) |
long double modf ( long double x, long double* iptr ); |
(4) | (constexpr since C++23) |
long double modfl( long double x, long double* iptr ); |
(5) | (desde C++11) (constexpr since C++23) |
1-5) Descompone el valor de punto flotante dado
x en sus partes entera y fraccionaria, cada uno con el mismo tipo y signo que x. La parte entera (en formato de punto flotante) se almacena en el objeto al que apunta iptr.Parámetros
| x | - | Valor de punto flotante. |
| iptr | - | Puntero al valor de punto flotante en el que almacenar la parte entera. |
Valor de retorno
Si no se producen errores, se devuelve la parte fraccionaria de x con el mismo signo que x. La parte entera se pone en el valor al que apunta iptr.
La suma del valor devuelto y el valor almacenado en *iptr da x (permitiendo el redondeo).
Manejo de errores
Esta función no está sujeta a ningún error especificado en math_errhandling.
Si la implementación admite la aritmética de punto flotante IEEE (IEC 60559):
- Si
xes +0, se devuelve +0, y se almacena +0 en*iptr. - Si
xes -0, se devuelve -0, y se almacena -0 en*iptr. - Si
xes +∞, se devuelve +∞, y se almacena +∞ en*iptr. - Si
xes -∞, se devuelve -∞, y se almacena -∞ en*iptr. - Si
xes NaN, se devuelve NaN, y NaN se almacena en*iptr. - El valor devuelto es exacto, se ignora el modo de redondeo actual.
Notas
Esta función se comporta como si se implementara de la siguiente manera:
double modf(double x, double* iptr)
{
#pragma STDC FENV_ACCESS ON
int save_round = std::fegetround();
std::fesetround(FE_TOWARDZERO);
*iptr = std::nearbyint(x);
std::fesetround(save_round);
return std::copysign(std::isinf(x) ? 0.0 : x - (*iptr), x);
}
Ejemplo
Compara diferentes funciones de descomposición de punto flotante.
Ejecuta este código
#include <iostream>
#include <cmath>
#include <limits>
int main()
{
double f = 123.45;
std::cout << "Dado el número " << f << " o " << std::hexfloat
<< f << std::defaultfloat << " en hexadecimal,\n";
double f3;
double f2 = std::modf(f, &f3);
std::cout << "modf() genera " << f3 << " + " << f2 << '\n';
int i;
f2 = std::frexp(f, &i);
std::cout << "frexp() genera " << f2 << " * 2^" << i << '\n';
i = std::ilogb(f);
std::cout << "logb()/ilogb() genera " << f/std::scalbn(1.0, i) << " * "
<< std::numeric_limits<double>::radix
<< "^" << std::ilogb(f) << '\n';
// valores especiales
f2 = std::modf(-0.0, &f3);
std::cout << "modf(-0) genera " << f3 << " + " << f2 << '\n';
f2 = std::modf(-INFINITY, &f3);
std::cout << "modf(-Inf) genera " << f3 << " + " << f2 << '\n';
}
Posible salida:
Dado el número 123.45 o 0x1.edccccccccccdp+6 en hexadecimal,
modf() genera 123 + 0.45
frexp() genera 0.964453 * 2^7
logb()/ilogb() genera 1.92891 * 2^6
modf(-0) genera -0 + -0
modf(-Inf) genera -inf + -0
Véase también
(C++11)(C++11)(C++11) |
Entero más cercano no mayor en magnitud que el valor dado (función) |
Documentación de C para modf
| |