1  CPML
   The Compaq Portable Mathematics Library (CPML) is a set of
   mathematical routines that are accessed from high-level languages
   (such as Fortran and C) which support mathematical functions.
   Many CPML routines can also be called directly using standard
   call interfaces, but it is recommended that you invoke CPML
   routines only from a high-level language.

   CPML routines are documented with generic names, and with the
   symbol F_TYPE to indicate generic floating-point values (e.g. F_
   TYPE sqrt (F_TYPE x)).

   To determine the appropriate names and interfaces within a
   specific programming language (e.g. float sqrtf(float x) or
   REAL*4 SQRT), refer to that language's documentation.

   To enable the use of CPML routines which are not provided by your
   high-level language, the actual CPML entrynames for OpenVMS are
   provided.

   Note: CPML routines which return complex numbers ("F_COMPLEX")
   use a private interface. Therefore, they can only be called from
   high-level languages that support that interface.

   The Data Types S_FLOAT, T_FLOAT and X_FLOAT refer to IEEE format
   floating-point numbers of single-, double-, and quad-precision,
   respectively. F_FLOAT and G_FLOAT refer to VAX format single-
   precision, and G-floating double-precision floating point
   numbers, respectively.

   For each CPML routine, "exceptional" input values are
   also provided. That is, values for which the function is
   mathematically undefined, or for which the output would be out
   of range for the floating-point type.

   Refer to your language's documentation for information about
   how exceptions manifest themselves and how to control exception
   behavior. Further information is also available at the Compaq
   Math website at: http://www.compaq.com/math.
 

2  acos()

   Interface

     F_TYPE acos (F_TYPE x)

     F_TYPE acosd (F_TYPE x)
 

3  Description
   acos() computes the principal value of the arc cosine of x in the
   interval [0,pi] radians for x in the interval [-1,1].

   acosd() computes the principal value of the arc cosine of x in
   the interval [0,180] degrees for x in the interval [-1,1].


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   acos       S_FLOAT     math$acos_s    acosf
              T_FLOAT     math$acos_t    acos
              X_FLOAT     math$acos_x    acosl
              F_FLOAT     math$acos_f
              G_FLOAT     math$acos_g

   acosd      S_FLOAT     math$acosd_s   acosdf
              T_FLOAT     math$acosd_t   acosd
              X_FLOAT     math$acosd_x   acosdl
              F_FLOAT     math$acosd_f
              G_FLOAT     math$acosd_g
 

3  Exceptions

   Exceptional Argument   Routine Behavior

   |x|>1                  Invalid argument
 

2  acosh()

   Interface

     F_TYPE acosh (F_TYPE x)
 

3  Description
   acosh() returns the hyperbolic arc cosine of x for x in the
   interval [1,+infinity]. acosh(x) = ln(x + sqrt(x**2 - 1)).

   acosh() is the inverse function of cosh().  The definition of the
   acosh() function is acosh(cosh (x)) = x.


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   acosh      S_FLOAT     math$acosh_s   acoshf
              T_FLOAT     math$acosh_t   acosh
              X_FLOAT     math$acosh_x   acoshl
              F_FLOAT     math$acosh_f
              G_FLOAT     math$acosh_g
 

3  Exceptions

   Exceptional Argument   Routine Behavior

   x<1                    Invalid argument
 

2  asin()

   Interface

     F_TYPE asin (F_TYPE x)

     F_TYPE asind (F_TYPE x)
 

3  Description
   asin() computes the principal value of the arc sine of x in the
   interval [-pi/2,pi/2] radians for x in the interval [-1,1].

   asind() computes the principal value of the arc sine of x in the
   interval [-90,90] degrees for x in the interval [-1,1].


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   asin       S_FLOAT     math$asin_s    asinf
              T_FLOAT     math$asin_t    asin
              X_FLOAT     math$asin_x    asinl
              F_FLOAT     math$asin_f
              G_FLOAT     math$asin_g

   asind      S_FLOAT     math$asind_s   asindf
              T_FLOAT     math$asind_t   asind
              X_FLOAT     math$asind_x   asindl
              F_FLOAT     math$asind_f
              G_FLOAT     math$asind_g
 

3  Exceptions

   Exceptional Argument   Routine Behavior

   |x|>1                  Invalid argument
 

2  asinh()

   Interface

     F_TYPE asinh (F_TYPE x)
 

3  Description
   asinh()
   returns the hyperbolic arc sine of x for x in the interval
   [-infinity, +infinity]. asinh(x) = ln(x + sqrt(x**2 + 1)).

   asinh() is the inverse function of sinh().  asinh(sinh (x)) = x.


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   asinh      S_FLOAT     math$asinh_s   asinhf
              T_FLOAT     math$asinh_t   asinh
              X_FLOAT     math$asinh_x   asinhl
              F_FLOAT     math$asinh_f
              G_FLOAT     math$asinh_g
 

3  Exceptions
   None.
 

2  atan()

   Interface

     F_TYPE atan (F_TYPE x)

     F_TYPE atand (F_TYPE x)
 

3  Description
   atan() computes the principal value of the arc tangent of x
   in the interval [-pi/2,pi/2] radians for x in the interval [-
   infinity, +infinity].

   atand() computes the principal value of the arc tangent of x in
   the interval [-90,90] degrees for x in the interval [-infinity,
   +infinity].


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   atan       S_FLOAT     math$atan_s    atanf
              T_FLOAT     math$atan_t    atan
              X_FLOAT     math$atan_x    atanl
              F_FLOAT     math$atan_f
              G_FLOAT     math$atan_g

   atand      S_FLOAT     math$atand_s   atandf
              T_FLOAT     math$atand_t   atand
              X_FLOAT     math$atand_x   atandl
              F_FLOAT     math$atand_f
              G_FLOAT     math$atand_g
 

3  Exceptions
   None.
 

2  atan2()

   Interface

     F_TYPE atan2 (F_TYPE y, F_TYPE x)

     F_TYPE atand2 (F_TYPE y, F_TYPE x)
 

3  Description
   atan2() computes the angle in the interval [-pi,pi] whose
   arc tangent is y/x radians for x and y in the interval
   [-infinity, +infinity]. The sign of atan2() is the same as the
   sign of y. The atan2(y, x) function is computed as follows, where
   f is the number of fraction bits associated with the data type:

   Value of Input Arguments            Angle Returned

   x = 0 or y/x > 2**(f+1)             pi/2 * (sign y)
   x > 0 and y/x < or = 2**(f+1)       atan(y/x)
   x < 0 and y/x < or = 2**(f+1)       pi * (sign y) + atan(y/x)

   atand2() computes the angle in the interval [-180,180]
   whose arc tangent is y/x degrees for x and y in the interval
   [-infinity, +infinity]. The sign of atand2() is the same as the
   sign of y.


                          Entry-Point Names

   Generic                                  Compaq
   Function   Data Type                     Tru64 UNIX
   Name       Required    OpenVMS Alpha     Alpha

   atan2      S_FLOAT     math$atan2_s      atan2f
              T_FLOAT     math$atan2_t      atan2
              X_FLOAT     math$atan2_x      atan2l
              F_FLOAT     math$atan2_f
              G_FLOAT     math$atan2_g

   atand2     S_FLOAT     math$atand2_s     atand2f
              T_FLOAT     math$atand2_t     atand2
              X_FLOAT     math$atand2_x     atand2l
              F_FLOAT     math$atand2_f
              G_FLOAT     math$atand2_g
 

