- 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 (x)`

is similar to`floor (log2 (fabs (x)))`

, except that the latter may give an incorrect integer due to intermediate rounding.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 real cube root, and rounding it to a representable value never causes overflow nor underflow.

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

- Function:
`double`

**log2p1**`(double`

¶`x`) - Function:
`float`

**log2p1f**`(float`

¶`x`) - Function:
`long double`

**log2p1l**`(long double`

¶`x`) - Function:
`_FloatN`

**log2p1fN**`(_Float`

¶`N``x`) - Function:
`_FloatNx`

**log2p1fNx**`(_Float`

¶`N`x`x`) -
Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions return a value equivalent to

`log2 (1 +`

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

`log2p1`

functions are from TS 18661-4:2015.

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))`