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.