3  Exceptions

   Exceptional Argument   Routine Behavior

   y = x = 0              Invalid argument
   |y| = infinity and     Invalid argument
   |x| = infinity
 

2  atanh()

   Interface

     F_TYPE atanh (F_TYPE x)
 

3  Description
   atanh() returns the hyperbolic arc tangent of x for x in the
   interval (-1,1). atanh() is the inverse function of tanh().
   atanh(tanh (x)) = x.

   atanh(x) is computed as 1/2 ln((1+x)/(1-x)).


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   atanh      S_FLOAT     math$atanh_s   atanhf
              T_FLOAT     math$atanh_t   atanh
              X_FLOAT     math$atanh_x   atanhl
              F_FLOAT     math$atanh_f
              G_FLOAT     math$atanh_g
 

3  Exceptions

   Exceptional Argument   Routine Behavior

   |x| > or = 1           Invalid argument
 

2  bessel()

   Interface

     F_TYPE j0 (F_TYPE x)

     F_TYPE j1 (F_TYPE x)

     F_TYPE jn (int n, F_TYPE x)

     F_TYPE y0 (F_TYPE x)

     F_TYPE y1 (F_TYPE x)

     F_TYPE yn (int n, F_TYPE x)
 

3  Description
   j0() and j1()  return the value of the Bessel function of the
   first kind of orders 0 and 1, respectively.

   jn() returns the value of the Bessel function of the first kind
   of order n.

   y0() and y1()  return the value of the Bessel function of the
   second kind of orders 0 and 1, respectively.

   yn() returns the value of the Bessel function of the second kind
   of order n.

   The value of x must be positive for the y family of Bessel
   functions. The value of n specifies some integer value.


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   j0         S_FLOAT     math$j0_s      j0f
              T_FLOAT     math$j0_t      j0
              X_FLOAT     math$j0_x      j0l
              F_FLOAT     math$j0_f
              G_FLOAT     math$j0_g

   j1         S_FLOAT     math$j1_s      j1f
              T_FLOAT     math$j1_t      j1
              X_FLOAT     math$j1_x      j1l
              F_FLOAT     math$j1_f
              G_FLOAT     math$j1_g

   jn         S_FLOAT     math$jn_s      jnf
              T_FLOAT     math$jn_t      jn
              X_FLOAT     math$jn_x      jnl
              F_FLOAT     math$jn_f
              G_FLOAT     math$jn_g

   y0         S_FLOAT     math$y0_s      y0f
              T_FLOAT     math$y0_t      y0
              X_FLOAT     math$y0_x      y0l
              F_FLOAT     math$y0_f
              G_FLOAT     math$y0_g

   y1         S_FLOAT     math$y1_s      y1f
              T_FLOAT     math$y1_t      y1
              X_FLOAT     math$y1_x      y1l
              F_FLOAT     math$y1_f
              G_FLOAT     math$y1_g

   yn         S_FLOAT     math$yn_s      ynf
              T_FLOAT     math$yn_t      yn
              X_FLOAT     math$yn_x      ynl
              F_FLOAT     math$yn_f
              G_FLOAT     math$yn_g
 

3  Exceptions

   Exceptional Argument            Routine Behavior

   (y0(), y1(),  yn()) x < 0       Invalid argument
   (y0(), y1(),  yn()) x = 0       Overflow

   The j1() and jn()  functions can result in an underflow as x
   becomes small. The largest value of x for which this occurs is a
   function of n.

   The y1() and yn()  functions can result in an overflow as x
   becomes small. The largest value of x for which this occurs is
   a function of n.
 

2  cabs()

   Interface

     F_TYPE cabs (F_TYPE x, F_TYPE y)
 

3  Description
   cabs(x,y) is defined as the square root of (x**2 + y**2) and
   returns the same value as hypot(x,y).


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   cabs       S_FLOAT     math$hypot_s   cabsf
              T_FLOAT     math$hypot_t   cabs
              X_FLOAT     math$hypot_x   cabsl
              F_FLOAT     math$hypot_f
              G_FLOAT     math$hypot_g
 

3  Exceptions

   Exceptional Argument            Routine Behavior

   sqrt(x**2 + y**2) > max_float   Overflow


   Data
   Type  Value for: max_float

   F     Hexadecimal: FFFF7FFF
   G     Hexadecimal: FFFFFFFFFFFF7FFF
   S     Hexadecimal: 7F7FFFFF
   T     Hexadecimal: 7FEFFFFFFFFFFFFF
   X     Hexadecimal: 7FFEFFFFFFFFFFFFFFFFFFFFFFFFFFFF

   F     Decimal: 1.701411e38
   G     Decimal: 8.988465674311579e307
   S     Decimal: 3.402823e38
   T     Decimal: 1.797693134862316e308
   X     Decimal: 1.189731495357231765085759326628007016196477e4932
 

2  cbrt()

   Interface

     F_TYPE cbrt (F_TYPE x)
 

3  Description
   cbrt() returns the cube root of x.


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   cbrt       S_FLOAT     math$cbrt_s    cbrtf
              T_FLOAT     math$cbrt_t    cbrt
              X_FLOAT     math$cbrt_x    cbrtl
              F_FLOAT     math$cbrt_f
              G_FLOAT     math$cbrt_g
 

3  Exceptions
   None.
 

2  ccos()

   Interface

     F_COMPLEX ccos (F_TYPE x, F_TYPE y)
 

3  Description
   ccos() returns the cosine of a complex number, x + iy.

   ccos(x,y) is defined as cos (x + iy) = (cos x * cosh y - i * sin
   x * sinh y).


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   ccos       S_FLOAT     math$ccos_s    ccosf
              T_FLOAT     math$ccos_t    ccos
              X_FLOAT     math$ccos_x    ccosl
              F_FLOAT     math$ccos_f
              G_FLOAT     math$ccos_g
 

3  Exceptions

   Exceptional Argument            Routine Behavior

   |x| = infinity                  Invalid argument
   (sin x sinh y) > max_float      Overflow
   (cos x cosh y) > max_float      Overflow


   Data
   Type  Value for: max_float

   F     Hexadecimal: FFFF7FFF
   G     Hexadecimal: FFFFFFFFFFFF7FFF
   S     Hexadecimal: 7F7FFFFF
   T     Hexadecimal: 7FEFFFFFFFFFFFFF
   X     Hexadecimal: 7FFEFFFFFFFFFFFFFFFFFFFFFFFFFFFF

   F     Decimal: 1.701411e38
   G     Decimal: 8.988465674311579e307
   S     Decimal: 3.402823e38
   T     Decimal: 1.797693134862316e308
   X     Decimal: 1.189731495357231765085759326628007016196477e4932
 

2  cdiv()

   Interface

     F_COMPLEX cdiv (F_TYPE a, F_TYPE b, F_TYPE c, F_TYPE d)
 

