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.