# exp(3)

```NAME
exp, expm1, log, log10, log1p, pow - exponential, logarithm, power

SYNOPSIS
#include <math.h>

double exp(double x)
double expm1(double x)
double log(double x)
double log10(double x)
double log1p(double x)
double pow(double x, double y)

DESCRIPTION

Exp returns the exponential function of x.

Expm1 returns exp(x)-1 accurately even for tiny x.

Log returns the natural logarithm of x.

Log10 returns the logarithm of x to base 10.

Log1p returns log(1+x) accurately even for tiny x.

Pow(x,y) returns x**y.

ERROR (due to Roundoff etc.)
exp(x), log(x), expm1(x), log(x) and log1p(x) are accurate to  within  an
ulp,  and log10(x) to within about 2 ulps; an ulp is one Unit in the Last
Place.   Pow(x,y)   returns   x**y   nearly   rounded.    In   particular
pow(integer,integer)  always  returns  the correct integer provided it is
representable.

DIAGNOSTICS
exp(Inf) = Inf, exp(NaN) = NaN.
For a finite argument, only exp(0) = 1 is exact.
Overflow of exp(x) if x > 7.09782712893383973096e+02.
Underflow of exp(x) if x < -7.45133219101941108420e+02.

expm1(Inf) = Inf, expm1(NaN) = NaN, expm1(-Inf) = -1.
For a finite argument, only expm1(0) = 0 is exact.
Overflow of expm1(x) if x > 7.09782712893383973096e+02.

log(x) = NaN with signal if x < 0 (including -Inf).
log(NaN) = that NaN with no signal.
log(+Inf) = +Inf.
log(0) = -Inf with signal.

log10(x) = NaN with signal if x < 0.
log10(NaN) = that NaN with no signal.
log10(+Inf) = +Inf.
log10(0) = -Inf with signal.
log10(10**n) = n for n = 0, 1, ..., 22.

log1p(x) = NaN with signal if x < -1 (including -Inf).
log1p(NaN) = that NaN with no signal.
log1p(+Inf) = +Inf.
log1p(-1) = -Inf with signal.

pow([anything], 0) = 1
pow([anything], 1) = [that anything]
pow([anything], NaN) = NaN
pow(NaN, [anything except 0]) = NaN
pow(+[|x| > 1], +Inf) = +Inf
pow(+[|x| > 1], -Inf) = +0
pow(+[|x| < 1], +Inf) = +0
pow(+[|x| < 1], -Inf) = +Inf
pow(+1 , +Inf) = NaN
pow(+0, [+anything except 0, NaN]) = +0
pow(-0, [+anything except 0, NaN, odd integer]) = +0
pow(+0, [-anything except 0, NaN]) = +Inf
pow(-0, [-anything except 0, NaN, odd integer]) = +Inf
pow(-0, [odd integer]) = -( +0 ** [odd integer] )
pow(+Inf, [+anything except 0, NaN]) = +Inf
pow(+Inf, [-anything except 0, NaN]) = +0
pow(-Inf, [anything]) = -0 ** [-anything])
pow([-anything], [integer]) = (-1)**integer*(+anything**integer)
pow([-anything except 0 and Inf], [non-integer]) = NaN

NOTES
To guarantee log10(10**n) = n, where 10**n is normal, the  rounding  mode
must  set  to  Round-to-Nearest.   Log10 is monotonic on all binary break
points.

math(3).

AUTHOR
Kwok-Choi Ng, W. Kahan

```