HP OpenVMS Systems Documentation

HP Fortran for OpenVMS
User Manual

This chapter describes:

• Section 8.1, Summary of Data Types and Characteristics
• Section 8.2, Integer Data Representations
• Section 8.3, Logical Data Representations
• Section 8.4, Native Floating-Point Representations and IEEE Exceptional Values
• Section 8.5, Character Representation
• Section 8.6, Hollerith Representation

For More Information:

• On using nonnative big endian and VAX floating-point formats, see Chapter 9.
• On HP Fortran I/O, see Chapter 6.

Table 8-1 lists the intrinsic data types provided by HP Fortran, the storage required, and valid numeric ranges.

.

In addition to the intrinsic numeric data types, you can define nondecimal (binary, octal, or hexadecimal) constants as explained in the HP Fortran for OpenVMS Language Reference Manual.

8.2 Integer Data Representations

Integer data lengths can be one, two, four, or eight bytes in length.

Integer data is signed with the sign bit being 0 (zero) for positive numbers and 1 for negative numbers.

To improve performance, avoid using 2-byte or 1-byte integer declarations (see Chapter 5).

8.2.1 Integer Declarations and FORTRAN Command Qualifiers

The default size used for an INTEGER data declaration without a kind parameter (or size specifier) is INTEGER (KIND=4) (same as INTEGER*4), unless you do one of the following:

• Explicitly declare the length of an INTEGER by using a kind parameter, such as INTEGER (KIND=8). HP Fortran provides intrinsic INTEGER kinds of 1, 2, 4, and 8. Each INTEGER kind number corresponds to the number of bytes used by that intrinsic representation.
  To obtain the kind of a variable, use the KIND intrinsic function. You can also use a size specifier, such as INTEGER*4, but be aware this is an extension to the Fortran 90 standard.
• Use the FORTRAN command /INTEGER_SIZE=nn qualifier to control the size of all default (without a kind parameter or size specifier) INTEGER and LOGICAL declarations (see Section 2.3.26).

Intrinsic INTEGER (KIND=1) or INTEGER*1 signed values range from --128 to 127 and are stored in a two's complement representation. For example:

+22 = 16(hex)
 -7 = F9(hex)

INTEGER (KIND=1) or INTEGER*1 values are stored in one byte, as shown in Figure 8-1.

Figure 8-1 INTEGER (KIND =1) or INTEGER*1 Representation

Intrinsic INTEGER (KIND=2) or INTEGER*2 signed values range from --32,768 to 32,767 and are stored in a two's complement representation. For example:

+22 = 0016(hex)
 -7 = FFF9(hex)

INTEGER (KIND=2) or INTEGER*2 values are stored in two contiguous bytes, as shown in Figure 8-2.

Figure 8-2 INTEGER (KIND =2) or INTEGER*2 Representation

Intrinsic INTEGER (KIND=4) or INTEGER*4 signed values range from --2,147,483,648 to 2,147,483,647 and are stored in a two's complement representation. INTEGER (KIND=4) or INTEGER*4 values are stored in four contiguous bytes, as shown in Figure 8-3.

Figure 8-3 INTEGER (KIND =4) or INTEGER*4 Representation

Intrinsic INTEGER (KIND=8) or INTEGER*8 signed values range from --9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 and are stored in a two's complement representation. INTEGER*8 or INTEGER (KIND=8) values are stored in eight contiguous bytes, as shown in Figure 8-4.

Figure 8-4 INTEGER (KIND =8) or INTEGER*8 Representation

For More Information:

• On defining constants and assigning values to variables, see the HP Fortran for OpenVMS Language Reference Manual.
• On intrinsic functions related to the various data types, such as KIND and SELECTED_INT_KIND, see the HP Fortran for OpenVMS Language Reference Manual.
• On the FORTRAN command qualifiers that control the size of default INTEGER declarations, see Section 2.3.26.

Logical data can be one, two, four, or eight bytes in length.

The default size used for a LOGICAL data declaration without a kind parameter (or size specifier) is LOGICAL (KIND=4) (same as LOGICAL*4), unless you do one of the following:

• Explicitly declare the length of a LOGICAL declaration by using a kind parameter, such as LOGICAL (KIND=4). HP Fortran provides intrinsic LOGICAL kinds of 1, 2, 4, and 8. Each LOGICAL kind number corresponds to number of bytes used by that intrinsic representation.
  You can also use a size specifier, such as LOGICAL*4, but be aware this is an extension to the Fortran 90 standard.
