Copyright Digital Equipment Corp. All rights reserved.

INT

 INT (number [,kind])

 Class:  Elemental function - Generic

 Returns the largest integer whose absolute value does not exceed
 the absolute value of the argument and has the same sign as the
 argument.

 The result is of type integer.  If "kind" is present, the kind
 parameter of the result is that specified by "kind"; otherwise, the
 kind parameter of the result is that shown in the following table.
 If the processor cannot represent the result value in the kind of
 the result, the result is undefined.
 +------+-----------+----------+------------+-------------+        
 | Args | Generic   | Specific |  Argument  | Result Type |
 +------+-----------+----------+------------+-------------+
 |  1   |  INT      |  --      | INTEGER*1  | INTEGER*2   |
 |      |           |  --      | INTEGER*1  | INTEGER*4   |
 |      |           |  --      | INTEGER*1  | INTEGER*8   |
 |      |           |  --      | INTEGER*2  | INTEGER*4   |
 |      |           |  --      | INTEGER*2  | INTEGER*8   |
 |      |           |  --      | INTEGER*4  | INTEGER*4   |
 |      |           |  --      | INTEGER*4  | INTEGER*8   |
 |      |           |  --      | INTEGER*8  | INTEGER*8   |
 |      |see note1  | IIFIX    | REAL*4     | INTEGER*2   |
 |      |           | IINT     | REAL*4     | INTEGER*2   |
 |      |see note2  | IFIX     | REAL*4     | INTEGER*4   |
 |      |           | JFIX     | INTEGER*1  | INTEGER*4   |
 |      |           |          | INTEGER*2  | INTEGER*4   |
 |      |           |          | INTEGER*4  | INTEGER*4   |
 |      |           |          | INTEGER*8  | INTEGER*4   |
 |      |           |          | REAL*4     | INTEGER*4   |
 |      |           |          | REAL*8     | INTEGER*4   |
 |      |           |          | REAL*16    | INTEGER*4   |
 |      |           |          | COMPLEX*8  | INTEGER*4   |
 |      |           |          | COMPLEX*16 | INTEGER*4   |
 |      |           |          | COMPLEX*32 | INTEGER*4   |
 |      |see note3  | INT      | REAL*4     | INTEGER*4   |
 |      |           | KIFIX    | REAL*4     | INTEGER*8   |
 |      |           | KINT     | REAL*4     | INTEGER*8   |
 |      |           | IIDINT   | REAL*8     | INTEGER*2   |
 |      |see note4  | IDINT    | REAL*8     | INTEGER*4   |
 |      |           | KIDINT   | REAL*4     | INTEGER*8   |
 |      |           | IIQINT   | REAL*16    | INTEGER*2   |
 |      |see note5  | IQINT    | REAL*16    | INTEGER*4   |
 |      |           | KIQINT   | REAL*16    | INTEGER*8   |
 |      |           |  --      | COMPLEX*8  | INTEGER*2   |
 |      |           |  --      | COMPLEX*8  | INTEGER*4   |
 |      |           |  --      | COMPLEX*8  | INTEGER*8   |
 |      |           |  --      | COMPLEX*16 | INTEGER*2   |
 |      |           |  --      | COMPLEX*16 | INTEGER*4   |
 |      |           |  --      | COMPLEX*16 | INTEGER*8   |
 |      |           |  --      | COMPLEX*32 | INTEGER*2   |
 |      |           |  --      | COMPLEX*32 | INTEGER*4   |
 |      |           |  --      | COMPLEX*32 | INTEGER*8   |
 |      |           | INT1     | INTEGER*1  | INTEGER*1   |
 |      |           |          | INTEGER*2  | INTEGER*1   |
 |      |           |          | INTEGER*4  | INTEGER*1   |
 |      |           |          | INTEGER*8  | INTEGER*1   |
 |      |           |          | REAL*4     | INTEGER*1   |
 |      |           |          | REAL*8     | INTEGER*1   |
 |      |           |          | REAL*16    | INTEGER*1   |
 |      |           |          | COMPLEX*8  | INTEGER*1   |
 |      |           |          | COMPLEX*16 | INTEGER*1   |
 |      |           |          | COMPLEX*32 | INTEGER*1   |
 |      |           | INT2     | INTEGER*1  | INTEGER*2   |
 |      |           |          | INTEGER*2  | INTEGER*2   |
 |      |           |          | INTEGER*4  | INTEGER*2   |
 |      |           |          | INTEGER*8  | INTEGER*2   |
 |      |           |          | REAL*4     | INTEGER*2   |
 |      |           |          | REAL*8     | INTEGER*2   |
 |      |           |          | REAL*16    | INTEGER*2   |
 |      |           |          | COMPLEX*8  | INTEGER*2   |
 |      |           |          | COMPLEX*16 | INTEGER*2   |
 |      |           |          | COMPLEX*32 | INTEGER*2   |
 |      |           | INT4     | INTEGER*1  | INTEGER*4   |
 |      |           |          | INTEGER*2  | INTEGER*4   |
 |      |           |          | INTEGER*4  | INTEGER*4   |
 |      |           |          | INTEGER*8  | INTEGER*4   |
 |      |           |          | REAL*4     | INTEGER*4   |
 |      |           |          | REAL*8     | INTEGER*4   |
 |      |           |          | REAL*16    | INTEGER*4   |
 |      |           |          | COMPLEX*8  | INTEGER*4   |
 |      |           |          | COMPLEX*16 | INTEGER*4   |
 |      |           |          | COMPLEX*32 | INTEGER*4   |
 |      |           | INT8     | INTEGER*1  | INTEGER*8   |
 |      |           |          | INTEGER*2  | INTEGER*8   |
 |      |           |          | INTEGER*4  | INTEGER*8   |
 |      |           |          | INTEGER*8  | INTEGER*8   |
 |      |           |          | REAL*4     | INTEGER*8   |
 |      |           |          | REAL*8     | INTEGER*8   |
 |      |           |          | REAL*16    | INTEGER*8   |
 |      |           |          | COMPLEX*8  | INTEGER*8   |
 |      |           |          | COMPLEX*16 | INTEGER*8   |
 |      |           |          | COMPLEX*32 | INTEGER*8   |
 +------+-----------+----------+------------+-------------+

 Note1: This function can also be specified as HFIX.
 Note2: For compatibility with older versions of 
        Fortran, IFIX can also be specified as a generic 
        function.
 Note3: Or JINT.
 Note4: Or JIDINT.  For compatibility with older versions of 
        Fortran, IDINT can also be specified as a generic 
        function.
 Note5: Or JIQINT.  For compatibility with older versions of 
        Fortran, IQINT can also be specified as a generic 
        function.

 These functions cannot be passed as actual arguments.

 The setting of compiler options specifying integer size can affect
 INT, IDINT, and IQINT.

 The setting of compiler options specifying integer size and real
 size can affect IFIX.