double
exp(double x)
float
expf(float x)
double
expm1(double x)
float
expm1f(float x)
double
log(double x)
float
logf(float x)
double
log2(double x)
float
log2f(float x)
double
log10(double x)
float
log10f(float x)
double
log1p(double x)
float
log1pf(float x)
double
pow(double x, double y)
float
powf(float x, float y)
)
function computes the exponential value of the given argument
x.
The
expm1()
function computes the value exp(x)-1 accurately even for tiny argument
x.
The
log()
function computes the value of the natural logarithm of argument
x.
The
log10()
function computes the value of the logarithm of argument
x
to base 10.
The
log1p()
function computes
the value of log(1+x) accurately even for tiny argument
x.
The
log2()
and the
log2f()
functions compute the value of the logarithm of argument
x
to base 2.
The
pow()
computes the value
of
x
to the exponent
y.
),
expm1()
and
pow()
detect if the computed value will overflow,
set the global variable
errno
to
ERANGE
and cause a reserved operand fault on a
VAX.
The function
pow(x, y)
checks to see if
x
< 0 and
y
is not an integer, in the event this is true,
the global variable
errno
is set to
EDOM
and on the
VAX
generate a reserved operand fault.
On a
VAX,
errno
is set to
EDOM
and the reserved operand is returned
by log unless
x
> 0, by
log1p()
unless
x
> -1.
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.
The function
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:
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.
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) gt; 1 as z gt; 0.
),
log(),
log10()
and
pow()
functions conform to
ANSI X3.159-1989 (``ANSI C89'') .
),
log()
and
pow()
functions
appeared in
Version 6 AT&T UNIX.
A
log10()
function
appeared in
Version 7 AT&T UNIX.
The
log1p()
and
expm1()
functions appeared in
4.3BSD.