FTYPE(3F) FTYPE(3F)
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
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)
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
DBLE(3M) Last changed: 1-6-98
DBLE, DFLOAT - Converts to type double precision
DBLE ([A=]a)
UNICOS, UNICOS/mk, and IRIX systems:
DFLOAT ([A=]a)
UNICOS, UNICOS/mk, and IRIX systems
DBLE: Fortran 90 standard
DFLOAT is a compiler extension to Fortran 90.
These functions convert specified types to double precision type.
DBLE and DFLOAT are elemental functions for the CF90 compiler.
arg or a can be of type complex, integer, real, or double precision.
Argument Range [Toc] [Back]
DBLE:
Real, and double precision:
2450
|x|< infinity (infinity is approximately 10 )
On UNICOS/mk systems and on CRAY T90 systems that support IEEE
arithmetic:
308
infinity is approximately 10
Complex:
|x | < infinity; for complex arguments, x =x + ix .
r r i
Integer:
63
|x| < 2
DFLOAT:
63
|x| < 2
The name of this intrinsic cannot be passed as an argument.
DBLE returns the double-precision equivalent of its complex, integer,
real, or double-precision argument.
DFLOAT returns the double-precision floating-point equivalent of its
integer argument.
Intrinsic Procedures Reference Manual, publication SR-2138, for the
printed version of this man page.
DBLE(3M) Last changed: 1-6-98
DBLE, DFLOAT - Converts to type double precision
DBLE ([A=]a)
UNICOS, UNICOS/mk, and IRIX systems:
DFLOAT ([A=]a)
UNICOS, UNICOS/mk, and IRIX systems
DBLE: Fortran 90 standard
DFLOAT is a compiler extension to Fortran 90.
These functions convert specified types to double precision type.
DBLE and DFLOAT are elemental functions for the CF90 compiler.
arg or a can be of type complex, integer, real, or double precision.
Argument Range [Toc] [Back]
DBLE:
Real, and double precision:
2450
|x|< infinity (infinity is approximately 10 )
On UNICOS/mk systems and on CRAY T90 systems that support IEEE
arithmetic:
308
infinity is approximately 10
Complex:
|x | < infinity; for complex arguments, x =x + ix .
r r i
Integer:
63
|x| < 2
DFLOAT:
63
|x| < 2
The name of this intrinsic cannot be passed as an argument.
DBLE returns the double-precision equivalent of its complex, integer,
real, or double-precision argument.
DFLOAT returns the double-precision floating-point equivalent of its
integer argument.
Intrinsic Procedures Reference Manual, publication SR-2138, for the
printed version of this man page.
[ Back ]
|
