osf1 man page for logb

frexp(3)						     Library Functions Manual							  frexp(3)

NAME
       frexp, ldexp, logb, scalb - Manipulate floating-point numbers

LIBRARY
       Math Library (libm.a)

SYNOPSIS
       #include <math.h>

       double  frexp   (double x, int *n); float  frexpf (float  x, int *n); long double frexpl  (long double x, int *n); double ldexp	(double y,
       int n); float  ldexpf (float  y, int n); long double ldexpl  (long double y, int n); double logb   (double x); float   logbf   (float   x);
       long double logbl   (long double x); double scalb  (double x, double n); float  scalbf (float  x, float	n); long double scalbl	(long dou-
       ble x, long double n);

STANDARDS
       Interfaces documented on this reference page conform to industry standards as follows:

       frexp():  XPG4

       ldexp():  XPG4

       logb():	XPG4-UNIX

       scalb():  XPG4-UNIX

       Refer to the standards(5) reference page for more information about industry standards and associated tags.

DESCRIPTION
       Every nonzero number can be written uniquely as the normalized mantissa (fraction) z times 2 raised to the  power  p,  where  the  absolute
       value of z is in the range [0.5, 1.0), and the exponent p, is an integer.

       The  frexp(),  frexpf(),  and  frexpl()	functions break a floating-point number into a normalized fraction and an integral power of 2. The
       functions store the integer in the int object pointed to by the n parameter and return the fraction part.

       The ldexp(), ldexpf(), and ldexpl() functions multiply a floating-point number, y, by an integral power of 2.

       The logb(), logbf(), and logbl() functions return a signed integer converted to double-precision floating-point and so  chosen  that  1	<=
       |x|/2**n < 2 unless x = 0 or |x| = infinity or x lies between 0 and the Underflow Threshold.

       IEEE 754 defines logb(+infinity) = +infinity and logb(0) = -infinity.  The latter is required to signal Division-by-Zero.

       The scalb(), scalbf(), and scalbl() functions are defined as x*(2**n) for integer n.

       The following table describes function behavior in response to exceptional arguments:

       ----------------------------------------------------------------------
       Function 		     Exceptional Argument   Routine Behavior
       ----------------------------------------------------------------------
       frexp(), frexpf(), frexpl()   |x| = infinity	    Invalid argument
       logb(), logbf(), logbl()      |x| = infinity	    Invalid argument
       scalb(), scalbf(), scalbl()   x*(2**n) > max_float   Overflow
       scalb(), scalbf(), scalbl()   x*(2**n) < min_float   Underflow
       ldexp(), ldexpf(), ldexpl()   x*(2**n) > max_float   Overflow
       ldexp(), ldexpf(), ldexpl()   x*(2**n) < min_float   Underflow
       ----------------------------------------------------------------------

       The following table lists boundary values used by these functions:

       --------------------------------------------------------------------
       Value Name   Data Type	Hexadecimal Value   Decimal Value

       --------------------------------------------------------------------
       max_float    S_FLOAT	7F7FFFFF	    3.402823e38
		    T_FLOAT	7FEFFFFFFFFFFFFF    1.797693134862316e308
       min_float    S_FLOAT	00000001	    1.4012985e-45
		    T_FLOAT	0000000000000001    4.940656458412465e-324
       --------------------------------------------------------------------
       delim off

																	  frexp(3)