ftype(3F)

NAME
     ftype: int, ifix, iifix, jifix, idint, iqint, real, float, floati,
     floatj, sngl, dble, dfloti, dflotj, dfloat, qfloat, qfloti, qflotj,
     qflotk, cmplx, dcmplx, qcmplx, ichar, char - explicit FORTRAN type
     conversion

SYNOPSIS
     integer i, j
     real r, s
     double precision dp, dq
     real*16 qp, qq
     complex cx, cy, cz
     double complex dcx, dcy, dcz
     complex*32 qcx, qcy, qcz
     character*1 ch
     integer*1 i1
     integer*2 ii
     integer*4 ji
     integer*8 ki
     real*4 r1

     i = int(j)
     i = int(r)
     i = int(dp)
     i = int(qp)
     i = int(cx)
     i = int(qcx)
     i = ifix(r)
     ii = iifix(r1)
     ji = jifix(r1)
     i = idint(dp)
     i = iqint(qp)

     r = real(i1)
     r = real(i)
     r = real(dp)
     r = real(qp)
     r = real(cx)
     r = real(dcx)
     r = real(qcx)
     r = real(s)
     r = float(i)
     r1 = floati(ii)
     r1 = floatj(ji)
     r = sngl(i)
     r = sngl(dp)
     r = sngl(qp)
     r = sngl(cx)
     r = sngl(dcx)
     r = sngl(qcx)
     r = sngl(s)

     dp = dble(i)
     dp = dble(r)
     dp = dble(dq)
     dp = dble(qq)
     dp = dble(cx)
     dp = dble(dcx)
     dp = dble(qcx)
     dp = dfloat(r)
     dp = dfloat(dp)
     dp = dfloat(qp)
     dp = dfloat(cx)
     dp = dfloat(dcx)
     dp = dfloat(qcx)
     dp = dfloti(ii)
     dp = dflotj(ji)

     qp = qfloat(r)
     qp = qfloat(dp)
     qp = qfloat(qp)
     qp = qfloat(cx)
     qp = qfloat(dcx)
     qp = qfloat(qcx)
     qp = qfloti(ii)
     qp = qflotj(ji)
     qp = qflotk(ki)

     cx = cmplx(i)
     cx = cmplx(i, j)
     cx = cmplx(r)
     cx = cmplx(r, s)
     cx = cmplx(dp)
     cx = cmplx(dp, dq)
     cx = cmplx(qp)
     cx = cmplx(qp, qq)
     cx = cmplx(cy)
     cx = cmplx(cy, cz)
     cx = cmplx(dcx)
     cx = cmplx(dcx, dcy)
     cx = cmplx(qcx)
     cx = cmplx(qcx, qcy)

     dcx = dcmplx(i)
     dcx = dcmplx(i, j)
     dcx = dcmplx(r)
     dcx = dcmplx(r, s)
     dcx = dcmplx(dp)
     dcx = dcmplx(dp, dq)
     dcx = dcmplx(qp)
     dcx = dcmplx(qp, qq)
     dcx = dcmplx(cx)
     dcx = dcmplx(cx, cy)
     dcx = dcmplx(dcy)
     dcx = dcmplx(dcy, dcz)
     dcx = dcmplx(qcy)
     dcx = dcmplx(qcy, qcz)

     qcx = qcmplx(i)
     qcx = qcmplx(i, j)
     qcx = qcmplx(r)
     qcx = qcmplx(r, s)
     qcx = qcmplx(dp)
     qcx = qcmplx(dp, dq)
     qcx = qcmplx(qp)
     qcx = qcmplx(qp, qq)
     qcx = qcmplx(cx)
     qcx = qcmplx(cx, cy)
     qcx = qcmplx(dcy)
     qcx = qcmplx(dcy, dcz)
     qcx = qcmplx(qcy)
     qcx = qcmplx(qcy, qcz)

     i = ichar(ch)
     ch = char(i)

DESCRIPTION
     These functions perform conversion from one data type to another.

     The function int converts to integer from its integer, real*4, double
     precision, real*16, complex, double complex, or complex*32 argument.  If
     the argument is real, integer, real*4, double precision, or real*16 int
     returns the integer whose magnitude is the largest integer that does not
     exceed the magnitude of the argument and whose sign is the same as the
     sign of the argument (i.e. truncation). For complex the above rule is
     applied to the real part.  ifix converts only real arguments.  int and
     ifix return result type integer*2 if the -i2 option is in effect;
     otherwise, the result type is integer*4.  iifix and jifix convert only
     real*4 to integer*2 and integer*4, respectively.  idint converts double
     precision arguments only.  iqint converts real*16 arguments only.

     The function real converts to real from an integer, integer*1, integer*2,
     integer*4, real, double precision, real*16, complex, double complex, or
     complex*32 argument.  If the argument is double precision or real*16, as
     much precision is kept as is possible. If the argument is complex, the
     real part is returned.  float converts integer arguments only.  floati
     and floatj convert integer*2 and integer*4 arguments respectively to
     real*4.  sngl converts integer, real, double, real*16, complex, double
     complex, and complex*32 arguments to real.

     The function dble converts any integer, real, double, real*16, complex,
     double complex, complex*32, integer*2 or integer*4 argument to double
     precision form.  If the argument is complex, the real part is returned.
     dfloat converts real, double, real*16, complex, double complex, and
     complex*32 to double.  dfloti and dflotj convert integer*2 and integer*4
     to real*8.
     qfloti, qflotj, and qflotk convert integer*2, integer*4,  and integer*8
     to real*16.

     The function cmplx converts its integer, real, double precision, real*16,
     double complex, or complex*32 argument(s) to complex form.

     The function dcmplx converts to double complex form its integer, real,
     double precision, real*16, complex, or complex*32 argument(s).

     The function qcmplx converts to complex*32 form its integer, real, double
     precision, real*16, complex, or double complex argument(s).

     Either one or two arguments may be supplied to cmplx, dmplx, and qcmplx .
     If there is only one argument, it is taken as the real part of the
     complex type and an imaginary part of zero is supplied. If two arguments
     are supplied, the first is taken as the real part and the second as the
     imaginary part.

     The function ichar converts from a character to an integer depending on
     the character's position in the collating sequence.  ichar returns the
     result type integer*2 if the -i2 compile option is in effect; otherwise
     the result type is integer*4.

     The function char returns the character in the ith position in the
     processor collating sequence where i is the supplied argument.