3  Description
   cdiv() returns the quotient of two complex numbers: (a + ib)/(c +
   id).


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   cdiv       S_FLOAT     math$cdiv_s    cdivf
              T_FLOAT     math$cdiv_t    cdiv
              X_FLOAT     math$cdiv_x    cdivl
              F_FLOAT     math$cdiv_f
              G_FLOAT     math$cdiv_g
 

3  Exceptions

   Exceptional Argument   Routine Behavior

   c=d=0                  Invalid argument

   The quotient may overflow.
 

2  ceil()

   Interface

     F_TYPE ceil (F_TYPE x)
 

3  Description
   ceil() returns the smallest floating-point number of integral
   value greater than or equal to x.


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   ceil       S_FLOAT     math$ceil_s    ceilf
              T_FLOAT     math$ceil_t    ceil
              X_FLOAT     math$ceil_x    ceill
              F_FLOAT     math$ceil_f
              G_FLOAT     math$ceil_g
 

3  Exceptions
   None.
 

2  cexp()

   Interface

     F_COMPLEX cexp (F_TYPE x, F_TYPE y)
 

3  Description
   cexp() returns the exponential of a complex number.

   cexp(x,y) is defined as e**(x + iy) = e**x cos y + ie**x sin y.


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   cexp       S_FLOAT     math$cexp_s    cexpf
              T_FLOAT     math$cexp_t    cexp
              X_FLOAT     math$cexp_x    cexpl
              F_FLOAT     math$cexp_f
              G_FLOAT     math$cexp_g
 

3  Exceptions

   Exceptional Argument            Routine Behavior

   |y| = infinity                  Invalid argument
   |e**x cos y| > max_float        Overflow
   |e**x sin y| > max_float        Overflow


   Data
   Type  Value for: max_float

   F     Hexadecimal: FFFF7FFF
   G     Hexadecimal: FFFFFFFFFFFF7FFF
   S     Hexadecimal: 7F7FFFFF
   T     Hexadecimal: 7FEFFFFFFFFFFFFF
   X     Hexadecimal: 7FFEFFFFFFFFFFFFFFFFFFFFFFFFFFFF

   F     Decimal: 1.701411e38
   G     Decimal: 8.988465674311579e307
   S     Decimal: 3.402823e38
   T     Decimal: 1.797693134862316e308
   X     Decimal: 1.189731495357231765085759326628007016196477e4932

   Data
   Type  Value for: min_float

   F     Hexadecimal: 00000080
   G     Hexadecimal: 0000000000000010
   S     Hexadecimal: 00000001
   T     Hexadecimal: 0000000000000001
   X     Hexadecimal: 00000000000000000000000000000001

   F     Decimal: 2.9387359e-39
   G     Decimal: 5.562684646268003e-309
   S     Decimal: 1.4012985e-45
   T     Decimal: 4.940656458412465e-324
   X     Decimal: 6.4751751194380251109244389582276465524996e-4966
 

2  clog()

   Interface

     F_COMPLEX clog (F_TYPE x, F_TYPE y)
 

3  Description
   clog() returns the natural logarithm of a complex number.

   clog(x,y) is defined as ln(x + iy) = 1/2 ln(x**2 + y**2) + i *
   atan2(y,x).


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   clog       S_FLOAT     math$clog_s    clogf
              T_FLOAT     math$clog_t    clog
              X_FLOAT     math$clog_x    clogl
              F_FLOAT     math$clog_f
              G_FLOAT     math$clog_g
 

3  Exceptions

   Exceptional Argument   Routine Behavior

   y=x=0                  Invalid argument
   |y|=|x|=infinity       Invalid argument
 

2  cmul()

   Interface

     F_COMPLEX cmul (F_TYPE a, F_TYPE b, F_TYPE c, F_TYPE d)
 

3  Description
   cmul() returns the product of two complex numbers.

   cmul(a,b,c,d) is defined as (a + ib) * (c + id).


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   cmul       S_FLOAT     math$cmul_s    cmulf
              T_FLOAT     math$cmul_t    cmul
              X_FLOAT     math$cmul_x    cmull
              F_FLOAT     math$cmul_f
              G_FLOAT     math$cmul_g
 

3  Exceptions
   None.
 

2  copysign()

   Interface

     F_TYPE copysign (F_TYPE x, F_TYPE y)
 

3  Description
   copysign() returns x with the same sign as y. IEEE Std 754
   requires copysign(x,NaN) = +x or -x.


                          Entry-Point Names

   Generic                                   Compaq
   Function   Data Type                      Tru64 UNIX
   Name       Required    OpenVMS Alpha      Alpha

   copysign   S_FLOAT     math$copysign_s    copysignf
              T_FLOAT     math$copysign_t    copysign
              X_FLOAT     math$copysign_x    copysignl
              F_FLOAT     math$copysign_f
              G_FLOAT     math$copysign_g
 

3  Exceptions
   None.
 

2  cos()

   Interface

     F_TYPE cos (F_TYPE x)

     F_TYPE cosd (F_TYPE x)
 

3  Description
   cos() computes the cosine of x, measured in radians.

   cosd() computes the cosine of x, measured in degrees.


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   cos        S_FLOAT     math$cos_s     cosf
              T_FLOAT     math$cos_t     cos
              X_FLOAT     math$cos_x     cosl
              F_FLOAT     math$cos_f
              G_FLOAT     math$cos_g

   cosd       S_FLOAT     math$cosd_s    cosdf
              T_FLOAT     math$cosd_t    cosd
              X_FLOAT     math$cosd_x    cosdl
              F_FLOAT     math$cosd_f
              G_FLOAT     math$cosd_g
 

3  Exceptions

   Exceptional Argument   Routine Behavior

   |x| = infinity         Invalid argument
 

2  cosh()

   Interface

     F_TYPE cosh (F_TYPE x)
 

3  Description
   cosh() computes the hyperbolic cosine of x.

   cosh(x) is defined as (exp(x) + exp(-x))/2.


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   cosh       S_FLOAT     math$cosh_s    coshf
              T_FLOAT     math$cosh_t    cosh
              X_FLOAT     math$cosh_x    coshl
              F_FLOAT     math$cosh_f
              G_FLOAT     math$cosh_g
 

3  Exceptions

   Exceptional Argument            Routine Behavior

   |x| > ln(2 * max_float)         Overflow


   Data
   Type  Value for: ln(2 * max_float)

   F     Hexadecimal: 721843B1
   G     Hexadecimal: 39EFFEFA2E4240A6
   S     Hexadecimal: 42B2D4FC
   T     Hexadecimal: 408633CE8FB9F87E
   X     Hexadecimal: 400C62E9BB80635D81D36125B64DA4A6

   F     Decimal: 88.72284
   G     Decimal: 709.7827128933840
   S     Decimal: 89.41599
   T     Decimal: 710.4758600739439
   X     Decimal: 11357.2165534747038948013483100922230678208
 

2  cot()

   Interface

     F_TYPE cot (F_TYPE x)

     F_TYPE cotd (F_TYPE x)
 

3  Description
   cot() computes the cotangent of x, measured in radians.

   cotd() computes the cotangent of x, measured in degrees.


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   cot        S_FLOAT     math$cot_s     cotf
              T_FLOAT     math$cot_t     cot
              X_FLOAT     math$cot_x     cotl
              F_FLOAT     math$cot_f
              G_FLOAT     math$cot_g

   cotd       S_FLOAT     math$cotd_s    cotdf
              T_FLOAT     math$cotd_t    cotd
              X_FLOAT     math$cotd_x    cotdl
              F_FLOAT     math$cotd_f
              G_FLOAT     math$cotd_g
 

