Syntax:
The /assume option specifies assumptions made by the Fortran syntax analyzer, optimizer, and code generator. These option keywords are:
The /assume options are:
Specifying /assume:noaccuracy_sensitive allows the compiler to reorder code based on algebraic identities (inverses, associativity, and distribution) to improve performance. In the visual development environment, specify Allow Reordering of Floating-Point Operations in the Optimizations Compiler Option Category.
The numeric results can be slightly different from the default (/assume:accuracy_sensitive) because of the way intermediate results are rounded.
Numeric results with /assume:noaccuracy_sensitive are not categorically less accurate. They can produce more accurate results for certain floating-point calculations, such as dot product summations. For example, the following expressions are mathematically equivalent but may not compute the same value using finite precision arithmetic:
X = (A + B) - C
X = A + (B - C)
If you omit /assume:noaccuracy_sensitive and omit /fast, the compiler uses a limited number of rules for calculations, which might prevent some optimizations.
If you specify /assume:noaccuracy_sensitive, or if you specify /fast and omit /assume:accuracy_sensitive, the compiler can reorder code based on algebraic identities to improve performance.
For more information on /assume:noaccuracy_sensitive, see Arithmetic Reordering Optimizations.
The /assume:buffered_io option controls whether records are written (flushed) to disk as each record is written (default) or accumulated in the buffer.
For disk devices, /assume:buffered_io (or the equivalent OPEN statement BUFFERED='YES' specifier or the FORT_BUFFERED run-time environment variable) requests that the internal buffer will be filled, possibly by many record output statements (WRITE), before it is written to disk by the Fortran run-time system. If a file is opened for direct access, I/O buffering will be ignored.
Using buffered writes usually makes disk I/O more efficient by writing larger blocks of data to the disk less often. However, if you request buffered writes, records not yet written to disk may be lost in the event of a system failure.
Unless you set the FORT_BUFFERED environment variable to TRUE, the default is BUFFERED='NO' and /assume:nobuffered_io for all I/O, in which case, the Fortran run-time system empties its internal buffer for each WRITE (or similar record output statement).
The OPEN statement BUFFERED specifier applies to a specific logical unit. In contrast, the /assume:[no]buffered_io option and the FORT_BUFFERED environment variable apply to all Fortran units.
In the visual development environment, to enable /assume:buffered_io, specify the Enable I/O Buffering in the Optimizations Compiler Option Category.
For more information on /assume:buffered_io, see Efficient Use of Record Buffers and Disk I/O.
The /assume:byterecl option applies only to unformatted files. In the visual development environment, specify the Use Bytes as Unit for Unformatted Files in the Fortran Data Compiler Option Category. Specifying the /assume:byterecl option:
Specifying /assume:nobyterecl indicates that the units for RECL values with unformatted files are in four-byte (longword) units. This is the default.
Specifying the /assume:dummy_aliases option requires that the compiler assume that dummy (formal) arguments to procedures share memory locations with other dummy arguments or with variables shared through use association, host association, or common block use. The default is /assume:nodummy_aliases.
In the visual development environment, specify Enable Dummy Argument Aliasing in the Fortran Data (or Optimizations) Compiler Option Category.
These program semantics do not strictly obey the Fortran Standard and they slow performance. If you omit /assume:dummy_aliases, the compiler does not need to make these assumptions, which results in better run-time performance. However, omitting /assume:dummy_aliases can cause some programs that depend on such aliases to fail or produce wrong answers.
You only need to compile the called subprogram with /assume:dummy_aliases.
If you compile a program that uses dummy aliasing with /assume:nodummy_aliases in effect, the run-time behavior of the program will be unpredictable. In such programs, the results will depend on the exact optimizations that are performed. In some cases, normal results will occur; however, in other cases, results will differ because the values used in computations involving the offending aliases will differ.
For more information, see Dummy Aliasing Assumption.
This option controls whether the compiler uses Fortran 95 standard semantics for the IEEE floating-point value of -0.0 (minus zero) in the SIGN intrinsic, if the processor is capable of distinguishing the difference between -0.0 and +0.0. The default is /assume:nominus0, where the value -0.0 or +0.0 in the SIGN function is treated as 0.0.
To request Fortran 95 semantics to allow use of the IEEE value -0.0 in the SIGN intrinsic, specify /assume:minus0.
In the visual development environment, specify Enable IEEE Minus Zero Support in the Floating Point Compiler Option Category.
This option specifies whether constant actual arguments can be changed. By default, actual arguments that are constants are read-only (/assume:protect_constants). To allow changes to actual arguments that are constants, specify /assume:noprotect_constants.
In the visual development environment, specify Constant Actual Arguments are Read-Only in the Fortran Data Compiler Option Category.
This option controls the directory searched for module files specified by a USE statement or source files specified by an INCLUDE statement:
In the visual development environment, specify the Default INCLUDE and USE Paths in the Preprocessor Compiler Option Category.
Specifying /assume:underscore option controls the appending of an underscore character to external user-defined names: the main program name, named COMMON, BLOCK DATA, and names implicitly or explicitly declared EXTERNAL. The name of blank COMMON remains _BLNK__, and Fortran intrinsic names are not affected.
In the visual development environment, specify Append Underscore to External Names in the External Procedures (or Fortran Data) Compiler Option Category.
Specifying /assume:nounderscore option does not append an underscore character to external user-defined names. This is the default.
For example, the following command requests the noaccuracy_sensitive and nosource_include keywords and accepts the defaults for the other /assume keywords:
df /assume:(noaccuracy_sensitive,nosource_include) testfile.f90