exp(3M)

NAME
     exp, expm1, log, log10, log1p, pow, fexp, expf, fexpm1, expm1f, flog,
     logf, flog10, log10f, flog1p, log1pf, fpow, powf, expl, expm1l, logl,
     log10l, log1pl, powl - exponential, logarithm, power

SYNOPSIS
     #include <math.h>

     double exp(double x);
     float fexp(float x);
     float expf(float x);
     long double expl(long double x);
     long double expm1l(long double x);

     double expm1(double x);
     float fexpm1(float x);
     float expm1f(float x);

     double log(double x);
     float flog(float x);
     float logf(float x);
     long double logl(long double x);

     double log10(double x);
     float flog10(float x);
     float log10f(float x);
     long double log10l(long double x);

     double log1p(double x);
     float flog1p(float x);
     float log1pf(float x);
     long double log1pl(long double x);

     double pow(double x, double y);
     float powf(float x, float y);
     long double powl(long double x, long double y);

IMPLEMENTATION
     IRIX systems

DESCRIPTION
     The long double and single-precision routines listed above are only
     available in the standard math library libm.a, and in libmx.a.

     The exp family return the exponential function of x, e**x.

     The expm1 family return exp(x)-1 accurately even for tiny x.

     The log functions return the natural logarithm of x.

     The log10 functions return the base 10 logarithm of x.

     The log1p family return log(1+x) accurately even for tiny x.

     pow(x,y), its single-precision counterpart powf(x,y), and its long
     double counterpart powl(x,y), return x**y.

NOTES
     Long double operations on this system are only supported in round to
     nearest rounding mode (the default).  The system must be in round to
     nearest rounding mode when calling any of the long double functions,
     or incorrect answers will result.

     Users concerned with portability to other computer systems should note
     that the long double and float versions of these functions are
     optional according to the ANSI C Programming Language Specification
     ISO/IEC 9899 : 1990 (E).

     Long double functions have been renamed to be compliant with the
     ANSI-C standard, however to be backward compatible, they may still be
     called with the double precision function name prefixed with a q.

     pow(x,0) returns x**0 = 1 for all x including x = 0 and Infinity.
     Previous implementations of pow defined Nan**0 to be 1 as well, but
     this behavior has been changed to conform to the IEEE standard.  x**0
     = 1 is returned in all other cases for the following reasons:

     1. Any program that already tests if x is zero (or infinite) before
        computing x**0 cannot care if 0**0 = 1 or not. Any program that
        depends upon 0**0 to be invalid is dubious anyway because that
        expression's meaning and (if invalid) its consequences vary from
        one computer system to another.

     3. 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 the following 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.

     1. 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 is because 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.

     2. If 0**0 = 1, then infinity**0 = 1/0**0 = 1 too; and because x**0 =
        1 for all finite and infinite non-NaN x.

   Errors
     exp(x), log(x), expm1(x) and log1p(x) are accurate to within a ULP,
     and log10(x) and pow(x,y) to within about 2 ULPs; a ULP one Unit in
     the Last Place.  Moderate values of pow are accurate enough that
     pow(integer,integer) is exact until it is bigger than 2**53 for
     double.

RETURN VALUES
     Functions in the standard math library, libm.a, are referred to as -lm
     versions. Those in math library libmx.a are referred to as -lmx
     versions. Those in the the BSD math library, libm43.a, are referred to
     as -lm43 versions.

     When NaN is used as an argument, a NaN is returned.  The -lm and -lmx
     versions always return the default Quiet NaN and set errno to EDOM.
     The -lm43 versions never set errno.

     The value of HUGE_VAL is IEEE Infinity.

     The exp functions return HUGE_VAL when the correct value would
     overflow, and return zero if the correct value would underflow. The
     -lm and -lmx versions set the value of errno to ERANGE for both
     underflow and overflow.

     The log functions return NaN when x is less than zero, indicating an
     invalid operation. The -lm and -lmx versions also set errno to EDOM.
     When x is zero, the log functions return -HUGE_VAL.  The -lm and -lmx
     versions set errno to ERANGE.

     The pow functions return NaN indicating an invalid operation, if x is
     negative and y is not an integer. The -lm and -lmx versions also set
     errno to EDOM.

     When x is zero and y is negative, the -lm and -lmx versions return
     HUGE_VAL and set errno to EDOM.  The -lm43 versions return HUGE_VAL.

     When both arguments are zero, the pow functions return one.

     When the correct value for pow would overflow or underflow, the pow
     functions return +/-HUGE_VAL or zero, respectively.  The -lm and -lmx
     versions set errno to ERANGE.

     See matherr(3M) for a description of error handling for -lmx
     functions.

SEE ALSO
     math(3M), matherr(3M)

     This man page is available only online.