• Use the FORTRAN command /INTEGER_SIZE=nn qualifier to control the size of default (without a kind parameter or size specifier) LOGICAL and INTEGER declarations (see Section 2.3.26).

To improve performance, avoid using 2-byte or 1-byte logical declarations (see Chapter 5).

Intrinsic LOGICAL*1 or LOGICAL (KIND=1) values are stored in a single byte.

Logical (intrinsic) values can also be stored in the following sizes of contiguous bytes starting on an arbitrary byte boundary:

• Two bytes (LOGICAL (KIND=2) or LOGICAL*2)
• Four bytes (LOGICAL (KIND=4) or LOGICAL*4)
• Eight bytes (LOGICAL (KIND=8) or LOGICAL*8)

The low-order bit determines whether the logical value is true or false. Logical variables can also be interpreted as integer data (an extension to the Fortran 90 standard). For example, in addition to having logical values .TRUE. and .FALSE., LOGICAL*1 data can also have values in the range --128 to 127.

LOGICAL*1, LOGICAL*2, LOGICAL*4, and LOGICAL*8 data representations appear in Figure 8-5.

Figure 8-5 LOGICAL Representations

For More Information:

• On defining constants and assigning values to variables, see the HP Fortran for OpenVMS Language Reference Manual.
• On intrinsic functions related to the various data types, see the HP Fortran for OpenVMS Language Reference Manual.
• On the FORTRAN command qualifiers that control the size of default LOGICAL declarations, see Section 2.3.26.

Floating-point numbers are stored on OpenVMS systems in one of the following IEEE or VAX little endian binary floating-point formats, as follows:

• REAL (KIND=4) or REAL*4 declarations are stored in little endian IEEE S_float format or VAX F_float format.
• REAL (KIND=8) or REAL*8 declarations are stored in little endian IEEE T_float format, VAX G_float format, or VAX D_float format.
• REAL (KIND=16) or REAL*16 declarations always are stored in little endian Alpha IEEE-like X_float format.

COMPLEX numbers use a pair of little endian REAL values to denote the real and imaginary parts of the data, as follows:

• COMPLEX (KIND=4) or COMPLEX*8 declarations are stored in IEEE S_float or VAX F_float format using two REAL (KIND=4) or REAL*4 values.
• COMPLEX (KIND=8) or COMPLEX*16 declarations are stored in IEEE T_float, VAX G_float, or VAX D_float format using two REAL (KIND=8) or REAL*8 values.
• COMPLEX (KIND=16) or COMPLEX*32 declarations are stored in IEEE X_float format using two REAL (KIND=16) or REAL*16 values.

To specify the floating-point format used in memory, use the FORTRAN command /FLOAT qualifier. If you do not specify the /FLOAT qualifier, the following formats are used:

• VAX F_float for REAL (KIND=4) and COMPLEX (KIND=4) data
• VAX G_float for REAL (KIND=8) and COMPLEX (KIND=8) data
• X_float for REAL (KIND=16)

To change the default size for REAL and COMPLEX declarations, use the FORTRAN command /REAL_SIZE qualifier.

To change the default size for DOUBLE PRECISION declarations, use the FORTRAN command /DOUBLE_SIZE qualifier.

All floating-point formats represent fractions using sign-magnitude notation, with the binary radix point to the left of the most significant bit for F_floating, D_floating, and G_floating, and to the right for S_floating and T_floating. Fractions are assumed to be normalized, and therefore the most significant bit is not stored. This is called "hidden bit normalization".

With IEEE data, the hidden bit is assumed to be 1 unless the exponent is 0. If the exponent equals 0, then the value represented is denormalized (subnormal) or plus or minus 0 (zero).

With VAX data, the hidden bit is assumed to be 1.

For an explanation of the representation of NaN, Infinity, and related IEEE exceptional values, see Section 8.4.8.

8.4.1 REAL, COMPLEX, and DOUBLE PRECISION Declarations and FORTRAN Qualifiers

The default size for REAL, COMPLEX, and DOUBLE PRECISION data declarations are as follows:

• For REAL data declarations without a kind parameter (or size specifier), the default size is REAL (KIND=4) (same as REAL*4). To change the default REAL (and COMPLEX) size to (KIND=8), use the FORTRAN command /REAL_SIZE qualifier (see Section 2.3.37).
• For COMPLEX data declarations without a kind parameter (or size specifier), the default data size is COMPLEX (KIND=4) (same as COMPLEX*8). To change the default COMPLEX (and REAL) size to (KIND=8), use the FORTRAN command /REAL_SIZE qualifier (see Section 2.3.37).
• For a DOUBLE PRECISION data declarations, the default size is REAL (KIND=8) (same as REAL*8). To change the default DOUBLE PRECISION size to REAL (KIND=16), use the FORTRAN command /DOUBLE_SIZE qualifier (see Section 2.3.17).

You can explicitly declare the length of a REAL or a COMPLEX declaration using a kind parameter or specify DOUBLE PRECISION or DOUBLE COMPLEX.

Intrinsic REAL kinds are 4 (single precision) and 8 (double precision); intrinsic COMPLEX kinds are also 4 (single precision) and 8 (double precision). For example, REAL (KIND=4) requests single-precision floating-point data.

You can also use a size specifier, such as REAL*4, but be aware this is an extension to the Fortran 90 standard.

8.4.2 REAL (KIND=4) or REAL*4 Representations

REAL (KIND=4) or REAL*4 data can be in IEEE S_float or VAX F_float formats. This is the default data size for REAL declarations.

8.4.2.1 IEEE S_float Representation

Intrinsic REAL (KIND=4) or REAL*4 (single precision REAL) data occupies four contiguous bytes stored in IEEE S_float format. Bits are labeled from the right, 0 through 31, as shown in Figure 8-6.

Figure 8-6 IEEE S_float REAL (KIND =4) or REAL*4 Representation

The form of REAL (KIND=4) or REAL*4 data is sign magnitude, with:

• Bit 31 the sign bit (0 for positive numbers, 1 for negative numbers)
• Bits 30:23 a binary exponent in excess 127 notation
• Bits 22:0 a normalized 24-bit fraction including the redundant most-significant fraction bit not represented.

The value of data is in the approximate range: 1.17549435E--38 (normalized) to 3.40282347E38. The IEEE denormalized limit is 1.40129846E--45.

The precision is approximately one part in 2**23, typically seven decimal digits.

8.4.2.2 VAX F_float Representation

Intrinsic REAL (KIND=4) or REAL*4 F_float data occupies four contiguous bytes. Bits are labeled from the right, 0 through 31, as shown in Figure 8-7.

Figure 8-7 VAX F_float REAL (KIND =4) or REAL*4 Representation

The form of REAL (KIND=4) or REAL*4 F_float data is sign magnitude, where:

• Bit 15 is the sign bit (0 for positive numbers, 1 for negative numbers).
• Bits 14:7 are a binary exponent in excess 128 notation (binary exponents from --127 to 127 are represented by binary 1 to 255).
• Bits 6:0 and 31:16 are a normalized 24-bit fraction with the redundant most significant fraction bit not represented.

The value of data is in the approximate range: 0.293873588E--38 to 1.7014117E38.

The precision is approximately one part in 2**23, typically seven decimal digits.

8.4.3 REAL (KIND=8) or REAL*8 Representations

REAL (KIND=8) or REAL*8 data can be in IEEE T_float, VAX G_float, or VAX D_float formats.

8.4.3.1 IEEE T_float Representation

Intrinsic REAL (KIND=8) or REAL*8 (same as DOUBLE PRECISION) data occupies eight contiguous bytes stored in IEEE T_float format. Bits are labeled from the right, 0 through 63, as shown in Figure 8-8.

Figure 8-8 IEEE T_float REAL (KIND =8) or REAL*8 Representation

The form of REAL (KIND=8) or REAL*8 data is sign magnitude, with:

• Bit 63 the sign bit (0 for positive numbers, 1 for negative numbers)
• Bits 62:52 a binary exponent in excess 1023 notation
• Bits 51:0 a normalized 53-bit fraction including the redundant most-significant fraction bit not represented.

The value of data is in the approximate range: 2.2250738585072013D-308 (normalized) to 1.7976931348623158D308. The IEEE denormalized limit is 4.94065645841246544D-324.

The precision is approximately one part in 2**52, typically 15 decimal digits.