Next: Hyperbolic Functions, Previous: Inverse Trig Functions, Up: Mathematics [Contents][Index]

- Function:
*double***exp***(double*`x`) - Function:
*float***expf***(float*`x`) - Function:
*long double***expl***(long double*`x`) Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions compute

`e`

(the base of natural logarithms) raised to the power`x`.If the magnitude of the result is too large to be representable,

`exp`

signals overflow.

- Function:
*double***exp2***(double*`x`) - Function:
*float***exp2f***(float*`x`) - Function:
*long double***exp2l***(long double*`x`) Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions compute

`2`

raised to the power`x`. Mathematically,`exp2 (x)`

is the same as`exp (x * log (2))`

.

- Function:
*double***exp10***(double*`x`) - Function:
*float***exp10f***(float*`x`) - Function:
*long double***exp10l***(long double*`x`) - Function:
*double***pow10***(double*`x`) - Function:
*float***pow10f***(float*`x`) - Function:
*long double***pow10l***(long double*`x`) Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions compute

`10`

raised to the power`x`. Mathematically,`exp10 (x)`

is the same as`exp (x * log (10))`

.These functions are GNU extensions. The name

`exp10`

is preferred, since it is analogous to`exp`

and`exp2`

.

- Function:
*double***log***(double*`x`) - Function:
*float***logf***(float*`x`) - Function:
*long double***logl***(long double*`x`) Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions compute the natural logarithm of

`x`.`exp (log (`

equals`x`))`x`, exactly in mathematics and approximately in C.If

`x`is negative,`log`

signals a domain error. If`x`is zero, it returns negative infinity; if`x`is too close to zero, it may signal overflow.

- Function:
*double***log10***(double*`x`) - Function:
*float***log10f***(float*`x`) - Function:
*long double***log10l***(long double*`x`) Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions return the base-10 logarithm of

`x`.`log10 (`

equals`x`)`log (`

.`x`) / log (10)

- Function:
*double***log2***(double*`x`) - Function:
*float***log2f***(float*`x`) - Function:
*long double***log2l***(long double*`x`) Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions return the base-2 logarithm of

`x`.`log2 (`

equals`x`)`log (`

.`x`) / log (2)

- Function:
*double***logb***(double*`x`) - Function:
*float***logbf***(float*`x`) - Function:
*long double***logbl***(long double*`x`) Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions extract the exponent of

`x`and return it as a floating-point value. If`FLT_RADIX`

is two,`logb`

is equal to`floor (log2 (x))`

, except it’s probably faster.If

`x`is de-normalized,`logb`

returns the exponent`x`would have if it were normalized. If`x`is infinity (positive or negative),`logb`

returns*∞*. If`x`is zero,`logb`

returns*∞*. It does not signal.

- Function:
*int***ilogb***(double*`x`) - Function:
*int***ilogbf***(float*`x`) - Function:
*int***ilogbl***(long double*`x`) Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions are equivalent to the corresponding

`logb`

functions except that they return signed integer values.

Since integers cannot represent infinity and NaN, `ilogb`

instead
returns an integer that can’t be the exponent of a normal floating-point
number. `math.h` defines constants so you can check for this.

- Macro:
*int***FP_ILOGB0** `ilogb`

returns this value if its argument is`0`

. The numeric value is either`INT_MIN`

or`-INT_MAX`

.This macro is defined in ISO C99.

- Macro:
*int***FP_ILOGBNAN** `ilogb`

returns this value if its argument is`NaN`

. The numeric value is either`INT_MIN`

or`INT_MAX`

.This macro is defined in ISO C99.

These values are system specific. They might even be the same. The
proper way to test the result of `ilogb`

is as follows:

i = ilogb (f); if (i == FP_ILOGB0 || i == FP_ILOGBNAN) { if (isnan (f)) { /* Handle NaN. */ } else if (f == 0.0) { /* Handle 0.0. */ } else { /* Some other value with large exponent, perhaps +Inf. */ } }

- Function:
*double***pow***(double*`base`, double`power`) - Function:
*float***powf***(float*`base`, float`power`) - Function:
*long double***powl***(long double*`base`, long double`power`) Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These are general exponentiation functions, returning

