EXP(3M-SysV)        RISC/os Reference Manual         EXP(3M-SysV)



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

SYNOPSIS
     #include <math.h>

     double exp(x)
     double x;

     float fexp(float x)
     float x;

     double expm1(x)
     double x;

     float fexpm1(float x)
     float x;

     double log(x)
     double x;

     float flog(float x)
     float x;

     double log10(x)
     double x;

     float flog10(float x)
     float x;

     double log1p(x)
     double x;

     float flog1p(float x)
     float x;

     double pow(x,y)
     double x,y;

DESCRIPTION
     exp and fexp return the exponential function of x for double
     and float data types respectively.

     expm1 and fexpm1 return exp(x)-1 accurately even for tiny x
     for double and float data types respectively.

     log and flog return the natural logarithm of x for double
     and float data types respectively.

     log10 and flog10 return the logarithm of x to base 10 for
     double and float data types respectively.



                         Printed 1/15/91                   Page 1

EXP(3M-SysV)        RISC/os Reference Manual         EXP(3M-SysV)



     log1p and log1p return log(1+x) accurately even for tiny x
     for double and float data types respectively.

     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; 11 bits for IEEE 754 Double.  No such drastic loss
     has been exposed by testing; the worst errors observed have
     been below 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**53 for IEEE 754 Double.

DIAGNOSTICS
     exp returns Infinity when the correct value would overflow,
     or the smallest non-zero value when the correct value would
     underflow.

     log and log10 return the default quiet NaN when x is less
     than zero indicating the invalid operation.  log and log10
     return -Infinity when x is zero.

     pow returns Infinity when x is 0 and y is non-positive.  pow
     returns NaN when x is negative and y is not an integer indi-
     cating the invalid operation.  When the correct value for
     pow would overflow or underflow, pow returns +Infinity or 0
     respectively.

NOTES
     pow(x,0) returns x**0 = 1 for all x including x = 0, Infin-
     ity, and NaN.  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




 Page 2                  Printed 1/15/91

EXP(3M-SysV)        RISC/os Reference Manual         EXP(3M-SysV)



         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
     math(3M)

AUTHOR
     Kwok-Choi Ng, W. Kahan



































                         Printed 1/15/91                   Page 3