/FLOAT=option D=/FLOAT=IEEE_FLOAT (I64)

                                 D=/FLOAT=G_FLOAT (Alpha) 
 Specifies the floating-point data format to be used in memory for
 REAL or COMPLEX data.

 For performance reasons, consider specifying the same
 floating-point memory format as the floating-point format used by
 unformatted files the program will access if the data falls within
 the acceptable range.

 To specify a floating-point format (such as big endian) for all
 unformatted files opened by the program, use the /CONVERT
 qualifier.  To allow the same program to use different
 floating-point formats, you must use predefined logical names or
 the OPEN (CONVERT=) keyword to specify the format for specific unit
 numbers, as described in the HP Fortran for OpenVMS User Manual.

 You can only specify one qualifier option.

 D_FLOAT
   Specifies that the memory format for REAL(KIND=4) and
   COMPLEX(KIND=4) data is VAX F_floating and that the memory format
   for REAL(KIND=8) and COMPLEX(KIND=8) data is VAX D_floating.
   This option is the same as the obsolete qualifier /NOG_FLOATING.

                                 NOTE

           OpenVMS  VAX  systems  support   D_floating   and
           G_floating    implementations   of   the   DOUBLE
           PRECISION (REAL(KIND=8))  data  type  in  memory.
           OpenVMS  Alpha  systems  can  store  REAL(KIND=8)
           floating-point  data  in  memory  in  D_floating,
           G_floating, or T_floating format.

           Because  the  Alpha  instruction  set  does   not
           support  D_floating computations, D_floating data
           is converted to G_floating format for  arithmetic
           computations   and   then   converted   back   to
           D_floating format.   For  programs  that  perform
           many  REAL(KIND=8) computations, using D_floating
           data  is  slower   than   using   G_floating   or
           T_floating  data and the results will differ from
           VAX D_floating computations and results.

           Unless a program uses unformatted data  files  in
           D_floating  format, do not use the /FLOAT=D_FLOAT
           option.  If range and accuracy constraints do not
           disallow  the  use of the other REAL(KIND=8) data
           types, consider converting  existing  unformatted
           files  that  contain  D_floating  data to another
           format,  such  as  G_floating,   T_floating,   or
           X_floating  to  optimize  performance.  (For more
           information, see the HP Fortran for OpenVMS User
           Manual.)

 G_FLOAT
   Specifies that the memory format for REAL(KIND=4) and
   COMPLEX(KIND=4) data is VAX F_floating and that REAL(KIND=8) and
   the memory format for COMPLEX(KIND=8) data is VAX G_floating.
   This option is the same as the obsolete qualifier /G_FLOATING.

                                 NOTE

               Because the I64 instruction set does not support
	       F_floating, D_floating, or G_floating computations,
	       data in those formats is converted to IEEE format
               (S_floating or T_floating) for arithmetic
               computations and then converted back to
               the original format.  For programs that perform
               many REAL (KIND=4 or KIND=8) computations, using
               F_floating, D_floating, or G_floating data will be
               slower than using S_floating or T_floating  data.
               The results may differ from slightly from Alpha
               F_floating, D_floating, or G_floating computations
               and results. In particular, exceptions raised by
               the calculation may be different, and some
               exceptions may no longer occur, while new
               exceptions may appear.

 This the default floating-point format for Alpha systems.

 IEEE_FLOAT
   Specifies that the memory format for REAL(KIND=4) and
   COMPLEX(KIND=4) data is IEEE S_floating and the memory format for
   REAL(KIND=8) and COMPLEX(KIND=8) data is IEEE T_floating.

   This format lets you use the /IEEE_MODE qualifier.

   This is the default floating-point format for I64 systems.

 If your program requires the G_floating form of double precision
 for its correct operation (it uses a range larger than 10**38), you
 should use the /FLOAT qualifier in an OPTIONS statement in your
 source program.

 You should not mix floating data type formats in routines that pass
 single-precision or double-precision quantities amongst themselves.

 For more information on floating-point data types, see the HP
 Fortran for OpenVMS User Manual.