

#include <math.h>double frexp(double value, int *eptr);
float frexpf(float value, int *eptr);
long double frexpl(long double value, int *eptr);
int ilogb(double value);
int ilogbf(float value);
int ilogbl(long double value);
double ldexp(double value, int exp);
float ldexpf(float value, int exp);
long double ldexpl(long double value, int exp);
double logb(double value);
float logbf(float value);
long double logbl(long double value);
double nextafter(double value1, double value2);
float nextafterf(float value1, float value2);
long double nextafterl(long double value1, long double value2);
double scalb(double value, double exp);
float scalbf(float value, float exp);
long double scalbl(long double value, long double exp);
double modf(double value, double *iptr);
float modff(float value, float *iptr);
long double modfl(long double value, long double *iptr);
ilogb, ilogbf and ilogbl return the (unbiased) exponent part of value. It is equivalent to (int)logb[fl](value).
ldexp, ldexpf, ldexpl, scalb, scalbf and scalbl return the quantity value*2^exp.
logb returns the unbiased exponent of its floatingpoint argument as a doubleprecision floatingpoint value.
logbf returns the unbiased exponent of its floatingpoint argument as an floatprecision floatingpoint value.
logbl returns the unbiased exponent of its floatingpoint argument as an extended doubleprecision floatingpoint value.
modf, modff and modfl return the signed fractional part of value and store the integral part indirectly in the location pointed to by iptr.
nextafter, nextafterf and nextafterl return the next representable floatingpoint value following value1 in the direction of value2. Thus, if value2 is less than value1, nextafter, nextafterf and nextafterl return the largest representable floatingpoint number less than value1.
If the correct value of ldexp, ldexpf, ldexpl, scalb, scalbf or scalbl would cause overflow, these functions return a value that will compare equal to ±HUGE_VAL (according to the sign of value) and set errno to ERANGE. If the correct value of these functions would cause underflow, zero is returned and errno is set to ERANGE.
logb or logbl of zero returns HUGE_VAL; on systems that support IEEE floatingpoint, the divide by zero exception is raised. On systems that support IEEE floatingpoint, scalb, scalbf, scalbf, logb, logbf or logbl of ± infinity returns + infinity. For both of these error cases, errno is set to EDOM.
On systems that support IEEE floatingpoint, if input value1 to nextafter, nextafterf or nextafterl is ± infinity, that input is returned and errno is set to EDOM. The overflow and inexact exceptions are signaled when input value1 is finite, but
nextafter(value1, value2)
is not. The underflow and inexact exceptions are signaled when the returned value is denormalized. In both cases errno is set to ERANGE. (These last two conditions apply to nextafterl, as well.)
On systems that support IEEE NaN, if the input to any of these functions is a quiet NaN, that NaN is returned. If the input is a signaling NaN, a quiet NaN is returned and the invalid operation exception is raised. In either case, errno is set to EDOM.
When the program is compiled with the cc option Xt [see cc(C)], the returned value of ldexp, ldexpl, scalb, scalbf and scalbl will compare equal to HUGE instead of HUGE_VAL.