3  Exceptions

   Exceptional Argument                     Routine Behavior

   (cot) x=0                                Overflow
   (cotd) |x| = multiples of 180 degrees    Overflow
 

2  cpow()

   Interface

     F_COMPLEX cpow (F_TYPE a, F_TYPE b, F_TYPE c, F_TYPE d)
 

3  Description
   cpow() raises a complex base (a + ib) to a complex exponent (c +
   id).

   cpow(a,b,c,d) is defined as e**((c + id) ln(a + ib)).


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   cpow       S_FLOAT     math$cpow_s    cpowf
              T_FLOAT     math$cpow_t    cpow
              X_FLOAT     math$cpow_x    cpowl
              F_FLOAT     math$cpow_f
              G_FLOAT     math$cpow_g
 

3  Exceptions

   Exceptional Argument                Routine Behavior

   sqrt (a**2 + b**2) > max_float      Overflow
   c/2 * ln(a**2 + b**2) > max_float   Overflow
   c/2 * ln(a**2 + b**2) - (d *        Overflow
   atan2(b,c)) > max_float
   a=b=c=d=0                           Invalid argument


   Data
   Type  Value for: max_float

   F     Hexadecimal: FFFF7FFF
   G     Hexadecimal: FFFFFFFFFFFF7FFF
   S     Hexadecimal: 7F7FFFFF
   T     Hexadecimal: 7FEFFFFFFFFFFFFF
   X     Hexadecimal: 7FFEFFFFFFFFFFFFFFFFFFFFFFFFFFFF

   F     Decimal: 1.701411e38
   G     Decimal: 8.988465674311579e307
   S     Decimal: 3.402823e38
   T     Decimal: 1.797693134862316e308
   X     Decimal: 1.189731495357231765085759326628007016196477e4932
 

2  csin()

   Interface

     F_COMPLEX csin (F_TYPE x, F_TYPE y)
 

3  Description
   csin() computes the sine of a complex number, x + iy.

   csin(x,y) is defined as csin (x + iy) = sin x * cosh y + i * cos
   x * sinh y.


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   csin       S_FLOAT     math$csin_s    csinf
              T_FLOAT     math$csin_t    csin
              X_FLOAT     math$csin_x    csinl
              F_FLOAT     math$csin_f
              G_FLOAT     math$csin_g
 

3  Exceptions

   Exceptional Argument            Routine Behavior

   |x| = infinity                  Invalid argument
   |sin x * cosh y| > max_float    Overflow
   |cos x * sinh y| > max_float    Overflow


   Data
   Type  Value for: max_float

   F     Hexadecimal: FFFF7FFF
   G     Hexadecimal: FFFFFFFFFFFF7FFF
   S     Hexadecimal: 7F7FFFFF
   T     Hexadecimal: 7FEFFFFFFFFFFFFF
   X     Hexadecimal: 7FFEFFFFFFFFFFFFFFFFFFFFFFFFFFFF

   F     Decimal: 1.701411e38
   G     Decimal: 8.988465674311579e307
   S     Decimal: 3.402823e38
   T     Decimal: 1.797693134862316e308
   X     Decimal: 1.189731495357231765085759326628007016196477e4932
 

2  csqrt()

   Interface

     F_COMPLEX csqrt (F_TYPE x, F_TYPE y)
 

3  Description
   csqrt() computes the square root of a complex number, x + iy.
   The root is chosen so that the real part of csqrt(x,y) is greater
   than or equal to zero.




                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   csqrt      S_FLOAT     math$csqrt_s   csqrtf
              T_FLOAT     math$csqrt_t   csqrt
              X_FLOAT     math$csqrt_x   csqrtl
              F_FLOAT     math$csqrt_f
              G_FLOAT     math$csqrt_g
 

3  Exceptions
   None.
 

2  drem()

   Interface

     F_TYPE drem (F_TYPE x, F_TYPE y)
 

3  Description
   drem() returns the remainder r = x-n*y, where n = rint(x/y).
   Additionally, if |n-x/y|=1/2, then n is even. The remainder is
   computed exactly, and |r| is less than or equal to |y|/2. The
   drem() and remainder()  functions are aliases of each other.


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   drem       S_FLOAT     math$rem_s     dremf
              T_FLOAT     math$rem_t     drem
              X_FLOAT     math$rem_x     dreml
              F_FLOAT     math$rem_f
              G_FLOAT     math$rem_g
 

3  Exceptions

   Exceptional Argument   Routine Behavior

   x = infinity           Invalid argument

   Note that rem(x,0) has value 0 and is not an exceptional case.
 

2  erf()

   Interface

     F_TYPE erf (F_TYPE x)

     F_TYPE erfc (F_TYPE x)
 

3  Description
   erf() returns the value of the error function. The definition of
   the erf() function is (2/sqrt(pi)) times the area under the curve
   exp(-t * t) between 0 and x.

   erfc() returns (1.0-erf(x)).


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   erf        S_FLOAT     math$erf_s     erff
              T_FLOAT     math$erf_t     erf
              X_FLOAT     math$erf_x     erfl
              F_FLOAT     math$erf_f
              G_FLOAT     math$erf_g

   erfc       S_FLOAT     math$erfc_s    erfcf
              T_FLOAT     math$erfc_t    erfc
              X_FLOAT     math$erfc_x    erfcl
              F_FLOAT     math$erfc_f
              G_FLOAT     math$erfc_g
 

3  Exceptions
   The erfc() function can result in an underflow as x gets large.
 

2  exp()

   Interface

     F_TYPE exp (F_TYPE x)

     F_TYPE expm1 (F_TYPE x)
 

3  Description
   exp() computes the value of the exponential function, defined
   as e**x, where e is the constant used as a base for natural
   logarithms.

   expm1() computes exp(x)-1 accurately, even for tiny x.


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   exp        S_FLOAT     math$exp_s     expf
              T_FLOAT     math$exp_t     exp
              X_FLOAT     math$exp_x     expl
              F_FLOAT     math$exp_f
              G_FLOAT     math$exp_g

   expm1      S_FLOAT     math$expm1_s   expm1f
              T_FLOAT     math$expm1_t   expm1
              X_FLOAT     math$expm1_x   expm1l
              F_FLOAT     math$expm1_f
              G_FLOAT     math$expm1_g
 

3  Exceptions

   Exceptional Argument   Routine Behavior

   x > ln(max_float)      Overflow
   x < ln(min_float)      Underflow


   Data
   Type  Value for: ln(max_float)

   F     Hexadecimal: 0F3443B0
   G     Hexadecimal: 7B616E3A28B740A6
   S     Hexadecimal: 42B17218
   T     Hexadecimal: 40862E42FEFA39EF
   X     Hexadecimal: 400C62E42FEFA39EF35793C7673007E6

   F     Decimal: 88.029692
   G     Decimal: 709.0895657128241
   S     Decimal: 88.7228391
   T     Decimal: 709.7827128933840
   X     Decimal: 11356.5234062941439494919310779707648912527

   Data
   Type  Value for: ln(min_float)

   F     Hexadecimal: 7218C3B1
   G     Hexadecimal: 39EFFEFA2E42C0A6
   S     Hexadecimal: C2CE8ED0
   T     Hexadecimal: C0874385446D71C3
   X     Hexadecimal: C00C6546282207802C89D24D65E96274

   F     Decimal: -88.72284
   G     Decimal: -709.7827128933840
   S     Decimal: -103.2789
   T     Decimal: -744.4400719213813
   X     Decimal: -11432.7695961557379335278266113311643138373
 

