FTYPE(3F)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)
Page 1
FTYPE(3F)FTYPE(3F)
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)
Page 2
FTYPE(3F)FTYPE(3F)
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.
Page 3
FTYPE(3F)FTYPE(3F)
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.
Page 4
