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.
1 – acos()
Interface
F_TYPE acos (F_TYPE x)
F_TYPE acosd (F_TYPE x)
1.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
1.2 – Exceptions
Exceptional Argument Routine Behavior
|x|>1 Invalid argument
2 – acosh()
Interface
F_TYPE acosh (F_TYPE x)
2.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
2.2 – Exceptions
Exceptional Argument Routine Behavior
x<1 Invalid argument
3 – asin()
Interface
F_TYPE asin (F_TYPE x)
F_TYPE asind (F_TYPE x)
3.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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.2 – Exceptions
Exceptional Argument Routine Behavior
|x|>1 Invalid argument
4 – asinh()
Interface
F_TYPE asinh (F_TYPE x)
4.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
4.2 – Exceptions
None.
5 – atan()
Interface
F_TYPE atan (F_TYPE x)
F_TYPE atand (F_TYPE x)
5.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
5.2 – Exceptions
None.
6 – atan2()
Interface
F_TYPE atan2 (F_TYPE y, F_TYPE x)
F_TYPE atand2 (F_TYPE y, F_TYPE x)
6.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
6.2 – Exceptions
Exceptional Argument Routine Behavior
y = x = 0 Invalid argument
|y| = infinity and Invalid argument
|x| = infinity
7 – atanh()
Interface
F_TYPE atanh (F_TYPE x)
7.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
7.2 – Exceptions
Exceptional Argument Routine Behavior
|x| > or = 1 Invalid argument
8 – 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)
8.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
8.2 – 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.
9 – cabs()
Interface
F_TYPE cabs (F_TYPE x, F_TYPE y)
9.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
9.2 – 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
10 – cbrt()
Interface
F_TYPE cbrt (F_TYPE x)
10.1 – Description
cbrt() returns the cube root of x.
Entry-Point Names
Generic
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
10.2 – Exceptions
None.
11 – ccos()
Interface
F_COMPLEX ccos (F_TYPE x, F_TYPE y)
11.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
11.2 – 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
12 – cdiv()
Interface
F_COMPLEX cdiv (F_TYPE a, F_TYPE b, F_TYPE c, F_TYPE d)
12.1 – Description
cdiv() returns the quotient of two complex numbers: (a + ib)/(c +
id).
Entry-Point Names
Generic
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
12.2 – Exceptions
Exceptional Argument Routine Behavior
c=d=0 Invalid argument
The quotient may overflow.
13 – ceil()
Interface
F_TYPE ceil (F_TYPE x)
13.1 – Description
ceil() returns the smallest floating-point number of integral
value greater than or equal to x.
Entry-Point Names
Generic
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
13.2 – Exceptions
None.
14 – cexp()
Interface
F_COMPLEX cexp (F_TYPE x, F_TYPE y)
14.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
14.2 – 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
15 – clog()
Interface
F_COMPLEX clog (F_TYPE x, F_TYPE y)
15.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
15.2 – Exceptions
Exceptional Argument Routine Behavior
y=x=0 Invalid argument
|y|=|x|=infinity Invalid argument
16 – cmul()
Interface
F_COMPLEX cmul (F_TYPE a, F_TYPE b, F_TYPE c, F_TYPE d)
16.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
16.2 – Exceptions
None.
17 – copysign()
Interface
F_TYPE copysign (F_TYPE x, F_TYPE y)
17.1 – Description
copysign() returns x with the same sign as y. IEEE Std 754
requires copysign(x,NaN) = +x or -x.
Entry-Point Names
Generic
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
17.2 – Exceptions
None.
18 – cos()
Interface
F_TYPE cos (F_TYPE x)
F_TYPE cosd (F_TYPE x)
18.1 – Description
cos() computes the cosine of x, measured in radians.
cosd() computes the cosine of x, measured in degrees.
Entry-Point Names
Generic
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
18.2 – Exceptions
Exceptional Argument Routine Behavior
|x| = infinity Invalid argument
19 – cosh()
Interface
F_TYPE cosh (F_TYPE x)
19.1 – Description
cosh() computes the hyperbolic cosine of x.
cosh(x) is defined as (exp(x) + exp(-x))/2.
Entry-Point Names
Generic
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
19.2 – 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
20 – cot()
Interface
F_TYPE cot (F_TYPE x)
F_TYPE cotd (F_TYPE x)
20.1 – Description
cot() computes the cotangent of x, measured in radians.
cotd() computes the cotangent of x, measured in degrees.
Entry-Point Names
Generic
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
20.2 – Exceptions
Exceptional Argument Routine Behavior
(cot) x=0 Overflow
(cotd) |x| = multiples of 180 degrees Overflow
21 – cpow()
Interface
F_COMPLEX cpow (F_TYPE a, F_TYPE b, F_TYPE c, F_TYPE d)
21.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
21.2 – 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
22 – csin()
Interface
F_COMPLEX csin (F_TYPE x, F_TYPE y)
22.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
22.2 – 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
23 – csqrt()
Interface
F_COMPLEX csqrt (F_TYPE x, F_TYPE y)
23.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
23.2 – Exceptions
None.
24 – drem()
Interface
F_TYPE drem (F_TYPE x, F_TYPE y)
24.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
24.2 – Exceptions
Exceptional Argument Routine Behavior
x = infinity Invalid argument
Note that rem(x,0) has value 0 and is not an exceptional case.
25 – erf()
Interface
F_TYPE erf (F_TYPE x)
F_TYPE erfc (F_TYPE x)
25.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
25.2 – Exceptions
The erfc() function can result in an underflow as x gets large.
26 – exp()
Interface
F_TYPE exp (F_TYPE x)
F_TYPE expm1 (F_TYPE x)
26.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
26.2 – 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
27 – fabs()
Interface
F_TYPE fabs (F_TYPE x)
27.1 – Description
fabs() computes the absolute value of x.
Entry-Point Names
Generic
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
27.2 – Exceptions
None.
28 – finite()
Interface
int finite (F_TYPE x)
28.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
28.2 – Exceptions
None.
29 – floor()
Interface
F_TYPE floor (F_TYPE x)
29.1 – Description
floor() returns the largest floating-point number of integral
value less than or equal to x.
Entry-Point Names
Generic
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
29.2 – Exceptions
None.
30 – fmod()
Interface
F_TYPE fmod (F_TYPE x, F_TYPE y)
30.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
30.2 – Exceptions
Exceptional Argument Routine Behavior
x = infinity Invalid argument
Note that fmod(x,0) has value 0 and is not an exceptional case.
31 – fp_class()
Interface
int fp_class (F_TYPE x)
31.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
31.2 – Exceptions
None.
32 – frexp()
Interface
F_TYPE frexp (F_TYPE x, int *n)
32.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
32.2 – Exceptions
None.
33 – hypot()
Interface
F_TYPE hypot (F_TYPE x, F_TYPE y)
33.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
33.2 – 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
34 – ilogb()
Interface
int ilogb (F_TYPE x)
34.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
34.2 – Exceptions
None.
35 – isnan()
Interface
int isnan (F_TYPE x)
35.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
35.2 – Exceptions
None.
36 – ldexp()
Interface
F_TYPE ldexp (F_TYPE x, int n)
36.1 – Description
ldexp() multiplies a floating-point number, x, by 2**n.
Entry-Point Names
Generic
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
36.2 – 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
37 – lgamma()
Interface
F_TYPE lgamma (F_TYPE x)
37.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
37.2 – 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
38 – 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)
38.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
38.2 – Exceptions
Exceptional Argument Routine Behavior
x < 0 Invalid argument
x = 0 Overflow
1+y < 0 Invalid argument
1+y = 0 Overflow
39 – logb()
Interface
F_TYPE logb (F_TYPE x)
39.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
39.2 – Exceptions
Exceptional Argument Routine Behavior
x = 0 Invalid argument
40 – modf()
Interface
F_TYPE modf (F_TYPE x, F_TYPE *n)
40.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
40.2 – Exceptions
None.
41 – nextafter()
Interface
F_TYPE nextafter (F_TYPE x, F_TYPE y)
41.1 – Description
nextafter() returns the machine-representable number next to x in
the direction y.
Entry-Point Names
Generic
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
41.2 – 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
42 – nint()
Interface
F_TYPE nint (F_TYPE x)
42.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
42.2 – Exceptions
None.
43 – pow()
Interface
F_TYPE pow (F_TYPE x, F_TYPE y)
43.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
43.2 – 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
44 – random()
Interface
F_TYPE random (int *n)
44.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
random S_FLOAT math$random_l_s
T_FLOAT
X_FLOAT
F_FLOAT math$random_l_f
G_FLOAT
44.2 – Exceptions
None.
45 – remainder()
Interface
F_TYPE remainder (F_TYPE x, F_TYPE y)
45.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
45.2 – Exceptions
Exceptional Argument Routine Behavior
x = infinity Invalid argument
Note that rem(x,0) has value 0 and is not an exceptional case.
46 – rint()
Interface
F_TYPE rint (F_TYPE x)
46.1 – Description
rint() rounds x to an integral value according to the current
IEEE rounding direction specified by the user.
Entry-Point Names
Generic
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
46.2 – Exceptions
None.
47 – scalb()
Interface
F_TYPE scalb (F_TYPE x, F_TYPE y)
47.1 – Description
scalb() = x*(2**y) computed, for integer-valued floating point
number y.
Entry-Point Names
Generic
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
47.2 – 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
48 – sin()
Interface
F_TYPE sin (F_TYPE x)
F_TYPE sind (F_TYPE x)
48.1 – Description
sin() computes the sine of x, measured in radians.
sind() computes the sine of x, measured in degrees.
Entry-Point Names
Generic
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
48.2 – 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
49 – sinh()
Interface
F_TYPE sinh (F_TYPE x)
49.1 – Description
sinh() computes the hyperbolic sine of x.
sinh(x) is defined as (exp(x)-exp(-x))/2.
Entry-Point Names
Generic
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
49.2 – 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
50 – sqrt()
Interface
F_TYPE sqrt (F_TYPE x)
50.1 – Description
sqrt() computes the rounded square root of x.
For platforms supporting a signed zero, sqrt(-0) = 0.
Entry-Point Names
Generic
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
50.2 – Exceptions
Exceptional Argument Routine Behavior
x < 0 Invalid argument
51 – tan()
Interface
F_TYPE tan (F_TYPE x)
F_TYPE tand (F_TYPE x)
51.1 – Description
tan() computes the tangent of x, measured in radians.
tand() computes the tangent of x, measured in degrees.
Entry-Point Names
Generic
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
51.2 – 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
52 – tanh()
Interface
F_TYPE tanh (F_TYPE x)
52.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
52.2 – Exceptions
None.
53 – trunc()
Interface
F_TYPE trunc (F_TYPE x)
53.1 – Description
trunc() truncates x to an integral value.
Entry-Point Names
Generic
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
53.2 – Exceptions
None.
54 – unordered()
Interface
int unordered (F_TYPE x, F_TYPE y)
54.1 – 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
Function Data Type OpenVMS Tru64 UNIX
Name Required
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
54.2 – Exceptions
None.