2  fabs()

   Interface

     F_TYPE fabs (F_TYPE x)
 

3  Description
   fabs() computes the absolute value of x.


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   fabs       S_FLOAT     math$fabs_s    fabsf
              T_FLOAT     math$fabs_t    fabs
              X_FLOAT     math$fabs_x    fabsl
              F_FLOAT     math$fabs_f
              G_FLOAT     math$fabs_g
 

3  Exceptions
   None.
 

2  finite()

   Interface

     int finite (F_TYPE x)
 

3  Description
   finite() returns the integer value 1 (true) or 0 (false).

   finite(x) = 1 when -infinity < x < +infinity.

   finite(x) = 0 when |x| = infinity or x is a NaN.


                          Entry-Point Names

   Generic                                   Compaq
   Function   Data Type                      Tru64 UNIX
   Name       Required    OpenVMS Alpha      Alpha

   finite     S_FLOAT     math$finite_s      finitef
              T_FLOAT     math$finite_t      finite
              X_FLOAT     math$finite_x      finitel
              F_FLOAT     math$finite_f
              G_FLOAT     math$finite_g
 

3  Exceptions
   None.
 

2  floor()

   Interface

     F_TYPE floor (F_TYPE x)
 

3  Description
   floor() returns the largest floating-point number of integral
   value less than or equal to x.


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   floor      S_FLOAT     math$floor_s   floorf
              T_FLOAT     math$floor_t   floor
              X_FLOAT     math$floor_x   floorl
              F_FLOAT     math$floor_f
              G_FLOAT     math$floor_g
 

3  Exceptions
   None.
 

2  fmod()

   Interface

     F_TYPE fmod (F_TYPE x, F_TYPE y)
 

3  Description
   fmod() computes the floating-point remainder of x modulo y.
   It returns the remainder r = x-n*y, where n = trunc(x/y). The
   remainder is computed exactly.

   The result has the same sign as x and a magnitude less than the
   magnitude of y.


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   fmod       S_FLOAT     math$mod_s     fmodf
              T_FLOAT     math$mod_t     fmod
              X_FLOAT     math$mod_x     fmodl
              F_FLOAT     math$mod_f
              G_FLOAT     math$mod_g
 

3  Exceptions

   Exceptional Argument   Routine Behavior

   x = infinity           Invalid argument

   Note that fmod(x,0) has value 0 and is not an exceptional case.
 

2  fp_class()

   Interface

     int fp_class (F_TYPE x)
 

3  Description
   These routines determine the class of IEEE floating-point values.
   They return one of the constants in the file <fp_class.h> and
   never cause an exception, even for signaling NaNs. These routines
   implement the recommended function class(x) in the appendix of
   the IEEE Std 754. The constants in <fp_class.h> refer to the
   following classes of values:

   Constant           Class

   FP_SNAN            Signaling NaN (Not-a-Number)
   FP_QNAN            Quiet NaN (Not-a-Number)
   FP_POS_INF         +Infinity
   FP_NEG_INF         -Infinity
   FP_POS_NORM        Positive normalized
   FP_NEG_NORM        Negative normalized
   FP_POS_DENORM      Positive denormalized
   FP_NEG_DENORM      Negative denormalized
   FP_POS_ZERO        +0.0 (positive zero)
   FP_NEG_ZERO        -0.0 (negative zero)


                          Entry-Point Names

   Generic                                       Compaq
   Function   Data Type                          Tru64 UNIX
   Name       Required    OpenVMS Alpha          Alpha

   fp_class   S_FLOAT     math$fp_class_s        fp_classf
              T_FLOAT     math$fp_class_t        fp_class
              X_FLOAT     math$fp_class_x        fp_classl
              F_FLOAT     math$fp_class_f
              G_FLOAT     math$fp_class_g
 

3  Exceptions
   None.
 

2  frexp()

   Interface

     F_TYPE frexp (F_TYPE x, int *n)
 

3  Description
   frexp() breaks a floating-point number into a normalized fraction
   and an integral power of 2. It stores the integer in the int
   object pointed to by the n parameter and returns the fraction
   part.


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   frexp      S_FLOAT     math$frexp_s   frexpf
              T_FLOAT     math$frexp_t   frexp
              X_FLOAT     math$frexp_x   frexpl
              F_FLOAT     math$frexp_f
              G_FLOAT     math$frexp_g
 

3  Exceptions
   None.
 

2  hypot()

   Interface

     F_TYPE hypot (F_TYPE x, F_TYPE y)
 

3  Description
   hypot() computes the length of the hypotenuse of a right
   triangle, where x and y represent the perpendicular sides of
   the triangle.

   hypot(x,y) is defined as the square root of (x**2 + y**2) and
   returns the same value as cabs(x,y).


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   hypot      S_FLOAT     math$hypot_s   hypotf
              T_FLOAT     math$hypot_t   hypot
              X_FLOAT     math$hypot_x   hypotl
              F_FLOAT     math$hypot_f
              G_FLOAT     math$hypot_g
 

3  Exceptions

   Exceptional Argument            Routine Behavior

   sqrt(x**2 + y**2) > max_float   Overflow


   Data
   Type  Value for: max_float

   F     Hexadecimal: FFFF7FFF
   G     Hexadecimal: FFFFFFFFFFFF7FFF
   S     Hexadecimal: 7F7FFFFF
   T     Hexadecimal: 7FEFFFFFFFFFFFFF
   X     Hexadecimal: 7FFEFFFFFFFFFFFFFFFFFFFFFFFFFFFF

   F     Decimal: 1.701411e38
   G     Decimal: 8.988465674311579e307
   S     Decimal: 3.402823e38
   T     Decimal: 1.797693134862316e308
   X     Decimal: 1.189731495357231765085759326628007016196477e4932
 

2  ilogb()

   Interface

     int ilogb (F_TYPE x)
 

3  Description
   ilogb(x) returns the unbiased exponent of x as an integer, (as if
   x were normalized >= 1.0 and < 2.0) except:

      ilogb(NaN) is INT_MIN
      ilogb(inf) is INT_MAX
      logb(0) is INT_MIN

   There are no errors. The sign of x is ignored.


                          Entry-Point Names

   Generic                                       Compaq
   Function   Data Type                          Tru64 UNIX
   Name       Required    OpenVMS Alpha          Alpha

   ilogb      S_FLOAT     math$ilogb_s           ilogbf
              T_FLOAT     math$ilogb_t           ilogb
              X_FLOAT     math$ilogb_x           ilogbl
              F_FLOAT     math$ilogb_f
              G_FLOAT     math$ilogb_g
 

3  Exceptions
   None.
 

