User's Guide

IEEE Floating-Point Overview

Here is a brief summary of the IEEE Standard for Floating-Point Arithmetic and the details of how it applies to XL Fortran on specific hardware platforms.For information on the draft Fortran 2000 IEEE Module and arithmetic support, see the XL Fortran for AIX Language Reference.

Compiling for Strict IEEE Conformance

By default, XL Fortran follows most, but not all of the rules in the IEEE standard. To compile for strict compliance with the standard:

• Use the compiler option -qfloat=nomaf.
• If the program changes the rounding mode at run time, include rrm among the -qfloat suboptions.
• If the data or program code contains signaling NaN values (NaNS), include nans among the -qfloat suboptions. (A NaNS is different from a quiet NaN; you must explicitly code it into the program or data or create it by using the -qinitauto compiler option.)
• If compiling with -O3, include the option -qstrict also.

IEEE Single- and Double-Precision Values

XL Fortran encodes single-precision and double-precision values in IEEE format. For the range and representation, see "Real" in the XL Fortran for AIX Language Reference.

IEEE Extended-Precision Values

The IEEE standard suggests, but does not mandate, a format for extended-precision values. XL Fortran does not use this format. Extended-Precision Values describes the format that XL Fortran uses.

Infinities and NaNs

For single-precision real values:

• Positive infinity is represented by the bit pattern X'7F80 0000'.
• Negative infinity is represented by the bit pattern X'FF80 0000'.
• A signaling NaN (NANS) is represented by any bit pattern between X'7F80 0001' and X'7FBF FFFF' or between X'FF80 0001' and X'FFBF FFFF'.
• A quiet NaN (NANQ) is represented by any bit pattern between X'7FC0 0000' and X'7FFF FFFF' or between X'FFC0 0000' and X'FFFF FFFF'.

For double-precision real values:

• Positive infinity is represented by the bit pattern X'7FF00000 00000000'.
• Negative infinity is represented by the bit pattern X'FFF00000 00000000'.
• A signaling NaN is represented by any bit pattern between X'7FF00000 00000001' and X'7FF7FFFF FFFFFFFF' or between X'FFF00000 00000001' and X'FFF7FFFF FFFFFFFF'.
• A quiet NaN is represented by any bit pattern between X'7FF80000 00000000' and X'7FFFFFFF FFFFFFFF' or between X'FFF80000 00000000' and X'FFFFFFFF FFFFFFFF'.

These values do not correspond to any Fortran real constants. You can generate all of these by encoding the bit pattern directly. However, this programming technique is often discouraged, as it is not allowed by the Fortran standard and it could cause portability problems on machines using different bit patterns for the different values. All except NaNS values can occur as the result of arithmetic operations:

$ cat fp_values.f
real plus_inf, minus_inf, plus_nanq, minus_nanq, nans
real large
 
data plus_inf /z'7f800000'/
data minus_inf /z'ff800000'/
data plus_nanq /z'7fc00000'/
data minus_nanq /z'ffc00000'/
data nans /z'7f800001'/
 
print *, 'Special values:', plus_inf, minus_inf, plus_nanq, minus_nanq, nans
 
! They can also occur as the result of operations.
large = 10.0 ** 200
print *, 'Number too big for a REAL:', large * large
print *, 'Number divided by zero:', (-large) / 0.0
print *, 'Nonsensical results:', plus_inf - plus_inf, sqrt(-large)
 
! To find if something is a NaN, compare it to itself.
print *, 'Does a NaNQ equal itself:', plus_nanq .eq. plus_nanq
print *, 'Does a NaNS equal itself:', nans .eq. nans
! Only for a NaN is this comparison false.
 
end
$ xlf95 -o fp_values fp_values.f
** _main   === End of Compilation 1 ===
1501-510  Compilation successful for file fp_values.f.
$ fp_values
 Special values: INF -INF NaNQ -NaNQ NaNS
 Number too big for a REAL: INF
 Number divided by zero: -INF
 Nonsensical results: NaNQ NaNQ
 Does a NaNQ equal itself: F
 Does a NaNS equal itself: F

Exception-Handling Model

The IEEE standard defines several exception conditions that can occur:

OVERFLOW

The exponent of a value is too large to be represented.

UNDERFLOW

A nonzero value is so small that it cannot be represented as anything other than zero.

ZERODIVIDE

A finite nonzero value is divided by zero.

INVALID

Operations are performed on values for which the results are not defined, such as infinity-infinity, 0.0/0.0, or the square root of a negative number.

INEXACT

A computed value cannot be represented exactly, so a rounding error is introduced. (This exception is very common.)

XL Fortran always detects these exceptions when they occur, but the default is not to take any special action. Calculation continues, usually with a NaN or infinity value as the result. If you want to be automatically informed when an exception occurs, you can turn on exception trapping through compiler options or calls to intrinsic subprograms. However, different results, intended to be manipulated by exception handlers, are produced:

Table 18. Results of IEEE Exceptions, with and without Trapping Enabled

Note:

Because different results are possible, it is very important to make sure that any exceptions that are generated are handled correctly. See Detecting and Trapping Floating-Point Exceptions for instructions on doing so.