NAME

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

SYNOPSIS

#include <math.h>

double exp(x)

double x;

double exp10(x)

double x;

double exp2(x)

double x;

double expm1(x)

double x;

double log(x)

double x;

double log10(x)

double x;

double log1p(x)

double x;

double log2(x)

double x;

double pow(x,y)

double x,y;

DESCRIPTION

Exp returns the exponential function of x.

Exp10 returns the base 10 exponential 10x.

Exp2 returns the base 2 exponential 2x.

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.

Log2 returns the logarithm of x to base 2.

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

ERROR (due to Roundoff etc.)

exp(x), log(x), expm1(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. The error in pow(x,y) is below about 2 ulps when
its

magnitude is moderate, but increases as pow(x,y) approaches
the

over/underflow thresholds until almost as many bits could be
lost

as are occupied by the floating-point format’s
exponent field; that

is 8 bits for VAX D and 11 bits for IEEE 754 Double. No such

drastic loss has been exposed by testing; the worst errors
observed

have been below 20 ulps for VAX D, 300 ulps for IEEE 754
Double.

Moderate values of pow are accurate enough that

pow(integer,integer) is exact until it is bigger than 2**56
on a

VAX, 2**53 for IEEE 754.

DIAGNOSTICS

Exp, exp10, exp2, expm1 and pow return +infinity on an
overflow.

Pow(x,y) returns NaN when x < 0 and y is not an
integer.

NaN is returned by log unless x > 0, by log1p unless x > -1.

NOTES

The functions exp(x)-1 and log(1+x) are called expm1 and
logp1 in

BASIC on the Hewlett-Packard HP-71B and APPLE Macintosh,
EXP1 and

LN1 in Pascal, exp1 and log1 in C on APPLE Macintoshes,
where they

have been provided to make sure financial calculations of

((1+x)**n-1)/x, namely expm1(n*log1p(x))/x, will be accurate
when x

is tiny. They also provide accurate inverse hyperbolic
functions.

Pow(x,0) returns x**0 = 1 for
all x including x = 0, Infinity (not

found on a VAX), and NaN (the reserved operand on a VAX).
Previous

implementations of pow may have defined x**0 to be undefined
in

some or all of these cases. Here are reasons for returning
x**0 =

1 always:

(1) Any program that already
tests whether x is zero (or infinite

or NaN) before computing x**0 cannot care whether 0**0 = 1
or

not. Any program that depends upon 0**0 to be invalid is

dubious anyway since that expression’s meaning and, if
invalid,

its consequences vary from one computer system to
another.

(2) Some Algebra texts (e.g.
Sigler’s) define x**0 = 1 for all x,

including x = 0. This is compatible with the convention that

accepts a[0] as the value of polynomial

p(x) = a[0]*x**0 + a[1]*x**1 + a[2]*x**2 +...+ a[n]*x**n

at x = 0 rather than reject a[0]*0**0 as invalid.

(3) Analysts will accept 0**0 =
1 despite that x**y can approach

anything or nothing as x and y approach 0 independently. The

reason for setting 0**0 = 1 anyway is this:

If x(z) and y(z) are any
functions analytic (expandable in

power series) in z around z = 0, and if there x(0) = y(0) =
0,

then x(z)**y(z) -> 1 as z -> 0.

(4) If 0**0 = 1, then
infinity**0 = 1/0**0 = 1 too; and then NaN**0

= 1 too because x**0 = 1 for all finite and infinite x,
i.e.,

independently of x.

SEE ALSO

libm(3)

AUTHOR

Kwok-Choi Ng, W. Kahan