ABS (number)A function that returns the absolute value of the argument. The absolute value of a complex number, (X,Y), is the real value: (X**2 + Y**2)**(1/2).
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | ABS | -- | INTEGER*1 | INTEGER*1 | | | | IIABS | INTEGER*2 | INTEGER*2 | | | | JIABS | INTEGER*4 | INTEGER*4 | | |see note | KIABS | INTEGER*8 | INTEGER*8 | | | | ABS | REAL*4 | REAL*4 | | | | DABS | REAL*8 | REAL*8 | | |see note | QABS | REAL*16 | REAL*16 | | | | CABS | COMPLEX*8 | REAL*4 | | | | CDABS | COMPLEX*16 | REAL*8 | | | | ZABS | COMPLEX*16 | REAL*8 | +------+---------+----------+------------+-------------+
NOTE: KIABS is only available on AXP systems. QABS is not available in DEC Fortran.
See also the IABS intrinsic function.
ACOS (number)A function that returns the arc cosine of the argument in radians. The absolute value of the argument must be less than or equal to 1.
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | ACOS | ACOS | REAL*4 | REAL*4 | | | | DACOS | REAL*8 | REAL*8 | | |see note | QACOS | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
NOTE: QACOS is not available in DEC Fortran.
ACOSD (real-number)A function that returns the arc cosine of the argument in degrees. The value of the argument must be between 0 (exclusive) and 1 (inclusive).
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | ACOSD | ACOSD | REAL*4 | REAL*4 | | | | DACOSD | REAL*8 | REAL*8 | | |see note | QACOSD | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
NOTE: QACOSD is not available in DEC Fortran.
AIMAG (complex-number)A function that returns the imaginary part of a complex number. The argument must be a COMPLEX*8 data type. The result is a REAL*4 data type.
The setting of -r8 affects AIMAG.
AINT (real-number)A function that returns the largest integer whose absolute value does not exceed the absolute value of the argument and has the same sign as the argument.
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | AINT | AINT | REAL*4 | REAL*4 | | | | DINT | REAL*8 | REAL*8 | | |see note | QINT | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
NOTE: QINT is not available in DEC Fortran.
See also the INT intrinsic function.
AMAX0 (number, number, ...)A function that returns the greatest of the values specified in the argument list. There must be at least two arguments.
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | n | AMAX0 | -- | INTEGER*1 | REAL*4 | | | | AIMAX0 | INTEGER*2 | REAL*4 | | | | AJMAX0 | INTEGER*4 | REAL*4 | | |see note | AKMAX0 | INTEGER*8 | REAL*4 | +------+---------+----------+------------+-------------+
NOTE: AKMAX0 is only available on AXP systems. See also the MAX intrinsic function.
AMIN0 (number, number, ...)A function that returns the lowest of the values specified in the argument list. There must be at least two arguments.
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | n | AMIN0 | -- | INTEGER*1 | REAL*4 | | | | AIMIN0 | INTEGER*2 | REAL*4 | | | | AJMIN0 | INTEGER*4 | REAL*4 | | |see note | AKMIN0 | INTEGER*8 | REAL*4 | +------+---------+----------+------------+-------------+
NOTE: AKMIN0 is only available on AXP systems. See also the MIN intrinsic function.
ANINT (real-number)A function that returns the value of the integer nearest to the value of the argument.
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | ANINT | ANINT | REAL*4 | REAL*4 | | | | DNINT | REAL*8 | REAL*8 | | |see note | QNINT | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
NOTE: QNINT is not available in DEC Fortran.
[x] is defined as the largest integer whose magnitude does not exceed the magnitude of x and whose sign is the same as that of x.
See also the NINT intrinsic function.
ASIN (real-number)A function that returns the arc sine of the argument in radians. The absolute value of the argument must be less than or equal to 1.
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | ASIN | ASIN | REAL*4 | REAL*4 | | | | DASIN | REAL*8 | REAL*8 | | |see note | QASIN | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
NOTE: QASIN is not available in DEC Fortran.
ASIND (real-number)A function that returns the arc sine of the argument in degrees. The value of the argument must be between 0 (exclusive) and 1 (inclusive).
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | ASIND | ASIND | REAL*4 | REAL*4 | | | | DASIND | REAL*8 | REAL*8 | | |see note | QASIND | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
NOTE: QASIND is not available in DEC Fortran.
ATAN (real-number)A function that returns the arc tangent of the argument in radians.
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | ATAN | ATAN | REAL*4 | REAL*4 | | | | DATAN | REAL*8 | REAL*8 | | |see note | QATAN | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
NOTE: QATAN is not available in DEC Fortran.
ATAND (real-number)A function that returns the arc tangent of the argument in degrees. The value of the argument must be greater than 0.
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | ATAND | ATAND | REAL*4 | REAL*4 | | | | DATAND | REAL*8 | REAL*8 | | |see note | QATAND | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
NOTE: QATAND is not available in DEC Fortran.
ATAN2 (real-number, real-number)A function that returns the arc tangent of the quotient of the two arguments in radians. If both arguments are zero, the result is undefined. If the first argument is positive, the result is positive. If the first argument is negative, the result is negative. If the first argument is zero, the result is zero. If the second argument is zero, the absolute value of the result is pi/2.
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | ATAN2 | ATAN2 | REAL*4 | REAL*4 | | | | DATAN2 | REAL*8 | REAL*8 | | |see note | QATAN2 | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
NOTE: QATAN2 is not available in DEC Fortran.
The range of the result is -pi < result <= pi.
ATAN2D (real-number, real-number)A function that returns the arc tangent of the quotient of the two arguments in degrees. If both arguments are zero, the result is undefined. If the first argument is positive, the result is positive. If the first argument is negative, the result is negative. If the first argument is zero, the result is zero. If the second argument is zero, the absolute value of the result is 90 degrees. The value of the argument must be greater than zero.
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | ATAN2D | ATAN2D | REAL*4 | REAL*4 | | | | DATAN2D | REAL*8 | REAL*8 | | |see note | QATAN2D | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
NOTE: QATAN2D is not available in DEC Fortran.
The range of the result is -180 degrees < result <= 180 degrees.
BTEST (integer, position)A function that returns a logical value of true if the bit within the integer specified by position is set to 1 (bit test). The low-order bit is position 0.
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | BTEST | -- | INTEGER*1 | LOGICAL*4 | | | | BITEST | INTEGER*2 | LOGICAL*2 | | | | BJTEST | INTEGER*4 | LOGICAL*4 | | |see note | BKTEST | INTEGER*8 | LOGICAL*8 | +------+---------+----------+------------+-------------+
NOTE: BKTEST is only available on AXP systems.
CHAR (integer)A function that returns the character that has the numeric value specified by the argument. The input value must be in the range 0 to 255.
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | -- | CHAR | LOGICAL*1 | CHARACTER | | | | -- | INTEGER*1 | CHARACTER | | | | -- | INTEGER*2 | CHARACTER | | | | -- | INTEGER*4 | CHARACTER | | |see note | -- | INTEGER*8 | CHARACTER | +------+---------+----------+------------+-------------+
NOTE: INTEGER*8 is only available on AXP systems.
CMPLX (number [,number])A function that converts the argument(s) into a COMPLEX*8 value. If one argument is specified, the argument is converted into the real part of the complex value and the imaginary part becomes zero. If two arguments are specified, the first argument is converted into the real part of the complex value and the second argument is converted into the imaginary part of the complex value. If two arguments are specified, they must have the same data type.
+------+-----------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+-----------+----------+------------+-------------+ | 1,2 | CMPLX | -- | INTEGER*1 | COMPLEX*8 | | 1,2 | | -- | INTEGER*2 | COMPLEX*8 | | 1,2 | | -- | INTEGER*4 | COMPLEX*8 | | 1,2 |see note 1 | -- | INTEGER*8 | COMPLEX*8 | | 1,2 | | -- | REAL*4 | COMPLEX*8 | | 1,2 | | -- | REAL*8 | COMPLEX*8 | | 1,2 |see note 2 | -- | REAL*16 | COMPLEX*8 | | 1 | | -- | COMPLEX*8 | COMPLEX*8 | | 1 | | -- | COMPLEX*16 | COMPLEX*8 | +------+-----------+----------+------------+-------------+
NOTE 1: This argument type is only available on AXP systems. NOTE 2: This argument type is not available in DEC Fortran.
The setting of -r8 affects CMPLX.
CONJG (complex-number)A function that returns the complex conjugate of the argument. If the argument is (X,Y), its complex conjugate is (X,-Y).
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | CONJG | CONJG | COMPLEX*8 | COMPLEX*8 | | | | DCONJG | COMPLEX*16 | COMPLEX*16 | +------+---------+----------+------------+-------------+
COS (number)A function that returns the cosine of the argument. The argument must be in radians; it is treated modulo 2*pi.
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | COS | COS | REAL*4 | REAL*4 | | | | DCOS | REAL*8 | REAL*8 | | |see note | QCOS | REAL*16 | REAL*16 | | | | CCOS | COMPLEX*8 | COMPLEX*8 | | | | CDCOS | COMPLEX*16 | COMPLEX*16 | | | | ZCOS | COMPLEX*16 | COMPLEX*16 | +------+---------+----------+------------+-------------+
NOTE: QCOS is not available in DEC Fortran.
COSD (number)A function that returns the cosine of the argument. The argument must be in degrees; it is treated modulo 360.
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | COSD | COSD | REAL*4 | REAL*4 | | | | DCOSD | REAL*8 | REAL*8 | | |see note | QCOSD | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
NOTE: QCOSD is not available in DEC Fortran.
COSH (real-number)A function that returns the hyperbolic cosine of the argument.
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | COSH | COSH | REAL*4 | REAL*4 | | | | DCOSH | REAL*8 | REAL*8 | | |see note | QCOSH | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
NOTE: QCOSH is not available in DEC Fortran.
CALL DATE (buf)buf Is a 9-byte variable, array, array element, or character substring.
A subroutine that gets the current date as set within the system. The date is returned as a 9-byte ASCII character string as follows:
dd-mmm-yy
If "buf" is numeric type and smaller than 9 bytes, data corruption can occur.
If "buf" is character type, its associated length is passed to the subroutine. If "buf" is smaller than 9 bytes, the subroutine truncates the date to fit in the specified length. Note that if a CHARACTER array is passed, the subroutine stores the date in the first array element, using the element length, not the length of the entire array. For example, consider the following:
CHARACTER*1 DAY(9) . . . CALL DATE(DAY)
The length of the first array element in CHARACTER array DAY is passed to the DATE subroutine. The subroutine then truncates the date to fit into the one-character element, producing an incorrect result.
DBLE (number)A function that converts the argument into a REAL*8 value.
+------+-----------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+-----------+----------+------------+-------------+ | 1 | DBLE | -- | INTEGER*1 | REAL*8 | | | | -- | INTEGER*2 | REAL*8 | | | | -- | INTEGER*4 | REAL*8 | | |see note 1 | -- | INTEGER*8 | REAL*8 | | | | DBLE | REAL*4 | REAL*8 | | | | -- | REAL*8 | REAL*8 | | |see note 2 | DBLEQ | REAL*16 | REAL*8 | | | | -- | COMPLEX*8 | REAL*8 | | | | -- | COMPLEX*16 | REAL*8 | +------+-----------+----------+------------+-------------+
NOTE 1: This argument type is only available on AXP systems. NOTE 2: DBLEQ is not available in DEC Fortran.
DCMPLX (number [,number])A function that converts the argument(s) into a COMPLEX*16 value. If one argument is specified, the argument is converted into the real part of the complex value and the imaginary part becomes zero. If two arguments are specified, the first argument is converted into the real part of the complex value and the second argument is converted into the imaginary part of the complex value. If two arguments are specified, they must have the same data type.
+-------+----------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +-------+----------+----------+------------+-------------+ | 1,2 | DCMPLX | -- | INTEGER*1 | COMPLEX*16 | | 1,2 | | -- | INTEGER*2 | COMPLEX*16 | | 1,2 | | -- | INTEGER*4 | COMPLEX*16 | | 1,2 |see note 1| -- | INTEGER*8 | COMPLEX*16 | | 1,2 | | -- | REAL*4 | COMPLEX*16 | | 1,2 | | -- | REAL*8 | COMPLEX*16 | | 1,2 |see note 2| -- | REAL*16 | COMPLEX*16 | | 1 | | -- | COMPLEX*8 | COMPLEX*16 | | 1 | | -- | COMPLEX*16 | COMPLEX*16 | +-------+----------+----------+------------+-------------+
NOTE 1: INTEGER*8 is only available on AXP systems. NOTE 2: This argument type is not available in DEC Fortran.
DFLOAT (integer)A function that converts the argument into a REAL*8 value.
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | DFLOAT | -- | INTEGER*1 | REAL*8 | | | | DFLOTI | INTEGER*2 | REAL*8 | | | | DFLOTJ | INTEGER*4 | REAL*8 | | |see note | DFLOATK | INTEGER*8 | REAL*8 | +------+---------+----------+------------+-------------+
NOTE: DFLOATK is only available on AXP systems.
DIM (number, number)A function that returns the value of the first argument minus the minimum (MIN) of the two arguments.
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | DIM | -- | INTEGER*1 | INTEGER*1 | | | | IIDIM | INTEGER*2 | INTEGER*2 | | | | JIDIM | INTEGER*4 | INTEGER*4 | | |see note | KIDIM | INTEGER*8 | INTEGER*8 | | | | DIM | REAL*4 | REAL*4 | | | | DDIM | REAL*8 | REAL*8 | | |see note | QDIM | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
NOTE: KIDIM is only available on AXP systems. QDIM is not available in DEC Fortran.
See also the IDIM intrinsic function.
DIMAG (imaginary)A function that returns the imaginary part of a complex number. The argument must be a COMPLEX*16 data type. The result is a REAL*8 data type.
DPROD (real4-number, real4-number)A function that returns the product of two REAL*4 values as a REAL*8 value.
DREAL (complex-number)A function that returns the real part of a complex number. The argument must be a COMPLEX*16 data type. The result is a REAL*8 data type.
CALL EXIT [(exit-status)]A subroutine that terminates the program, closes all files, and returns control to the operating system. The optional argument specifies the exit-status value of the program.
EXP (exponent)A function that returns e**X, where X is the value of the argument.
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | EXP | EXP | REAL*4 | REAL*4 | | | | DEXP | REAL*8 | REAL*8 | | |see note | QEXP | REAL*16 | REAL*16 | | | | CEXP | COMPLEX*8 | COMPLEX*8 | | | | CDEXP | COMPLEX*16 | COMPLEX*16 | | | | ZEXP | COMPLEX*16 | COMPLEX*16 | +------+---------+----------+------------+-------------+
NOTE: QEXP is not available in DEC Fortran.
FLOAT (integer)A function that converts the argument to a REAL*4 value.
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | FLOAT | -- | INTEGER*1 | REAL*4 | | | | FLOATI | INTEGER*2 | REAL*4 | | | | FLOATJ | INTEGER*4 | REAL*4 | | |see note | FLOATK | INTEGER*8 | REAL*4 | +------+---------+----------+------------+-------------+
NOTE: FLOATK is only available on AXP systems.
The setting of -r8 affects FLOAT.
IABS (number)A function that returns the absolute value of the argument. The absolute value of a complex number, (X,Y), is the real value SQRT(X**2 + Y**2).
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | IABS | -- | INTEGER*1 | INTEGER*1 | | | | IIABS | INTEGER*2 | INTEGER*2 | | | | JIABS | INTEGER*4 | INTEGER*4 | | |see note | KIABS | INTEGER*8 | INTEGER*8 | +------+---------+----------+------------+-------------+
NOTE: KIABS is only available on AXP systems. See also the ABS intrinsic function.
IAND (integer, integer)A function that performs a logical AND of the arguments on a bit by bit basis (bitwise AND).
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | IAND | -- | INTEGER*1 | INTEGER*1 | | | | IIAND | INTEGER*2 | INTEGER*2 | | | | JIAND | INTEGER*4 | INTEGER*4 | | |see note | KIAND | INTEGER*8 | INTEGER*8 | +------+---------+----------+------------+-------------+
NOTE: KIAND is only available on AXP systems.
IBCLR (integer, position)A function that returns the value of the first argument with the specified bit set to 0 (bit clear). The low-order bit is position 0.
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | IBCLR | -- | INTEGER*1 | INTEGER*1 | | | | IIBCLR | INTEGER*2 | INTEGER*4 | | | | JIBCLR | INTEGER*4 | INTEGER*4 | | |see note | KIBCLR | INTEGER*8 | INTEGER*8 | +------+---------+----------+------------+-------------+
NOTE: KIBCLR is only available on AXP systems.
IBITS (integer, start-position, length)A function that returns the value of the bits specified by start-position and end-position (bit extraction). The low-order bit is position 0.
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 3 | IBITS | -- | INTEGER*1 | INTEGER*1 | | | | IIBITS | INTEGER*2 | INTEGER*4 | | | | JIBITS | INTEGER*4 | INTEGER*4 | | |see note | KIBITS | INTEGER*8 | INTEGER*8 | +------+---------+----------+------------+-------------+
NOTE: KIBITS is only available on AXP systems.
IBSET (integer, position)A function that returns the value of the first argument with the specified bit set to 1 (bit set). The low-order bit is position 0.
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | IBSET | -- | INTEGER*1 | INTEGER*1 | | | | IIBSET | INTEGER*2 | INTEGER*2 | | | | JIBSET | INTEGER*4 | INTEGER*4 | | |see note | KIBSET | INTEGER*8 | INTEGER*8 | +------+---------+----------+------------+-------------+
NOTE: KIBSET is only available on AXP systems.
ICHAR (character)A function that returns the ASCII value of the argument. The argument must be a character expression with a length of one.
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | -- | ICHAR | CHARACTER | INTEGER*2 | | | | -- | CHARACTER | INTEGER*4 | | |see note | -- | CHARACTER | INTEGER*8 | +------+---------+----------+------------+-------------+
NOTE: INTEGER*8 is only available on AXP systems.
CALL IDATE (month,day,year)A subroutine that returns three values representing the current date. The arguments must be defined as integers or integer array elements. The month is represented as the number of the month (1 - 12). The day is represented as the day of the month. The year is represented as the last two digits of the year.
IDIM (number, number)A function that returns the value of the first argument minus the minimum (MIN) of the two arguments.
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | IDIM | -- | INTEGER*1 | INTEGER*1 | | | | IIDIM | INTEGER*2 | INTEGER*2 | | | | JIDIM | INTEGER*4 | INTEGER*4 | | |see note | KIDIM | INTEGER*8 | INTEGER*8 | +------+---------+----------+------------+-------------+
NOTE: KIDIM is only available on AXP systems. See also the DIM intrinsic function.
IDINT (number)A function that returns the largest integer whose absolute value does not exceed the absolute value of the argument and has the same sign as the argument.
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | IDINT | IIDINT | REAL*8 | INTEGER*2 | | | | JIDINT | REAL*8 | INTEGER*4 | | |see note | KIDINT | REAL*4 | INTEGER*8 | +------+---------+----------+------------+-------------+
NOTE: KIDINT is only available on AXP systems.
The setting of -noi4 or -i8 (AXP only) affects IDINT.
See also the INT intrinsic function.
IDNINT (real-number)A function that returns the value of the integer nearest to the value of the argument.
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | IDNINT | IIDNNT | REAL*8 | INTEGER*2 | | | | JIDNNT | REAL*8 | INTEGER*4 | | |see note | KIDNNT | REAL*8 | INTEGER*8 | +------+---------+----------+------------+-------------+
NOTE: KIDNNT is only available on AXP systems.
The setting of -noi4 or -i8 (AXP only) affects IDNINT.
See also the NINT intrinsic function.
IEOR (integer, integer)A function that performs an exclusive OR of the arguments on a bit by bit basis (bit exclusive OR).
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | IEOR | -- | INTEGER*1 | INTEGER*1 | | | | IIEOR | INTEGER*2 | INTEGER*2 | | | | JIEOR | INTEGER*4 | INTEGER*4 | | |see note | KIEOR | INTEGER*8 | INTEGER*8 | +------+---------+----------+------------+-------------+
NOTE: KIEOR is only available on AXP systems.
IFIX (real4-number)A function that converts a real number to an integer.
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | IFIX | IIFIX | REAL*4 | INTEGER*2 | | | | JIFIX | REAL*4 | INTEGER*4 | | |see note | KIFIX | REAL*4 | INTEGER*8 | +------+---------+----------+------------+-------------+
NOTE: KIFIX is only available on AXP systems. The function returns an INTEGER*4 value if the -i4 command option is in effect; otherwise it returns an INTEGER*2 value.
IIFIX can also be spelled HFIX (to comply with the MIA standard).
The setting of -noi4 or -i8 (AXP only) affects IFIX.
IMAG (complex-number)A function that returns the imaginary part of a complex number. +------+-----------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+-----------+----------+------------+-------------+ | 1 | IMAG | AIMAG | COMPLEX*8 | REAL*4 | | | | DIMAG | COMPLEX*16 | REAL*8 | +--------------------------------------------------------+
The setting of -r8 affects AIMAG.
INDEX (string, substring)A function that searches a string for the first occurrence of a substring and returns the starting position of the substring as an INTEGER*4 or INTEGER*8 (AXP only) value.
INT (number)A function that returns the largest integer whose absolute value does not exceed the absolute value of the argument and has the same sign as the argument. +------+-----------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+-----------+----------+------------+-------------+ | 1 | INT | -- | INTEGER*1 | INTEGER*2 | | | | -- | INTEGER*1 | INTEGER*4 | | |see note 1 | -- | INTEGER*1 | INTEGER*8 | | | | -- | INTEGER*2 | INTEGER*4 | | |see note 1 | -- | INTEGER*2 | INTEGER*8 | | | | -- | INTEGER*4 | INTEGER*4 | | |see note 1 | -- | INTEGER*4 | INTEGER*8 | | |see note 1 | -- | INTEGER*8 | INTEGER*8 | | | | IINT | REAL*4 | INTEGER*2 | | | | JINT | REAL*4 | INTEGER*4 | | |see note 2 | KINT | REAL*4 | INTEGER*8 | | | | IIDINT | REAL*8 | INTEGER*2 | | | | JIDINT | REAL*8 | INTEGER*4 | | |see note 2 | KIDINT | REAL*4 | INTEGER*8 | | |see note 3 | IIQINT | REAL*16 | INTEGER*2 | | |see note 3 | JIQINT | REAL*16 | INTEGER*4 | | | | -- | COMPLEX*8 | INTEGER*2 | | | | -- | COMPLEX*8 | INTEGER*4 | | |see note 1 | -- | COMPLEX*8 | INTEGER*8 | | | | -- | COMPLEX*16 | INTEGER*2 | | | | -- | COMPLEX*16 | INTEGER*4 | | |see note 1 | -- | COMPLEX*16 | INTEGER*8 | +------+-----------+----------+------------+-------------+
NOTE 1: INTEGER*8 is only available on AXP systems. NOTE 2: KINT and KIDINT are only available on AXP systems. NOTE 3: IIQINT and JIQINT are not available in DEC Fortran.
The setting of -noi4 or -i8 (AXP only) affects INT.
See also AINT, IDINT, and IQINT.
IOR (integer, integer)A function that performs a logical OR of the arguments on a bit by bit basis (bitwise inclusive OR). +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | IOR | -- | INTEGER*1 | INTEGER*1 | | | | IIOR | INTEGER*2 | INTEGER*2 | | | | JIOR | INTEGER*4 | INTEGER*4 | | |see note | KIOR | INTEGER*8 | INTEGER*8 | +------+---------+----------+------------+-------------+
NOTE: KIOR is only available on AXP systems.
IQINT (number)This function is not available in DEC Fortran.
IQNINT (number)This function is not available in DEC Fortran.
ISHFT (a1,a2)Bitwise logical shift - a1 is an integer, a2 is the no-of-positions
A function that logically shifts a1 left (if a2 is positive) or right (if a2 is negative) by ABS(a2) bits. If ABS(a2) is greater than or equal to the length in bits of a1, the result is 0. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | ISHFT | -- | INTEGER*1 | INTEGER*1 | | | | IISHFT | INTEGER*2 | INTEGER*2 | | | | JISHFT | INTEGER*4 | INTEGER*4 | | |see note | KISHFT | INTEGER*8 | INTEGER*8 | +------+---------+----------+------------+-------------+
NOTE: KISHFT is only available on AXP systems.
ISHFTC (a1,a2,a3)Bitwise circular shift - a1 is an integer, a2 is no-of-positions, and a3 is no-of-bits
A function that circularly shifts the rightmost a3 bits of a1 by a2 places; bits in a1 beyond the value specified by a3 are unaffected. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 3 | ISHFTC | IISHFTC | INTEGER*2 | INTEGER*4 | | | | JISHFTC | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+
ISIGN (value, sign)A function that assigns the sign of the second argument to the absolute value of the first. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | ISIGN | -- | INTEGER*1 | INTEGER*1 | | | | IISIGN | INTEGER*2 | INTEGER*2 | | | | JISIGN | INTEGER*4 | INTEGER*4 | | |see note | KISIGN | INTEGER*8 | INTEGER*8 | +------+---------+----------+------------+-------------+
NOTE: KISIGN is only available on AXP systems. See also the SIGN intrinsic function.
LEN (character)A function that returns the number of characters in the argument. The argument must be a character expression. The result is an INTEGER*4 or INTEGER*8 (AXP only) value.
LGE (character, character)A function that returns a value of true if the first character string is greater than or equal to the second character string. The ASCII collating sequence determines the relationship between the arguments. The arguments must be character expressions. The result is a LOGICAL*4 value.
LGT (character, character)A function that returns a value of true if the first character string is greater than the second character string. The arguments must be character expressions. The ASCII collating sequence determines the relationship between the arguments. The result is a LOGICAL*4 value.
LLE (character, character)A function that returns a value of true if the first character string is less than or equal to the second character string. The arguments must be character expressions. The ASCII collating sequence determines the relationship between the arguments. The result is a LOGICAL*4 value.
LLT (character, character)A function that returns a value of true if the first character string is less than the second character string. The arguments must be character expressions. The ASCII collating sequence determines the relationship between the arguments. The result is a LOGICAL*4 value.
LOG (number)A function that returns the natural log (base e) of the argument. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | LOG | ALOG | REAL*4 | REAL*4 | | | | DLOG | REAL*8 | REAL*8 | | |see note | QLOG | REAL*16 | REAL*16 | | | | CLOG | COMPLEX*8 | COMPLEX*8 | | | | CDLOG | COMPLEX*16 | COMPLEX*16 | | | | ZLOG | COMPLEX*16 | COMPLEX*16 | +------+---------+----------+------------+-------------+
NOTE: QLOG is not available in DEC Fortran.
The argument for ALOG and DLOG must be greater than zero. The argument for CLOG and CDLOG must not be (0.,0.).
LOG10 (number)A function that returns the common log (base 10) of the argument. The argument must be greater than zero. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | LOG10 | ALOG10 | REAL*4 | REAL*4 | | | | DLOG10 | REAL*8 | REAL*8 | | |see note | QLOG10 | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
NOTE: QLOG10 is not available in DEC Fortran.
The argument for ALOG10, DLOG10, and QLOG10 must be greater than zero.
MAX (number, number, ...)A function that returns the greatest of the values specified in the argument list. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | n | MAX | -- | INTEGER*1 | INTEGER*1 | | | | IMAX0 | INTEGER*2 | INTEGER*2 | | | | JMAX0 | INTEGER*4 | INTEGER*4 | | |see note | KMAX0 | INTEGER*8 | INTEGER*8 | | | | AMAX1 | REAL*4 | REAL*4 | | | | DMAX1 | REAL*8 | REAL*8 | | |see note | QMAX1 | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
NOTE: KMAX0 is only available on AXP systems. QMAX1 is not available in DEC Fortran.
See also the AMAX0, MAX0, and MAX1 intrinsic functions.
MAX0 (number, number, ...)A function that returns the greatest of the values specified in the argument list. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | n | MAX0 | -- | INTEGER*1 | INTEGER*1 | | | | IMAX0 | INTEGER*2 | INTEGER*2 | | | | JMAX0 | INTEGER*4 | INTEGER*4 | | |see note | KMAX0 | INTEGER*8 | INTEGER*8 | +------+---------+----------+------------+-------------+
NOTE: KMAX0 is only available on AXP systems. See also the MAX intrinsic function.
MAX1 (number, number, ...)A function that returns the greatest of the values specified in the argument list. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | n | MAX1 | IMAX1 | REAL*4 | INTEGER*2 | | | | JMAX1 | REAL*4 | INTEGER*4 | | |see note | KMAX1 | REAL*4 | INTEGER*8 | +------+---------+----------+------------+-------------+
NOTE: KMAX1 is only available on AXP systems.
The setting of -noi4 or -i8 (AXP only) affects MAX1.
See also the MAX intrinsic function.
MIN (number, number, ...)A function that returns the lowest of the values specified in the argument list. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | n | MIN | -- | INTEGER*1 | INTEGER*1 | | | | IMIN0 | INTEGER*2 | INTEGER*2 | | | | JMIN0 | INTEGER*4 | INTEGER*4 | | |see note | KMIN0 | INTEGER*8 | INTEGER*8 | | | | AMIN1 | REAL*4 | REAL*4 | | | | DMIN1 | REAL*8 | REAL*8 | | |see note | QMIN1 | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
NOTE: KMIN0 is only available on AXP systems. QMIN1 is not available in DEC Fortran.
See also the AMIN0, MIN0, and MIN1 intrinsic functions.
MIN0A function that returns the lowest of the values specified in the argument list. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | n | MIN0 | -- | INTEGER*1 | INTEGER*1 | | | | IMIN0 | INTEGER*2 | INTEGER*2 | | | | JMIN0 | INTEGER*4 | INTEGER*4 | | |see note | KMIN0 | INTEGER*8 | INTEGER*8 | +------+---------+----------+------------+-------------+
NOTE: KMIN0 is only available on AXP systems. See also the MIN intrinsic function.
MIN1A function that returns the lowest of the values specified in the argument list. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | n | MIN1 | IMIN1 | REAL*4 | INTEGER*2 | | | | JMIN1 | REAL*4 | INTEGER*4 | | |see note | KMIN1 | REAL*4 | INTEGER*8 | +------+---------+----------+------------+-------------+
NOTE: KMIN1 is only available on AXP systems.
The setting of -noi4 or -i8 (AXP only) affects MIN1.
See also the MIN intrinsic function.
MOD (dividend, divisor)A function that divides the first argument by the second and returns the remainder. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | MOD | -- | INTEGER*1 | INTEGER*1 | | | | IMOD | INTEGER*2 | INTEGER*2 | | | | JMOD | INTEGER*4 | INTEGER*4 | | |see note | KMOD | INTEGER*8 | INTEGER*8 | | | | AMOD | REAL*4 | REAL*4 | | | | DMOD | REAL*8 | REAL*8 | | |see note | QMOD | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
NOTE: KMOD is only available on AXP systems. QMOD is not available in DEC Fortran.
CALL MVBITS (integer1, start1, len, integer2, start2) A subroutine that moves bits from one location to another. Specify the arguments as follows:integer1 Is an integer variable or array element that contains the bits to be transferred.
start1 Is an integer expression that identifies the position of the first bit within "integer1" to be transferred.
len Is an integer expression that specifies the number of bits to be transferred.
integer2 Is an integer variable or array element that identifies the location to which the bits are being transferred.
start2 Is an integer expression that identifies the starting position within "integer2" for the bits being transferred.
The low-order bit in either integer is position 0. The values of start1+len must be < 32, and start2+len must be <= 32.
NINT (real-number)A function that returns the value of the integer nearest to the value of the argument. +------+-----------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+-----------+----------+------------+-------------+ | 1 | NINT | ININT | REAL*4 | INTEGER*2 | | | | JNINT | REAL*4 | INTEGER*4 | | |see note 1 | KNINT | REAL*4 | INTEGER*8 | | | | IIDNNT | REAL*8 | INTEGER*2 | | | | JIDNNT | REAL*8 | INTEGER*4 | | |see note 1 | KIDNNT | REAL*8 | INTEGER*8 | | |see note 2 | IIQNNT | REAL*16 | INTEGER*2 | | |see note 2 | JIQNNT | REAL*16 | INTEGER*4 | +------+-----------+----------+------------+-------------+
NOTE 1: KNINT and KIDNNT are only available on AXP systems. NOTE 2: IIQNNT and JIQNNT are not available in DEC Fortran.
The setting of -noi4 or -i8 (AXP only) affects NINT.
See also the ANINT, IDNINT, and IQNINT intrinsic functions.
NOT (integer)A function that complements each bit of the argument (bitwise complement). +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | NOT | -- | INTEGER*1 | INTEGER*1 | | | | INOT | INTEGER*2 | INTEGER*2 | | | | JNOT | INTEGER*4 | INTEGER*4 | | |see note | KNOT | INTEGER*8 | INTEGER*8 | +------+---------+----------+------------+-------------+
NOTE: KNOT is only available on AXP systems.
The intrinsic function NWORKERS requires no arguments and returns an INTEGER*4 value that represents the total number of processes executing an application. However, since DEC Fortran only does serial processing, NWORKERS always returns 1.
QEXT (number)This function is not available in DEC Fortran.
QFLOAT (integer)This function is not available in DEC Fortran.
RAN (seed)A function that is a general random number generator of the multiplicative congruential type. This function returns a different REAL*4 number between 0.0 (inclusive) and 1.0 (exclusive) each time it is invoked. The argument must be an INTEGER*4 variable or array element.
For best results, you should initialize the argument to a large, odd value before invoking RAN the first time. To generate different sets of random values, initialize the seed to a different value on each run. Do not modify the seed during a run.
REAL (number)A function that converts the argument to a real value. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | REAL | -- | INTEGER*1 | REAL*4 | | | | FLOATI | INTEGER*2 | REAL*4 | | | | FLOATJ | INTEGER*4 | REAL*4 | | |see note | FLOATK | INTEGER*8 | REAL*4 | | | | -- | REAL*4 | REAL*4 | | | | SNGL | REAL*8 | REAL*4 | | |see note | SNGLQ | REAL*16 | REAL*4 | | | | -- | COMPLEX*8 | REAL*4 | | | | -- | COMPLEX*16 | REAL*4 | +------+---------+----------+------------+-------------+
NOTE: FLOATK is only available on AXP systems. SNGLQ is not available in DEC Fortran.
REAL is also a specific name for a function that returns the real part of a complex number. The argument must be a COMPLEX*8 data type. The result is a REAL*4 data type.
The setting of -r8 affects REAL.
SECNDS (real-number)A function that returns the number of seconds since midnight minus the value of the argument. The argument must be a REAL*4 data type. The return value is a REAL*4 data type. The time returned is accurate to .01 seconds.
SIGN (value, sign)A function that assigns the sign of the second argument to the absolute value of the first. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | SIGN | -- | INTEGER*1 | INTEGER*1 | | | | IISIGN | INTEGER*2 | INTEGER*2 | | | | JISIGN | INTEGER*4 | INTEGER*4 | | |see note | KISIGN | INTEGER*8 | INTEGER*8 | | | | SIGN | REAL*4 | REAL*4 | | | | DSIGN | REAL*8 | REAL*8 | | |see note | QSIGN | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
NOTE: KISIGN is only available on AXP systems. QSIGN is not available in DEC Fortran.
See also the ISIGN intrinsic function.
SIN (number)A function that returns the sine of the argument. The argument must be in radians; it is treated modulo 2*pi. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | SIN | SIN | REAL*4 | REAL*4 | | | | DSIN | REAL*8 | REAL*8 | | |see note | QSIN | REAL*16 | REAL*16 | | | | CSIN | COMPLEX*8 | COMPLEX*8 | | | | CDSIN | COMPLEX*16 | COMPLEX*16 | | | | ZSIN | COMPLEX*16 | COMPLEX*16 | +------+---------+----------+------------+-------------+
NOTE: QSIN is not available in DEC Fortran.
SIND (number)A function that returns the sine of the argument. The argument must be in degrees; it is treated modulo 360. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | SIND | SIND | REAL*4 | REAL*4 | | | | DSIND | REAL*8 | REAL*8 | | |see note | QSIND | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
NOTE: QSIND is not available in DEC Fortran.
SINH (number)A function that returns the hyperbolic sine of the argument. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | SINH | SINH | REAL*4 | REAL*4 | | | | DSINH | REAL*8 | REAL*8 | | |see note | QSINH | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
NOTE: QSINH is not available in DEC Fortran.
SIZEOF (arg)A function that returns the number of bytes of storage used by the argument. +------+---------+----------+------------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------------+-------------+ | 1 | -- | SIZEOF | Anything with a | INTEGER*4 | | | | -- | valid data type, | INTEGER*8 | | | | | except assumed- | | | | | | size arrays or | | | | | | passed-length | | | | | | characters. | | +------+---------+----------+------------------+-------------+
NOTE: A result type of INTEGER*8 is only available on AXP systems.
SNGL (number)A function that converts the argument to a real value. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | REAL | -- | INTEGER*1 | REAL*4 | | | | FLOATI | INTEGER*2 | REAL*4 | | | | FLOATJ | INTEGER*4 | REAL*4 | | |see note | FLOATK | INTEGER*8 | REAL*4 | | | | REAL | REAL*4 | REAL*4 | | | | -- | REAL*8 | REAL*4 | | |see note | SNGLQ | REAL*16 | REAL*4 | +------+---------+----------+------------+-------------+
NOTE: FLOATK is only available on AXP systems. SNGLQ is not available in DEC Fortran.
The setting of -r8 affects SNGL.
SQRT (number)A function that returns the square root of the argument. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | SQRT | SQRT | REAL*4 | REAL*4 | | | | DSQRT | REAL*8 | REAL*8 | | |see note | QSQRT | REAL*16 | REAL*16 | | | | CSQRT | COMPLEX*8 | COMPLEX*8 | | | | CDSQRT | COMPLEX*16 | COMPLEX*8 | | | | ZSQRT | COMPLEX*16 | COMPLEX*8 | +------+---------+----------+------------+-------------+
NOTE: QSQRT is not available in DEC Fortran.
The argument for SQRT, DSQRT, and QSQRT must be greater than or equal to zero. The result of CSQRT, CDSQRT, and ZSQRT is the principal value, with the real part greater than or equal to zero. If the real part is zero, the result is the principal value, with the imaginary part greater than or equal to zero.
TAN (real-number)A function that returns the tangent of the argument. The argument must be in radians; it is treated modulo 2*pi. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | TAN | TAN | REAL*4 | REAL*4 | | | | DTAN | REAL*8 | REAL*8 | | |see note | QTAN | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
NOTE: QTAN is not available in DEC Fortran.
TAND (real-number)A function that returns the tangent of the argument. The argument must be in degrees; it is treated modulo 360. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | TAND | TAND | REAL*4 | REAL*4 | | | | DTAND | REAL*8 | REAL*8 | | |see note | QTAND | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
NOTE: QTAND is not available in DEC Fortran.
TANH (real-number)A function that returns the hyperbolic tangent of the argument.
+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | TANH | TANH | REAL*4 | REAL*4 | | | | DTANH | REAL*8 | REAL*8 | | |see note | QTANH | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
NOTE: QTANH is not available in DEC Fortran.
CALL TIME (buf)buf Is an 8-byte variable, array, array element, or character substring. .end literal .b A subroutine that places the current time in 24-hour ASCII format in the argument. The time is returned as an 8-byte ASCII character string having the following form: .b .literal hh:mm:ss
A 24-hour clock is used.
If "buf" is numeric type and smaller than 8 bytes, data corruption can occur.
If "buf" is character type, its associated length is passed to the subroutine. If "buf" is smaller than 8 bytes, the subroutine truncates the date to fit in the specified length. Note that if a CHARACTER array is passed, the subroutine stores the time in the first array element, using the element length, not the length of the entire array. For example, consider the following:
CHARACTER*1 HOUR(8) . . . CALL TIME(HOUR)
The length of the first array element in CHARACTER array HOUR is passed to the TIME subroutine. The subroutine then truncates the time to fit into the one-character element, producing an incorrect result.
ZEXT (integer)A function that returns the value of the argument, zero extended. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | ZEXT | IZEXT | LOGICAL*1 | INTEGER*2 | | | | -- | LOGICAL*2 | INTEGER*2 | | | | -- | INTEGER*1 | INTEGER*2 | | | | -- | INTEGER*2 | INTEGER*2 | | | | JZEXT | LOGICAL*1 | INTEGER*4 | | | | -- | LOGICAL*2 | INTEGER*4 | | | | -- | LOGICAL*4 | INTEGER*4 | | | | -- | INTEGER*1 | INTEGER*4 | | | | -- | INTEGER*2 | INTEGER*4 | | | | -- | INTEGER*4 | INTEGER*4 | | |see note | KZEXT | LOGICAL*1 | INTEGER*8 | | | | -- | LOGICAL*2 | INTEGER*8 | | | | -- | LOGICAL*4 | INTEGER*8 | | | | -- | LOGICAL*8 | INTEGER*8 | | | | -- | INTEGER*1 | INTEGER*8 | | | | -- | INTEGER*2 | INTEGER*8 | | | | -- | INTEGER*4 | INTEGER*8 | | | | -- | INTEGER*8 | INTEGER*8 | +------+---------+----------+------------+-------------+
NOTE: KZEXT is only available on AXP systems.
The setting of -noi4 or -i8 (AXP only) affects ZEXT.