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

- Function:
*double***exp***(double*¶`x`) - Function:
*float***expf***(float*¶`x`) - Function:
*long double***expl***(long double*¶`x`) - Function:
*_FloatN***expfN***(_Float*¶`N``x`) - Function:
*_FloatNx***expfNx***(_Float*¶`N`x`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`) - Function:
*_FloatN***exp2fN***(_Float*¶`N``x`) - Function:
*_FloatNx***exp2fNx***(_Float*¶`N`x`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:
*_FloatN***exp10fN***(_Float*¶`N``x`) - Function:
*_FloatNx***exp10fNx***(_Float*¶`N`x`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))`

.The

`exp10`

functions are from TS 18661-4:2015.

- Function:
*double***log***(double*¶`x`) - Function:
*float***logf***(float*¶`x`) - Function:
*long double***logl***(long double*¶`x`) - Function:
*_FloatN***logfN***(_Float*¶`N``x`) - Function:
*_FloatNx***logfNx***(_Float*¶`N`x`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`) - Function:
*_FloatN***log10fN***(_Float*¶`N``x`) - Function:
*_FloatNx***log10fNx***(_Float*¶`N`x`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`) - Function:
*_FloatN***log2fN***(_Float*¶`N``x`) - Function:
*_FloatNx***log2fNx***(_Float*¶`N`x`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`) - Function:
*_FloatN***logbfN***(_Float*¶`N``x`) - Function:
*_FloatNx***logbfNx***(_Float*¶`N`x`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`) - Function:
*int***ilogbfN***(_Float*¶`N``x`) - Function:
*int***ilogbfNx***(_Float*¶`N`x`x`) - Function:
*long int***llogb***(double*¶`x`) - Function:
*long int***llogbf***(float*¶`x`) - Function:
*long int***llogbl***(long double*¶`x`) - Function:
*long int***llogbfN***(_Float*¶`N``x`) - Function:
*long int***llogbfNx***(_Float*¶`N`x`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. The`ilogb`

,`ilogbf`

, and`ilogbl`

functions are from ISO C99; the`llogb`

,`llogbf`

,`llogbl`

functions are from TS 18661-1:2014; the`ilogbfN`

,`ilogbfNx`

,`llogbfN`

, and`llogbfNx`

functions are from TS 18661-3:2015.

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:
*long int***FP_LLOGB0**¶ -
`llogb`

returns this value if its argument is`0`

. The numeric value is either`LONG_MIN`

or`-LONG_MAX`

.This macro is defined in TS 18661-1:2014.

- 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.

- Macro:
*long int***FP_LLOGBNAN**¶ -
`llogb`

returns this value if its argument is`NaN`

. The numeric value is either`LONG_MIN`

or`LONG_MAX`

.This macro is defined in TS 18661-1:2014.

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`) - Function:
*_FloatN***powfN***(_Float*¶`N``base`, _Float`N``power`) - Function:
*_FloatNx***powfNx***(_Float*¶`N`x`base`, _Float`N`x`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`) - Function:
*_FloatN***sqrtfN***(_Float*¶`N``x`) - Function:
*_FloatNx***sqrtfNx***(_Float*¶`N`x`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`) - Function:
*_FloatN***cbrtfN***(_Float*¶`N``x`) - Function:
*_FloatNx***cbrtfNx***(_Float*¶`N`x`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`) - Function:
*_FloatN***hypotfN***(_Float*¶`N``x`, _Float`N``y`) - Function:
*_FloatNx***hypotfNx***(_Float*¶`N`x`x`, _Float`N`x`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`) - Function:
*_FloatN***expm1fN***(_Float*¶`N``x`) - Function:
*_FloatNx***expm1fNx***(_Float*¶`N`x`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`) - Function:
*_FloatN***log1pfN***(_Float*¶`N``x`) - Function:
*_FloatNx***log1pfNx***(_Float*¶`N`x`x`) -
Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions return 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`) - Function:
*complex _FloatN***cexpfN***(complex _Float*¶`N``z`) - Function:
*complex _FloatNx***cexpfNx***(complex _Float*¶`N`x`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`) - Function:
*complex _FloatN***clogfN***(complex _Float*¶`N``z`) - Function:
*complex _FloatNx***clogfNx***(complex _Float*¶`N`x`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`) - Function:
*complex _FloatN***clog10fN***(complex _Float*¶`N``z`) - Function:
*complex _FloatNx***clog10fNx***(complex _Float*¶`N`x`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*log10 (z) = log10 (cabs (z)) + I * carg (z) / log (10)*All these functions, including the

`_Float`

and`N``_Float`

variants, are GNU extensions.`N`x

- Function:
*complex double***csqrt***(complex double*¶`z`) - Function:
*complex float***csqrtf***(complex float*¶`z`) - Function:
*complex long double***csqrtl***(complex long double*¶`z`) - Function:
*complex _FloatN***csqrtfN***(_Float*¶`N``z`) - Function:
*complex _FloatNx***csqrtfNx***(complex _Float*¶`N`x`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`) - Function:
*complex _FloatN***cpowfN***(complex _Float*¶`N``base`, complex _Float`N``power`) - Function:
*complex _FloatNx***cpowfNx***(complex _Float*¶`N`x`base`, complex _Float`N`x`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))`