2  isnan()

   Interface

     int isnan (F_TYPE x)
 

3  Description
   isnan() returns 1 (true) if x is NaN (the IEEE floating-point
   reserved Not-a-Number value) and 0 (false) otherwise.


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   isnan      S_FLOAT     math$isnan_s   isnanf
              T_FLOAT     math$isnan_t   isnan
              X_FLOAT     math$isnan_x   isnanl
              F_FLOAT     math$isnan_f
              G_FLOAT     math$isnan_g
 

3  Exceptions
   None.
 

2  ldexp()

   Interface

     F_TYPE ldexp (F_TYPE x, int n)
 

3  Description
   ldexp() multiplies a floating-point number, x, by 2**n.


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   ldexp      S_FLOAT     math$ldexp_s   ldexpf
              T_FLOAT     math$ldexp_t   ldexp
              X_FLOAT     math$ldexp_x   ldexpl
              F_FLOAT     math$ldexp_f
              G_FLOAT     math$ldexp_g
 

3  Exceptions

   Exceptional Argument            Routine Behavior

   |x*(2**n)| > max_float          Overflow
   |x*(2**n)| < min_float          Underflow


   Data
   Type  Value for: max_float

   F     Hexadecimal: FFFF7FFF
   G     Hexadecimal: FFFFFFFFFFFF7FFF
   S     Hexadecimal: 7F7FFFFF
   T     Hexadecimal: 7FEFFFFFFFFFFFFF
   X     Hexadecimal: 7FFEFFFFFFFFFFFFFFFFFFFFFFFFFFFF

   F     Decimal: 1.701411e38
   G     Decimal: 8.988465674311579e307
   S     Decimal: 3.402823e38
   T     Decimal: 1.797693134862316e308
   X     Decimal: 1.189731495357231765085759326628007016196477e4932

   Data
   Type  Value for: min_float

   F     Hexadecimal: 00000080
   G     Hexadecimal: 0000000000000010
   S     Hexadecimal: 00000001
   T     Hexadecimal: 0000000000000001
   X     Hexadecimal: 00000000000000000000000000000001

   F     Decimal: 2.9387359e-39
   G     Decimal: 5.562684646268003e-309
   S     Decimal: 1.4012985e-45
   T     Decimal: 4.940656458412465e-324
   X     Decimal: 6.4751751194380251109244389582276465524996e-4966
 

2  lgamma()

   Interface

     F_TYPE lgamma (F_TYPE x)
 

3  Description
   lgamma() returns the logarithm of the absolute value of gamma
   of x, or ln(|G(x)|), where G is the gamma function. The sign of
   gamma of x is returned in the external integer variable signgam
   as +1 or -1. The x parameter cannot be 0 or a negative integer.

   gamma() returns the natural log of the gamma function and so is
   functionally equivalent to lgamma(). Because of this, gamma()  is
   marked TO BE WITHDRAWN in the X/Open Portability Guide, Revision
   4 (XPG4).


                          Entry-Point Names

   Generic                                       Compaq
   Function   Data Type                          Tru64 UNIX
   Name       Required    OpenVMS Alpha          Alpha

   lgamma     S_FLOAT     math$lgamma_s          lgammaf
              T_FLOAT     math$lgamma_t          lgamma
              X_FLOAT     math$lgamma_x          lgammal
              F_FLOAT     math$lgamma_f
              G_FLOAT     math$lgamma_g
 

3  Exceptions

   Exceptional Argument            Routine Behavior

   |x| = infinity                  Invalid argument
   x = 0, -1, -2, -3, ...          Invalid argument
   |x| > lgamma_max_float          Overflow


   Data
   Type  Value for: lgamma_max_float

   F     Hexadecimal: 50F97CC6
   G     Hexadecimal: F55FC5015ABD7F67
   S     Hexadecimal: 7BC650F9
   T     Hexadecimal: 7F475ABDC501F55F
   X     Hexadecimal: 7FF171AA9917FFFBD7EA44AE6D203DF6

   F     Decimal: 2.0594342e36
   G     Decimal: 1.2812545499066958e305
   S     Decimal: 2.0594342e36
   T     Decimal: 1.2812545499066958e305
   X     Decimal: 1.0485738685148938358098967157129705040168e4928
 

2  log()

   Interface

     F_TYPE ln (F_TYPE x)

     F_TYPE log2 (F_TYPE x)

     F_TYPE log10 (F_TYPE x)

     F_TYPE log1p (F_TYPE y)
 

3  Description
   ln() computes the natural (base e) logarithm of x.

   log2() computes the base 2 logarithm of x.

   log10() computes the common (base 10) logarithm of x.

   log1p() computes ln(1+y) accurately, even for tiny y.


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   ln         S_FLOAT     math$ln_s      logf
              T_FLOAT     math$ln_t      log
              X_FLOAT     math$ln_x      logl
              F_FLOAT     math$ln_f
              G_FLOAT     math$ln_g

   log2       S_FLOAT     math$log2_s    log2f
              T_FLOAT     math$log2_t    log2
              X_FLOAT     math$log2_x    log2l
              F_FLOAT     math$log2_f
              G_FLOAT     math$log2_g

   log10      S_FLOAT     math$log10_s   log10f
              T_FLOAT     math$log10_t   log10
              X_FLOAT     math$log10_x   log10l
              F_FLOAT     math$log10_f
              G_FLOAT     math$log10_g

   log1p      S_FLOAT     math$log1p_s   log1pf
              T_FLOAT     math$log1p_t   log1p
              X_FLOAT     math$log1p_x   log1pl
              F_FLOAT     math$log1p_f
              G_FLOAT     math$log1p_g
 

3  Exceptions

   Exceptional Argument   Routine Behavior

   x < 0                  Invalid argument
   x = 0                  Overflow
   1+y < 0                Invalid argument
   1+y = 0                Overflow
 

2  logb()

   Interface

     F_TYPE logb (F_TYPE x)
 

3  Description
   logb() returns a signed integer converted to double-precision
   floating-point and so chosen that 1 <= |x|/2**n < 2 unless x = 0
   or |x| = infinity.

   IEEE Std 754 defines logb(+infinity) = +infinity and logb(0) =
   -infinity. The latter is required to signal division by zero.


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   logb       S_FLOAT     math$logb_s    logbf
              T_FLOAT     math$logb_t    logb
              X_FLOAT     math$logb_x    logbl
              F_FLOAT     math$logb_f
              G_FLOAT     math$logb_g
 

3  Exceptions

   Exceptional Argument   Routine Behavior

   x = 0                  Invalid argument
 

2  modf()

   Interface

     F_TYPE modf (F_TYPE x, F_TYPE *n)
 

3  Description
   modf() splits a floating-point number x into a fractional part f
   and an integer part i such that |f| < 1.0 and (f + i) = x. Both f
   and i have the same sign as x. modf() returns f and stores i into
   the location pointed to by n.


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   modf       S_FLOAT     math$modf_s    modff
              T_FLOAT     math$modf_t    modf
              X_FLOAT     math$modf_x    modfl
              F_FLOAT     math$modf_f
              G_FLOAT     math$modf_g
 

3  Exceptions
   None.
 

2  nextafter()

   Interface

     F_TYPE nextafter (F_TYPE x, F_TYPE y)
 

