NAME    [Toc]    [Back]

       exp,  expm1,  log,  log2, log10, log1p, pow - Exponential,
       logarithm, and power functions

SYNOPSIS    [Toc]    [Back]

       #include <math.h>

       double exp(
               double x ); float expf(
               float x ); long double expl(
               long double x ); double expm1(
               double x ); float expm1f(
               float x ); long double expm1l(
               long double x ); double log(
               double x ); float logf(
               float x ); long double logl(
               long double x ); double log2(
               double x ); float log2f(
               float x ); long double log2l(
               long double x ); double log10(
               double x ); float log10f(
               float x ); long double log10l(
               long double x ); double log1p(
               double y ); float log1pf(
               float y ); long double log1pl(
               long double y ); double pow(
               double x,
               double y ); float powf(
               float x,
               float y ); long double powl(
               long double x,
               long double y );

LIBRARY    [Toc]    [Back]

       Math Library (libm)

STANDARDS    [Toc]    [Back]

       Interfaces documented on this reference  page  conform  to
       industry standards as follows:

       exp():  XPG4

       expm1():  XPG4-UNIX

       log():  XPG4

       log10():  XPG4

       log1p():  XPG4-UNIX

       pow():  XPG4

       Refer to the standards(5) reference page for more information
 about industry standards and associated tags.

DESCRIPTION    [Toc]    [Back]

       The exp(), expf(), and expl() functions compute the  value
       of  the  exponential function, defined as e**x, where e is
       the constant used as a base for natural logarithms.

       The expm1(),  expm1f(),  and  expm1l()  functions  compute
       exp(x) - 1 accurately, even for tiny x.

       The  log(), logf(), and logl() functions compute the natural
 (base e) logarithm of x.

       The log2(), log2f(), and  log2l()  functions  compute  the
       base 2 logarithm of x.

       The  log10(), log10f(), and log10l() functions compute the
       common (base 10) logarithm of x.

       The log1p(),  log1pf(),  and  log1pl()  functions  compute
       log(1+y) accurately, even for tiny y.

       The  pow(), powf(), and powl() functions raise a floatingpoint
 base x to a floating-point exponent y. The value  of
       pow(x,y)  is  computed as e**(yln(x)) for positive x. If x
       is 0 or negative, see your language reference manual.

       Passing a NaN input value to pow() produces a  NaN  result
       for  y  not  equal to 0. For pow(NaN,0), see your language
       reference manual.

       The  following  table  describes  function   behavior   in
       response to exceptional arguments:

       ----------------------------------------------------------------------------
       Function                        Exceptional Argument        Routine  Behavior

       ----------------------------------------------------------------------------
       exp(), expf(), expl()           x > ln(max_float)           Overflow
       exp(), expf(), expl()           x < ln(min_float)           Underflow
       expm1(), expm1f(), expm1l ()    x > ln(max_float)           Overflow
       expm1(), expm1f(), expm1l ()    x < ln(min_float)           Underflow
       log(), logf(), logl()           x < 0                       Invalid   argument

       log(), logf(), logl()           x = 0                       Overflow
       log2(), log2f(), log2l ()       x < 0                       Invalid   argument

       log2(), logf2(), log2l ()       x = 0                       Overflow
       log10(), log10f(), log10l ()    x < 0                       Invalid   argument

       log10(), log10f(), log10l ()    x = 0                       Overflow
       log1p(), log1pf(), log1pl ()    1+y < 0                     Invalid   argument

       log1p(), log1pf(), log1pl ()    1+y = 0                     Overflow
       pow(), powf(), powl()           y ln(x) > ln(max_float)     Overflow
       pow(), powf(), powl()           y ln(x) < ln(min_float)     Underflow
       ----------------------------------------------------------------------------

       The following table lists boundary values  used  by  these
       functions:







       -------------------------------------------------------------------
       Value Name      Data Type   Hexadecimal Value   Decimal Value
       -------------------------------------------------------------------
       ln(max_float)   S_FLOAT     42B17218            88.7228391
                       T_FLOAT     40862E42FEFA39EF    709.7827128933840
       ln(min_float)   S_FLOAT     C2CE8ED0            -103.2789
                       T_FLOAT     C0874385446D71C3    -744.4400719213813
       -------------------------------------------------------------------




                                                           exp(3)