Go to the previous, next section.

The functions described in this section are primarily provided as a way to efficiently perform certain low-level manipulations on floating point numbers that are represented internally using a binary radix; see section Floating Point Representation Concepts. These functions are required to have equivalent behavior even if the representation does not use a radix of 2, but of course they are unlikely to be particularly efficient in those cases.

All these functions are declared in ``math.h'`.

__Function:__ double **frexp** *(double value, int *exponent)*

The `frexp`

function is used to split the number `value`
into a normalized fraction and an exponent.

If the argument `value` is not zero, the return value is `value`
times a power of two, and is always in the range 1/2 (inclusive) to 1
(exclusive). The corresponding exponent is stored in
`*`

; the return value multiplied by 2 raised to this
exponent equals the original number `exponent``value`.

For example, `frexp (12.8, &exponent)`

returns `0.8`

and
stores `4`

in `exponent`

.

If `value` is zero, then the return value is zero and
zero is stored in `*`

.
`exponent`

__Function:__ double **ldexp** *(double value, int exponent)*

This function returns the result of multiplying the floating-point
number `value` by 2 raised to the power `exponent`. (It can
be used to reassemble floating-point numbers that were taken apart
by `frexp`

.)

For example, `ldexp (0.8, 4)`

returns `12.8`

.

The following functions which come from BSD provide facilities
equivalent to those of `ldexp`

and `frexp`

:

__Function:__ double **scalb** *(double value, int exponent)*

The `scalb`

function is the BSD name for `ldexp`

.

__Function:__ double **logb** *(double x)*

This BSD function returns the integer part of the base-2 logarithm of
`x`, an integer value represented in type `double`

. This is
the highest integer power of `2`

contained in `x`. The sign of
`x` is ignored. For example, `logb (3.5)`

is `1.0`

and
`logb (4.0)`

is `2.0`

.

When `2`

raised to this power is divided into `x`, it gives a
quotient between `1`

(inclusive) and `2`

(exclusive).

If `x` is zero, the value is minus infinity (if the machine supports
such a value), or else a very small number. If `x` is infinity, the
value is infinity.

The value returned by `logb`

is one less than the value that
`frexp`

would store into `*`

.
`exponent`

__Function:__ double **copysign** *(double value, double sign)*

The `copysign`

function returns a value whose absolute value is the
same as that of `value`, and whose sign matches that of `sign`.
This is a BSD function.

Go to the previous, next section.