3  Description
   nextafter() returns the machine-representable number next to x in
   the direction y.


                          Entry-Point Names

   Generic                                       Compaq
   Function   Data Type                          Tru64 UNIX
   Name       Required    OpenVMS Alpha          Alpha

   nextafter  S_FLOAT     math$nextafter_s       nextafterf
              T_FLOAT     math$nextafter_t       nextafter
              X_FLOAT     math$nextafter_x       nextafterl
              F_FLOAT     math$nextafter_f
              G_FLOAT     math$nextafter_g
 

3  Exceptions

   Exceptional Argument            Routine Behavior

   x = max_float and y =           Overflow
   +infinity
   x = -max_float and y = -        Overflow
   infinity
   x = min_float and y is less     Underflow
   than or equal to 0
   x = -min_float and y is         Underflow
   greater than or equal to 0
 

2  nint()

   Interface

     F_TYPE nint (F_TYPE x)
 

3  Description
   nint() returns the nearest integral value to x, except halfway
   cases are rounded to the integral value larger in magnitude. This
   function corresponds to the Fortran generic intrinsic function
   nint().


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   nint       S_FLOAT     math$nint_s    nintf
              T_FLOAT     math$nint_t    nint
              X_FLOAT     math$nint_x    nintl
              F_FLOAT     math$nint_f
              G_FLOAT     math$nint_g
 

3  Exceptions
   None.
 

2  pow()

   Interface

     F_TYPE pow (F_TYPE x, F_TYPE y)
 

