Table of Contents
The function computes the exponential value of the
given argument The function computes the value exp(x)-1 accurately even
for tiny argument The function computes the value of the natural logarithm
of argument The function computes the value of the logarithm of argument
to base 10. The function computes the value of log(1+x) accurately even
for tiny argument The computes the value of to the exponent
exp(x), log(x), expm1(x) and log1p(x) are accurate
to within an and log10(x) to within about 2 an is one in the The
error in is below about 2 when its magnitude is moderate, but increases
as 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 and 11 bits for IEEE 754 Double. No such drastic loss
has been exposed by testing; the worst errors observed have been below
20 for 300 for 754 Double. Moderate values of are accurate enough that
is exact until it is bigger than 2**56 on a 2**53 for 754.
These
functions will return the appropriate computation unless an error occurs
or an argument is out of range. The functions and detect if the computed
value will overflow, set the global variable and cause a reserved operand
fault on a or The function checks to see if < 0 and is not an integer,
in the event this is true, the global variable is set to and on the
and generate a reserved operand fault. On a and is set to and the reserved
operand is returned by log unless > 0, by unless > -1.
The functions
exp(x)-1 and log(1+x) are called expm1 and logp1 in on the Hewlett-Packard
and Macintosh, and in Pascal, exp1 and log1 in C on 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. The function returns x**0 = 1 for
all x including x = 0, 1 for all x including x = 0, Infinity if (not found
on a and (the reserved operand on a have defined x**0 to be undefined
in some or all of these cases. Here are reasons for returning x**0 = 1
always: Any program that already tests whether x is zero (or infinite
or Na) 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. 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. 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 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. If 0**0 = 1, then 1, then infinity**0 = 1/0**0 = 1 too; and
if**0 = 1/0**0 = 1 too; and then Na**0 = 1 too because x**0 = 1 for all
finite and infinite x, i.e., independently of x.
A and
functions appeared in A function appeared in The and functions appeared
in
Table of Contents