`base`raised to`power`.Mathematically,

`pow`

would return a complex number when`base`is negative and`power`is not an integral value.`pow`

can’t do that, so instead it signals a domain error.`pow`

may also underflow or overflow the destination type.

- Function:
*double***sqrt***(double*`x`) - Function:
*float***sqrtf***(float*`x`) - Function:
*long double***sqrtl***(long double*`x`) Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions return the nonnegative square root of

`x`.If

`x`is negative,`sqrt`

signals a domain error. Mathematically, it should return a complex number.

- Function:
*double***cbrt***(double*`x`) - Function:
*float***cbrtf***(float*`x`) - Function:
*long double***cbrtl***(long double*`x`) Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions return the cube root of

`x`. They cannot fail; every representable real value has a representable real cube root.

- Function:
*double***hypot***(double*`x`, double`y`) - Function:
*float***hypotf***(float*`x`, float`y`) - Function:
*long double***hypotl***(long double*`x`, long double`y`) Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions return

`sqrt (`

. This is the length of the hypotenuse of a right triangle with sides of length`x`*`x`+`y`*`y`)`x`and`y`, or the distance of the point (`x`,`y`) from the origin. Using this function instead of the direct formula is wise, since the error is much smaller. See also the function`cabs`

in Absolute Value.

- Function:
*double***expm1***(double*`x`) - Function:
*float***expm1f***(float*`x`) - Function:
*long double***expm1l***(long double*`x`) Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions return a value equivalent to

`exp (`

. They are computed in a way that is accurate even if`x`) - 1`x`is near zero—a case where`exp (`

would be inaccurate owing to subtraction of two numbers that are nearly equal.`x`) - 1

- Function:
*double***log1p***(double*`x`) - Function:
*float***log1pf***(float*`x`) - Function:
*long double***log1pl***(long double*`x`) Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions returns a value equivalent to

`log (1 +`

. They are computed in a way that is accurate even if`x`)`x`is near zero.

ISO C99 defines complex variants of some of the exponentiation and logarithm functions.

- Function:
*complex double***cexp***(complex double*`z`) - Function:
*complex float***cexpf***(complex float*`z`) - Function:
*complex long double***cexpl***(complex long double*`z`) Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions return

`e`

(the base of natural logarithms) raised to the power of`z`. Mathematically, this corresponds to the value*exp (z) = exp (creal (z)) * (cos (cimag (z)) + I * sin (cimag (z)))*

- Function:
*complex double***clog***(complex double*`z`) - Function:
*complex float***clogf***(complex float*`z`) - Function:
*complex long double***clogl***(complex long double*`z`) Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions return the natural logarithm of

`z`. Mathematically, this corresponds to the value*log (z) = log (cabs (z)) + I * carg (z)*`clog`

has a pole at 0, and will signal overflow if`z`equals or is very close to 0. It is well-defined for all other values of`z`.

- Function:
*complex double***clog10***(complex double*`z`) - Function:
*complex float***clog10f***(complex float*`z`) - Function:
*complex long double***clog10l***(complex long double*`z`) Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions return the base 10 logarithm of the complex value

`z`. Mathematically, this corresponds to the value*log (z) = log10 (cabs (z)) + I * carg (z)*These functions are GNU extensions.

- Function:
*complex double***csqrt***(complex double*`z`) - Function:
*complex float***csqrtf***(complex float*`z`) - Function:
*complex long double***csqrtl***(complex long double*`z`) Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions return the complex square root of the argument

`z`. Unlike the real-valued functions, they are defined for all values of`z`.

- Function:
*complex double***cpow***(complex double*`base`, complex double`power`) - Function:
*complex float***cpowf***(complex float*`base`, complex float`power`) - Function:
*complex long double***cpowl***(complex long double*`base`, complex long double`power`) Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions return

`base`raised to the power of`power`. This is equivalent to`cexp (y * clog (x))`

Next: Hyperbolic Functions, Previous: Inverse Trig Functions, Up: Mathematics [Contents][Index]