/[NO]ASSUME
Specifies various assumptions, including the following:
o What the compiler can assume about program behavior without
affecting correct results when it optimizes code.
o Whether the compiler should use certain code transformations
that affect floating-point operations. These changes may
affect the accuracy of the program's results.
o Whether a single-precision constant assigned to a
double-precision variable should be evaluated in single or
double precision.
o Changes the directory where the compiler searches for files
specified by an INCLUDE statement to the directory where the
source files reside, not the current default directory.
The defaults are /ASSUME=(ACCURACY_SENSITIVE, ALTPARAM,
NOBUFFERED_IO, NOBYTERECL, NODUMMY_ALIASES, NOF77RTL,
NOFP_CONSTANT, NOINT_CONSTANT, PROTECT_CONSTANTS,
NOSOURCE_INCLUDE,NO64BIT_STRING_PARAMS).
[NO]ACCURACY_SENSITIVE
Specifies whether certain code transformations that affect
floating-point operations are allowed. These changes may or may
affect the accuracy of the program's results.
The default, /ASSUME=ACCURACY_SENSITIVE, directs the compiler to
use only naive scalar rules for calculations. This setting may
prevent some optimizations.
Specifying /ASSUME=NOACCURACY_SENSITIVE allows the compiler to
reorder floating-point operations based on algebraic identities
(inverses, associativity, and distribution). For example, this
allows the compiler to move divide operations outside of loops,
thereby improving performance. 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)
[NO]ALTPARAM
Allows or disallows the alternate syntax for PARAMETER
statements. The alternate form has no parentheses surrounding
the list, and the form of the constant, rather than inplicit or
explicit typing, determines the data type of the variable. The
default is /ASSUME=ALTPARAM.
[NO]BUFFERED_IO
Controls whether buffered I/O is used for all Fortran logical
units opened for sequential writing. The default is
/ASSUME=NOBUFFERED_IO.
[NO]BYTERECL
Specifies (for unformatted data files) that the units for the
OPEN statement RECL specifier (record length) value are in bytes,
not longwords (four-byte units). For formatted files, the RECL
unit is always in bytes.
INQUIRE returns RECL in bytes if the unit is not open. INQUIRE
returns RECL in longwords if the file is open for unformatted
data and /ASSUME=BYTERECL is not specified; otherwise, it
returns RECL in bytes.
[NO]DUMMY_ALIASES
Specifies whether dummy (formal) arguments are permitted to share
memory locations with COMMON block variables or other dummy
arguments.
If you specify /ASSUME=DUMMY_ALIASES, the compiler assumes that
dummy (formal) arguments to procedures may share memory locations
with other dummy arguments or with variables shared through use
association, host association, or common block use.
These program semantics do not strictly obey the Fortran 95/90
standard and slow performance.
If you specify /ASSUME=NODUMMY_ALIASES, the default, 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 containing dummy aliasing with
/ASSUME=NODUMMY_ALIASES in effect, the run-time behavior of the
program will be unpredictable. The run-time behavior 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.
[NO]F77RTL
Specifies whether certain run-time I/O defaults are to match
those of HP Fortran 77 compilers.
If you specify /ASSUME=F77RTL, the following behavior changes:
- In NAMELIST-directed output, the HP Fortran 77
extension $ delimiters are used instead of the Fortran 90
standard delimiters
- PAD='NO' is the default when files are opened
The default is /ASSUME=NOF77RTL, which specifies that Fortran 95
semantics are to be followed.
[NO]FP_CONSTANT
Specifies whether a single-precision constant assigned to a
double-precision variable will be evaluated in double precision.
If you use /ASSUME=NOFP_CONSTANT (the default), a
single-precision constant assigned to a double-precision variable
is evaluated in single precision. The Fortran 95/90 standard
requires that the constant be evaluated in single precision.
If you specify /ASSUME=FP_CONSTANT, a single-precision constant
assigned to a double-precision variable is evaluated in double
precision.
Certain programs created for Fortran 77 compilers (including
HP Fortran 77) may show different results with
/ASSUME=FP_CONSTANT than when you use /ASSUME=NOFP_CONSTANT,
because they rely on single-precision constants assigned to a
double-precision variable to be evaluated in double precision.
In the following example, if you specify /ASSUME=FP_CONSTANT,
identical values are assigned to D1 and D2. If you use
/ASSUME=NOFP_CONSTANT, VSI Fortran will follow the standard
and assign a less precise value to D1:
REAL(KIND=8) D1,D2
DATA D1 /2.71828182846182/ ! REAL(KIND=4) value expanded to double
DATA D2 /2.71828182846182D0/ ! REAL(KIND=8) value assigned to double
[NO]INT_CONSTANT
Specifies whether Fortran 77 or Fortran 95/90 semantics are used
to determine the type for integer constants.
If you specify /ASSUME=INT_CONSTANT, integer constants take their
type from the value, as interpreted by HP Fortran 77.
If you specify /ASSUME=NOINT_CONSTANT, integer constants have
Fortran 95/90 "default integer" type. This is the default.
[NO]MINUS0
Specifies whether the compiler uses F95 or F90/FORTRAN 77
standard semantics for the treatment of the IEEE floating value
-0.0 in the SIGN intrinsic.
If you specify /ASSUME=NOMINUS0, F90 (FORTRAN 77) standard
semantics are used, where IEEE floating value -0.0 is treated as
0.0. This is the default.
If /ASSUME=MINUS0 is specified, F95 standard semantics are used,
where IEEE floating value -0.0 is treated as -0.0. Note that the
processor must be capable of distinguishing the difference
between -0.0 and +0.0.
[NO]PROTECT_CONSTANTS
Specifies whether a copy of a constant actual argument is passed.
/ASSUME=NOPROTECT_CONSTANTS causes a copy of a constant actual
argument to be passed, so it can be modified by the called
routine, even though the Fortran Standard prohibits such
modification. The constant is not modified in the calling
routine.
The default, /ASSUME=PROTECT_CONSTANTS, passes the constant
actual argument. Any attempt to modify it results in an error.
[NO]SOURCE_INCLUDE
Specifies the directory where the compiler searches for source
files or text libraries specified by an INCLUDE statement.
The default, /ASSUME=NOSOURCE_INCLUDE, indicates that the
compiler should search in the current default directory.
Specifying /ASSUME=SOURCE_INCLUDE causes the compiler to search
the directory of the source file specified on the F90 command
line, instead of the current default directory.
You can specify additional directories for the compiler to search
for include files or include libraries by using the /INCLUDE
qualifier.
[NO]64BIT_STRING_PARAMS
Specifies whether all string variables uses as parameters
should use 64-bit descriptors.
The default, /ASSUME=NO64BIT_STRING_PARAMS, indicates that the
compiler should generate 32-bit descriptors for string variables
unless such a variable is individually specified for a 64-bit
descriptor by using a compiler directive.
Specifying /ASSUME=64BIT_STRING_PARAMS causes ALL string
variables used as parameters to be passed/received by 64-bit
descriptors. Note that an unwanted side effect of changing
explicit or implicit parameters to system calls or the
Fortran Runtime Library can occur, causing runtime errors.
For more information, see the HP Fortran for OpenVMS User Manual.