
EXP(3)                     UNIX Programmer's Manual                     EXP(3)

NNAAMMEE
     eexxpp, eexxppmm11, lloogg, lloogg1100, lloogg11pp, ppooww - exponential, logarithm, power func-
     tions

SSYYNNOOPPSSIISS
     ##iinncclluuddee <<mmaatthh..hh>>

     _d_o_u_b_l_e
     eexxpp(_d_o_u_b_l_e _x)

     _d_o_u_b_l_e
     eexxppmm11(_d_o_u_b_l_e _x)

     _d_o_u_b_l_e
     lloogg(_d_o_u_b_l_e _x)

     _d_o_u_b_l_e
     lloogg1100(_d_o_u_b_l_e _x)

     _d_o_u_b_l_e
     lloogg11pp(_d_o_u_b_l_e _x)

     _d_o_u_b_l_e
     ppooww(_d_o_u_b_l_e _x, _d_o_u_b_l_e _y)

DDEESSCCRRIIPPTTIIOONN
     The eexxpp() function computes the exponential value of the given argument
     _x.

     The eexxppmm11() function computes the value exp(x)-1 accurately even for tiny
     argument _x.

     The lloogg() function computes the value for the natural logarithm of the
     argument x.

     The lloogg1100() function computes the value for the logarithm of argument _x
     to base 10.

     The lloogg11pp() function computes the value of log(1+x) accurately even for
     tiny argument _x.

     The ppooww() computes the value of _x to the exponent _y.

EERRRROORR ((dduuee ttoo RRoouunnddooffff eettcc..))
     exp(x), log(x), expm1(x) and log1p(x) are accurate to within an _u_p, and
     log10(x) to within about 2 _u_p_s; an _u_p is one _U_n_i_t in the _L_a_s_t _P_l_a_c_e. The
     error in ppooww(_x, _y) is below about 2 _u_p_s when its magnitude is moderate,
     but increases as ppooww(_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 _u_p_s for VAX D, 300 _u_p_s for IEEE 754
     Double.  Moderate values of ppooww() are accurate enough that ppooww(_i_n_t_e_g_e_r,
     _i_n_t_e_g_e_r) is exact until it is bigger than 2**56 on a VAX, 2**53 for IEEE
     754.

RREETTUURRNN VVAALLUUEESS
     These functions will return the approprate computation unless an error
     occurs or an argument is out of range.  The functions eexxpp(), eexxppmm11() and
     ppooww() detect if the computed value will overflow, set the global variable
     _e_r_r_n_o _t_o RANGE and cause a reserved operand fault on a VAX or Tahoe. The
     function ppooww(_x, _y) checks to see if _x < 0 and _y is not an integer, in the
     event this is true, the global variable _e_r_r_n_o is set to EDOM and on the
     VAX and Tahoe generate a reserved operand fault.  On a VAX and Tahoe,
     _e_r_r_n_o is set to EDOM and the reserved operand is returned by log unless _x
     > 0, by lloogg11pp() unless _x > -1.

NNOOTTEESS
     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 Pas-
     cal, exp1 and log1 in C on APPLE Macintoshes, where they have been pro-
     vided 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 ppooww(_x, _0) returns x**0 = 1 for all x including x = 0, Infin-
     ity (not found on a VAX), and _N_a_N (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 al-
     ways:

     1.      Any program that already tests whether x is zero (or infinite or
             _N_a_N) before computing x**0 cannot care whether 0**0 = 1 or not.
             Any program that depends upon 0**0 to be invalid is dubious any-
             way since that expression's meaning and, if invalid, its conse-
             quences vary from one computer system to another.

     2.      Some Algebra texts (e.g. Sigler's) define x**0 = 1 for all x, in-
             cluding x = 0.  This is compatible with the convention that ac-
             cepts 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 any-
             thing 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 _a_n_y 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 _N_a_N**0 =
             1 too because x**0 = 1 for all finite and infinite x, i.e., inde-
             pendently of x.

SSEEEE AALLSSOO
     math(3),  infnan(3)

HHIISSTTOORRYY
     A eexxpp(), lloogg() and ppooww() function appeared in Version 6 AT&T UNIX.  A
     lloogg1100() function appeared in Version 7 AT&T UNIX.  The lloogg11pp() and
     eexxppmm11() functions appeared in 4.3BSD.

4th Berkeley Distribution        July 31, 1991                               2