3  Description
   pow() raises a floating-point base x to a floating-point exponent
   y. The value of pow(x,y) is computed as e**(y ln(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
   nonzero values of y. For pow(NaN,0), see your language reference
   manual.


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   pow        S_FLOAT     math$pow_ss    powf
              T_FLOAT     math$pow_tt    pow
              X_FLOAT     math$pow_xx    powl
              F_FLOAT     math$pow_ff
              G_FLOAT     math$pow_gg
 

3  Exceptions

   Exceptional Argument                     Routine Behavior

   y ln(x) > ln(max_float)                  Overflow
   y ln(x) < ln(min_float)                  Underflow

   Fortran-Exceptional Argument             Routine Behavior

   x < 0                                    Invalid argument
   x = 0 and y < 0                          Invalid argument
   x = 0 and y = 0                          Invalid argument
   x = +infinity and y = 0                  Invalid argument
   x = 1 and |y| = infinity                 Invalid argument

   ANSI C-Exceptional Argument              Routine Behavior

   |x| = 1 and |y| = infinity               Invalid argument
   x < 0 and y is not integral              Invalid argument


   Data
   Type  Value for: ln(max_float)

   F     Hexadecimal: 0F3443B0
   G     Hexadecimal: 7B616E3A28B740A6
   S     Hexadecimal: 42B17218
   T     Hexadecimal: 40862E42FEFA39EF
   X     Hexadecimal: 400C62E42FEFA39EF35793C7673007E6

   F     Decimal: 88.029692
   G     Decimal: 709.0895657128241
   S     Decimal: 88.7228391
   T     Decimal: 709.7827128933840
   X     Decimal: 11356.5234062941439494919310779707648912527

   Data
   Type  Value for: ln(min_float)

   F     Hexadecimal: 7218C3B1
   G     Hexadecimal: 39EFFEFA2E42C0A6
   S     Hexadecimal: C2CE8ED0
   T     Hexadecimal: C0874385446D71C3
   X     Hexadecimal: C00C6546282207802C89D24D65E96274

   F     Decimal: -88.72284
   G     Decimal: -709.7827128933840
   S     Decimal: -103.2789
   T     Decimal: -744.4400719213813
   X     Decimal: -11432.7695961557379335278266113311643138373
 

2  random()

   Interface

     F_TYPE random (int *n)
 

3  Description
   random() is a general random number generator. The argument to
   the random function is an integer passed by reference. There
   are no restrictions on the input argument, although it should
   be initialized to different values on separate runs in order to
   obtain different random sequences. This function must be called
   again to obtain the next pseudo random number. The argument is
   updated automatically.

   The result is a floating-point number that is uniformly
   distributed in the interval (0.0,1.0).




                          Entry-Point Names

   Generic                                  Compaq
   Function   Data Type                     Tru64 UNIX
   Name       Required    OpenVMS Alpha     Alpha

   random     S_FLOAT     math$random_l_s
              T_FLOAT
              X_FLOAT
              F_FLOAT     math$random_l_f
              G_FLOAT
 

3  Exceptions
   None.
 

2  remainder()

   Interface

     F_TYPE remainder (F_TYPE x, F_TYPE y)
 

3  Description
   remainder() returns the remainder r = x-n*y, where n = rint(x/y).
   Additionally, if |n-x/y| = 1/2, then n is even. Consequently, the
   remainder is computed exactly, and |r| is less than or equal to
   |y|/2. The drem() and remainder()  functions are aliases of each
   other.


                          Entry-Point Names

   Generic                                       Compaq
   Function   Data Type                          Tru64 UNIX
   Name       Required    OpenVMS Alpha          Alpha

   remainder  S_FLOAT     math$rem_s             remainderf
              T_FLOAT     math$rem_t             remainder
              X_FLOAT     math$rem_x             remainderl
              F_FLOAT     math$rem_f
              G_FLOAT     math$rem_g
 

3  Exceptions

   Exceptional Argument   Routine Behavior

   x = infinity           Invalid argument

   Note that rem(x,0) has value 0 and is not an exceptional case.
 

2  rint()

   Interface

     F_TYPE rint (F_TYPE x)
 

3  Description
   rint() rounds x to an integral value according to the current
   IEEE rounding direction specified by the user.


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   rint       S_FLOAT     math$rint_s    rintf
              T_FLOAT     math$rint_t    rint
              X_FLOAT     math$rint_x    rintl
              F_FLOAT     math$rint_f
              G_FLOAT     math$rint_g
 

3  Exceptions
   None.
 

2  scalb()

   Interface

     F_TYPE scalb (F_TYPE x, F_TYPE y)
 

3  Description
   scalb() = x*(2**y) computed, for integer-valued floating point
   number y.




                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   scalb      S_FLOAT     math$scalb_s   scalbf
              T_FLOAT     math$scalb_t   scalb
              X_FLOAT     math$scalb_x   scalbl
              F_FLOAT     math$scalb_f
              G_FLOAT     math$scalb_g
 

3  Exceptions

   Exceptional Argument   Routine Behavior

   x*(2**y) > max_float   Overflow
   x*(2**y) < min_float   Underflow
   x=0, y=infinity        Invalid argument
   x=infinity, y=-        Invalid argument
   infinity


   Data
   Type  Value for: max_float

   F     Hexadecimal: FFFF7FFF
   G     Hexadecimal: FFFFFFFFFFFF7FFF
   S     Hexadecimal: 7F7FFFFF
   T     Hexadecimal: 7FEFFFFFFFFFFFFF
   X     Hexadecimal: 7FFEFFFFFFFFFFFFFFFFFFFFFFFFFFFF

   F     Decimal: 1.701411e38
   G     Decimal: 8.988465674311579e307
   S     Decimal: 3.402823e38
   T     Decimal: 1.797693134862316e308
   X     Decimal: 1.189731495357231765085759326628007016196477e4932

   Data
   Type  Value for: min_float

   F     Hexadecimal: 00000080
   G     Hexadecimal: 0000000000000010
   S     Hexadecimal: 00000001
   T     Hexadecimal: 0000000000000001
   X     Hexadecimal: 00000000000000000000000000000001

   F     Decimal: 2.9387359e-39
   G     Decimal: 5.562684646268003e-309
   S     Decimal: 1.4012985e-45
   T     Decimal: 4.940656458412465e-324
   X     Decimal: 6.4751751194380251109244389582276465524996e-4966
 

2  sin()

   Interface

     F_TYPE sin (F_TYPE x)

     F_TYPE sind (F_TYPE x)
 

3  Description
   sin() computes the sine of x, measured in radians.

   sind() computes the sine of x, measured in degrees.


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   sin        S_FLOAT     math$sin_s     sinf
              T_FLOAT     math$sin_t     sin
              X_FLOAT     math$sin_x     sinl
              F_FLOAT     math$sin_f
              G_FLOAT     math$sin_g

   sind       S_FLOAT     math$sind_s    sindf
              T_FLOAT     math$sind_t    sind
              X_FLOAT     math$sind_x    sindl
              F_FLOAT     math$sind_f
              G_FLOAT     math$sind_g
 

3  Exceptions

   Exceptional Argument                     Routine Behavior

   |x| = infinity                           Invalid argument
   (sind) |x| < (180/pi) * min_float        Underflow


   Data
   Type  Value for: (180/pi) * min_float

   F     Hexadecimal: 2EE10365
   G     Hexadecimal: C1F81A63A5DC006C
   S     Hexadecimal: 00000039
   T     Hexadecimal: 0000000000000039
   X     Hexadecimal: 00000000000000000000000000000039

   F     Decimal: 1.683772e-37
   G     Decimal: 3.187183529933798e-307
   S     Decimal: 8.028849e-44
   T     Decimal: 2.830787630910868e-322
   X     Decimal: 3.71000205951917569316937757202433432154392e-4964
 

2  sinh()

   Interface

     F_TYPE sinh (F_TYPE x)
 

3  Description
   sinh() computes the hyperbolic sine of x.

   sinh(x) is defined as (exp(x)-exp(-x))/2.


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   sinh       S_FLOAT     math$sinh_s    sinhf
              T_FLOAT     math$sinh_t    sinh
              X_FLOAT     math$sinh_x    sinhl
              F_FLOAT     math$sinh_f
              G_FLOAT     math$sinh_g
 

3  Exceptions

   Exceptional Argument      Routine Behavior

   |x| > ln(2 * max_float)   Overflow


   Data
   Type  Value for: ln(2 * max_float)

   F     Hexadecimal: 721843B1
   G     Hexadecimal: 39EFFEFA2E4240A6
   S     Hexadecimal: 42B2D4FC
   T     Hexadecimal: 408633CE8FB9F87E
   X     Hexadecimal: 400C62E9BB80635D81D36125B64DA4A6

   F     Decimal: 88.72284
   G     Decimal: 709.7827128933840
   S     Decimal: 89.41599
   T     Decimal: 710.4758600739439
   X     Decimal: 11357.2165534747038948013483100922230678208
 

2  sqrt()

   Interface

     F_TYPE sqrt (F_TYPE x)
 

3  Description
   sqrt() computes the rounded square root of x.

   For platforms supporting a signed zero, sqrt(-0) = 0.


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   sqrt       S_FLOAT     math$sqrt_s    sqrtf
              T_FLOAT     math$sqrt_t    sqrt
              X_FLOAT     math$sqrt_x    sqrtl
              F_FLOAT     math$sqrt_f
              G_FLOAT     math$sqrt_g
 

3  Exceptions

   Exceptional Argument   Routine Behavior

   x < 0                  Invalid argument
 

2  tan()

   Interface

     F_TYPE tan (F_TYPE x)

     F_TYPE tand (F_TYPE x)
 

3  Description
   tan() computes the tangent of x, measured in radians.

   tand() computes the tangent of x, measured in degrees.


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   tan        S_FLOAT     math$tan_s     tanf
              T_FLOAT     math$tan_t     tan
              X_FLOAT     math$tan_x     tanl
              F_FLOAT     math$tan_f
              G_FLOAT     math$tan_g

   tand       S_FLOAT     math$tand_s    tandf
              T_FLOAT     math$tand_t    tand
              X_FLOAT     math$tand_x    tandl
              F_FLOAT     math$tand_f
              G_FLOAT     math$tand_g
 

3  Exceptions

   Exceptional Argument                  Routine Behavior

   |x| = infinity                        Invalid argument
   (tand) |x| < (180/pi) * min_float     Underflow
   (tand) x = (2n+1) * 90                Overflow


   Data
   Type  Value for: (180/pi) * min_float

   F     Hexadecimal: 2EE10365
   G     Hexadecimal: C1F81A63A5DC006C
   S     Hexadecimal: 00000039
   T     Hexadecimal: 0000000000000039
   X     Hexadecimal: 00000000000000000000000000000039

   F     Decimal: 1.683772e-37
   G     Decimal: 3.187183529933798e-307
   S     Decimal: 8.028849e-44
   T     Decimal: 2.830787630910868e-322
   X     Decimal: 3.71000205951917569316937757202433432154392e-4964
 

2  tanh()

   Interface

     F_TYPE tanh (F_TYPE x)
 

3  Description
   tanh() computes the hyperbolic tangent of x.

   tanh(x) is defined as (exp(x)-exp(-x))/(exp(x) + exp(-x)).


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   tanh       S_FLOAT     math$tanh_s    tanhf
              T_FLOAT     math$tanh_t    tanh
              X_FLOAT     math$tanh_x    tanhl
              F_FLOAT     math$tanh_f
              G_FLOAT     math$tanh_g
 

3  Exceptions
   None.
 

2  trunc()

   Interface

     F_TYPE trunc (F_TYPE x)
 

3  Description
   trunc() truncates x to an integral value.


                          Entry-Point Names

   Generic                               Compaq
   Function   Data Type   OpenVMS        Tru64 UNIX
   Name       Required    Alpha          Alpha

   trunc      S_FLOAT     math$trunc_s   truncf
              T_FLOAT     math$trunc_t   trunc
              X_FLOAT     math$trunc_x   truncl
              F_FLOAT     math$trunc_f
              G_FLOAT     math$trunc_g
 

3  Exceptions
   None.
 

2  unordered()

   Interface

     int unordered (F_TYPE x, F_TYPE y)
 

3  Description
   unordered(x,y) returns the value 1 (true) if x, y, or both are a
   NaN and returns the value 0 (false) otherwise.


                          Entry-Point Names

   Generic                                       Compaq
   Function   Data Type                          Tru64 UNIX
   Name       Required    OpenVMS Alpha          Alpha

   unordered  S_FLOAT     math$unordered_s       unorderedf
              T_FLOAT     math$unordered_t       unordered
              X_FLOAT     math$unordered_x       unorderedl
              F_FLOAT     math$unordered_f
              G_FLOAT     math$unordered_g
 

3  Exceptions
   None.