All integer data is 64 bits (KIND=8), 2's complement.

When slower integer operations (f90 -O nofastint) are in effect, the range for INTEGER(KIND=8) operations is -2⁶³ < I < 2⁶³ or approximately -10¹⁸ < I < 10¹⁸.

When fast integer operations (f90 -O fastint) are in effect, which is the default, the range for INTEGER(KIND=8) operations is -2⁴⁶ < I < 2⁴⁶ or approximately -10¹³ < I < 10¹³.

Figure 5-1. Default 64-bit integers

Figure 5-2. Fast integer operations with INTEGER(KIND=8), UNICOS systems (except CRAY T90 systems that support IEEE floating-point arithmetic)

To declare an entity to be of type integer, specify one of the following:

Real (floating-point) numbers are represented in a packed representation of a binary mantissa and an exponent (power of 2). The bits in a Cray word are used to represent a real number as follows:

Figure 5-3. Real type

Notes on real data type representation:

The exponent is a power of 2, represented by a number that is 40000₈ higher than the actual value; this is called a bias. The effect of the bias is that the second bit in the word serves as the exponent's sign bit. This bit's usage is the inverse of the mantissa's sign bit, as follows:

The exponent is represented by the second through sixth digits in an octal printout; these digits have the range 40000 through 57776₈ for a positive exponent, and 37777 through 20003₈ for a negative exponent.

When the bias is accounted for, the range of all exponents is as follows (notice the negative range is one smaller):

The mantissa is a 48-bit signed fraction. The sign of the mantissa is separated from the rest of the mantissa as shown in the preceding diagram. The mantissa is not complemented for negative values. That is, the mantissa for -10.0 is the same as for +10.0.

In terms of decimal values, the floating-point format of the CPU allows representation of numbers to about 15 significant decimal digits in the following approximate decimal range:

.367 × 10^-2465 < R < .273 × 10 ²⁴⁶⁶

A zero value is not biased and is represented as a word of all zeros.

Following are some sample numbers as represented within memory:

Figure 5-4. Binary version of 10.0

The leftmost bit, with a 0 value, indicates a positive mantissa; that is, the real value is positive. The next bit, set to 1, is the sign bit of the exponent, indicating a positive exponent value; that is, the absolute value of the number is 1.0 or greater. The value 4 in the exponent (100 appearing to the left of bit 47) means that the binary fraction in the mantissa is multiplied by 2⁴ (or, to express it another way, the binary point is moved 4 bits to the right from the highest bit of the mantissa.) Interpreted in this way, the first 4 digits of the mantissa, 1010, indicate the real decimal value 10.0. You can display other values by printing them with formats O22, Z16, or B64.

To declare an entity to be of type real, specify one of the following:

Note that a real data object with KIND=4 has the same internal representation as a real data object with KIND=8. Numeric inquiry functions on a real data object with KIND=4 return different values than on a real data object with KIND=8. A numeric operation on a real data object with KIND=4 returns the same result as the same numeric operation on a real data object with KIND=8.

DATA REALZERO /0./
X = X + REALZERO

A double-precision value is represented by 2 words. The first has the same format as the real type. The second word uses bits 0 through 47 as 48 additional bits of the mantissa. The other 16 bits of the second word must be zeros. Double-precision numbers can be in the following range:

Figure 5-5. Double-precision type

To declare an entity to be of type double precision, specify one of the following:

A single-precision complex value is represented by 2 words, each of which has the same format as the real type. The first word represents the real part, and the second represents the imaginary part. Each word has the same range as a real value.

Figure 5-6. Single-precision complex type

To declare an entity to be of single-precision complex type, specify one of the following:

Note that a complex data object with KIND=4 has the same internal representation as a complex data object with KIND=8. Numeric inquiry functions on a complex data object with KIND=4 return different values than on a complex data object with KIND=8. A numeric operation on a complex data object with KIND=4 returns the same result as the same numeric operation on a complex data object with KIND=8.

Values of double precision complex type are represented by 4 words. The first 2 words are the real part, and the last 2 words are the imaginary part. The real part and the imaginary part each have the same range as a double precision value.

Figure 5-7. Double-precision complex type (real portion)

Figure 5-8. Double-precision complex type (imaginary portion)

To declare an entity to be of double-precision complex type, specify one of the following:

Characters are represented by 8-bit ASCII codes packed eight per word.

Figure 5-9. Character type

The CF90 compiler does not support a nondefault character type. The only kind value supported is 1.

A logical variable uses one 64-bit word. Its value is true if the numeric value in the word is negative (typically, -1), and it is false if the numeric value in the word is nonnegative (typically, 0).

---

Note:: Silicon Graphics does not guarantee a particular internal representation of logical values on any machine or system; the CF90 compiler is designed on the assumption that logical values will be used only as described in the Fortran standard. Therefore, it is not good programming practice to exploit gaps in type checking, such as between a function reference and its function value, to use logical values as numbers or vice versa.

---

To declare an entity to be of logical type, you can specify one of the following:

Note that logical entities with KIND=1, KIND=2, KIND=4, and KIND=8 all occupy 64 bits.

Cray character pointers include a word address, bit offset, and bit length field.

Figure 5-10. 64-bit addressing for UNICOS systems (except CRAY T90 systems)

Figure 5-11. 64-bit addressing for CRAY T90 systems

The following sections describe integer data representation of KIND=1, 2, 4, and 8 on IRIX systems.

KIND=1

Range: -2⁷ < I < 2⁷ or approximately -10² < I < 10²

Figure 5-12. INTEGER(KIND=1) on IRIX systems

To declare 8-bit integers, specify one of the following:

• KIND=1.

• KIND=KIND(kind_expr), where kind_expr is a scalar initialization expression with a kind type parameter that evaluates to 1.

KIND=2

Range: -2¹⁵ < I < 2¹⁵ or approximately -10⁴ < I < 10⁴

Figure 5-13. INTEGER(KIND=2) on IRIX systems

To declare 16-bit integers, specify one of the following:

• KIND=2.

• KIND=KIND(kind_expr), where kind_expr is a scalar initialization expression with a kind type parameter that evaluates to 2.

KIND=4

Range: -2³¹ < I < 2³¹ or approximately -10⁹ < I < 10⁹

Figure 5-14. INTEGER(KIND=4) on IRIX systems

To declare 32-bit integers, specify one of the following:

• KIND=4.

• KIND=KIND(kind_expr), where kind_expr is a scalar initialization expression with a kind type parameter that evaluates to 4.

KIND=8

Range: -2⁶³ < I < 2⁶³ or approximately -10¹⁸ < I < 10¹⁸

Figure 5-15. INTEGER(KIND=8) on IRIX systems

To declare 64-bit integers, specify one of the following:

• KIND=8.

• KIND=KIND(kind_expr), where kind_expr is a scalar initialization expression with a kind type parameter that evaluates to 8.

The following sections describe real data representation of KIND=4, 8, and 16 on IRIX systems. Real (floating-point) numbers are represented in a packed representation of a sign, an exponent (power of 2), and a binary mantissa.

KIND=4

Range: -2^-125 .LE. I < 2¹²⁸ or approximately -10^-38 .LE. I < 10³⁸

Figure 5-16. REAL(KIND=4) on IRIX systems

To declare 32-bit reals, specify one of the following:

• KIND=4.

• KIND=KIND(kind_expr), where kind_expr is a scalar initialization expression with a kind type parameter that evaluates to 4.

Notes on real data type representation:

The exponent is a power of 2, represented by a number that is 177₈ higher than the actual value; this is called a bias. The effect of the bias is that the second bit in the word serves as the exponent's sign bit. This bit's usage is the inverse of the mantissa's sign bit, as follows:

Bit	Applies to	1 value indicates
31	Mantissa	Negative
30	Exponent	Positive ( > 0 )

The exponent is represented by the second through ninth digits in a binary printout; these digits have the range 01111111₂ through 11111110₂ for a positive exponent, and 00000000₂ through 01111110₂ for a negative exponent.

When the bias is accounted for, the range of all exponents is as follows:

• 2^-177 to 2¹⁷⁷ (octal)

  or

• 2^-127 to 2¹²⁷ (decimal)

The mantissa is a 24-bit fraction with an assumed leading 1; that is, the leading 1 is not stored. The only exception is for the value 0, which has an assumed leading 0. The sign of the mantissa is separated from the rest of the mantissa as shown in the preceding diagram. The mantissa is not complemented for negative values. That is, the mantissa for -10.0 is the same as for +10.0.

In terms of decimal values, the 32-bit floating-point format allows representation of numbers to about 7 significant decimal digits in the following approximate decimal range:

1.18 × 10^-38 < R < 3.4 × 10³⁸

A zero value is not biased and is represented as a word of all zeros.

The following are some sample numbers as represented within memory:

Decimal	Octal	Hexadecimal
10.0	010110000000	41200000
-10.0	030110000000	C1200000
0.1	007563146315	3DCCCCCD
-0.1	027563146315	BDCCCCCD

Figure 5-17. Binary version of 10.0

The leftmost bit, with a 0 value, indicates a positive mantissa; that is, the real value is positive. The next 8 bits (10000010, or decimal 130) are the exponent. Subtracting the bias of 127 yields an exponent of 3, meaning that the binary fraction in the mantissa is multiplied by 2³. To express it another way, the binary point is moved 3 bits to the right from the mantissa's highest bit. Interpreted this way, the first 4 bits of the mantissa, [1]010, indicate the real decimal value 10.0 (remember that there is an assumed 1 to the left of the mantissa in the IEEE floating-point format with a binary point to its immediate right). You can display other values by printing them with formats O11, Z8, or B32.

KIND=8

Double precision, REAL(KIND=8), values are represented in 2 words on IRIX systems.

Range: -2^-1021 .LE. I < 2¹⁰²⁴ or approximately -10^-308 .LE. I < 10³⁰⁸

Figure 5-18. REAL(KIND=8) on IRIX systems

To declare 64-bit reals, specify one of the following:

• KIND=8.

• KIND=KIND(kind_expr), where kind_expr is a scalar initialization expression with a kind type parameter that evaluates to 8.

KIND=16

Quad precision, REAL(KIND=16), values are represented in 4 words on IRIX systems. For more information on quad precision representation IRIX systems, see math(3m).

Range: -2^-967 .LE. I < 2¹⁰²³ or approximately -10^-292 .LE. I < 10³⁰⁸

Figure 5-19. REAL(KIND=16) on IRIX systems

To declare 128-bit reals, specify one of the following:

• KIND=16.

• KIND=KIND(kind_expr), where kind_expr is a scalar initialization expression with a kind type parameter that evaluates to 16.

The following sections describe complex data representation of KIND=4, 8, and 16 on IRIX systems. A complex value has two parts. The first part represents the real part, and the second represents the imaginary part. Each word has the same range as a real value.

KIND=4

A single-precision, KIND=4, complex value is represented by 2 words. The first word represents the real part, and the second represents the imaginary part. Each word has the same range as a real value.

Range: -2^-125 .LE. I < 2¹²⁸ or approximately -10³⁸ .LE. I < 10³⁸

Figure 5-20. COMPLEX(KIND=4) on IRIX systems (real portion)

Figure 5-21. COMPLEX(KIND=4) on IRIX systems (imaginary portion)

To declare an entity to be of single-precision, complex type, specify one of the following:

• KIND=4.

• KIND=KIND(kind_expr), where kind_expr is a scalar initialization expression with a kind type parameter that evaluates to 4.

KIND=8

A double-precision, KIND=8, complex value is represented by 4 words. The first 2 words represent the real part, and the second 2 words represent the imaginary part. Each word has the same range as a real value.

Range: -2^-1021 .LE. I < 2¹⁰²⁴ or approximately -10³⁰⁸ .LE. I < 10³⁰⁸

Figure 5-22. COMPLEX(KIND=8) on IRIX systems (real portion)

Figure 5-23. COMPLEX(KIND=8) on IRIX systems (imaginary portion)

To declare an entity to be of double-precision, complex type, specify one of the following:

• KIND=8.

• KIND=KIND(kind_expr), where kind_expr is a scalar initialization expression with a kind type parameter that evaluates to 8.

KIND=16

A quad precision, KIND=16, complex value is represented by 8 words. The first 4 words represent the real part, and the second 4 words represent the imaginary part. Each word has the same range as a real value.

Range: -2^-967 .LE. I < 2¹⁰²³ or approximately -10^-292 .LE. I < 10³⁰⁸

Figure 5-24. COMPLEX(KIND=16) on IRIX systems (real portion)

Figure 5-25. COMPLEX(KIND=16) on IRIX systems (imaginary portion)

To declare an entity to be of quad precision, complex type, specify one of the following:

• KIND=16.

• KIND=KIND(kind_expr), where kind_expr is a scalar initialization expression with a kind type parameter that evaluates to 16.

Characters are represented by 8-bit ASCII codes. On IRIX systems, the codes are stored in 1 byte.

Figure 5-26. Character type

The MIPSpro 7 Fortran 90 compiler does not support a nondefault character type. The only kind value supported is 1.

Logical entities specified as KIND=1, KIND=2, and KIND=4 occupy 32 bits on IRIX systems. Logical entities specified as KIND=8 occupy 64 bits on IRIX systems. Its value is true if the numeric value in the word is one (1). Its value is false if the numeric value in the word is zero (0).

---

Note:: Silicon Graphics does not guarantee a particular internal representation of logical values on any machine or system; the MIPSpro 7 Fortran 90 compiler is designed on the assumption that logical values will be used only as described in the Fortran standard. Therefore, it is not good programming practice to use logical values as numbers or vice versa.

---

To declare an entity to be of logical type, you can specify one of the following:

Cray character pointers include a byte address and a byte length field.

Figure 5-27. 32-bit addressing on IRIX systems

The following subsections describe integer data representation of KIND=1, 2, 4, and 8 on UNICOS/mk systems.

KIND=1, KIND=2, or KIND=4

Range: -2³¹ < I < 2³¹ or approximately -10⁹ < I < 10⁹

Figure 5-28. Integer KIND=1, 2, or 4 on UNICOS/mk systems

To declare 32-bit integers, specify one of the following:

• KIND=1, KIND=2, or KIND=4.

• KIND=KIND(kind_expr), where kind_expr is a scalar initialization expression with a kind type parameter that evaluates to 1, 2, or 4.

KIND=8

Range: -2⁶³ < I < 2⁶³ or approximately -10¹⁸ < I < 10¹⁸

Figure 5-29. INTEGER(KIND=8) on UNICOS/mk systems

To declare 64-bit integers, specify one of the following:

• KIND=8.

• KIND=KIND(kind_expr), where kind_expr is a scalar initialization expression with a kind type parameter that evaluates to 8.

The following sections describe real data representation of KIND=4 and 8. Real (floating-point) numbers are represented in a packed representation of a sign, an exponent (power of 2), and a binary mantissa.

KIND=4

Range: -2^-125 .LE. I < 2¹²⁸ or approximately -10^-38 .LE. I < 10³⁸

Figure 5-30. REAL(KIND=4) on UNICOS/mk systems

To declare 32-bit reals, specify one of the following:

• KIND=4.

• KIND=KIND(kind_expr), where kind_expr is a scalar initialization expression with a kind type parameter that evaluates to 4.

Notes on real data type representation:

The exponent is a power of 2, represented by a number that is 177₈ higher than the actual value; this is called a bias. The effect of the bias is that the second bit in the word serves as the exponent's sign bit. This bit's usage is the inverse of the mantissa's sign bit, as follows:

Bit	Applies to	1 value indicates
31	Mantissa	Negative
30	Exponent	Positive ( > 0 )

The exponent is represented by the second through ninth digits in a binary printout; these digits have the range 01111111₂ through 11111110₂ for a positive exponent, and 00000000₂ through 01111110₂ for a negative exponent.

When the bias is accounted for, the range of all exponents is as follows:

• 2^-177 to 2¹⁷⁷ (octal)

  or

• 2^-127 to 2¹²⁷ (decimal)

The mantissa is a 24-bit fraction with an assumed leading 1; that is, the leading 1 is not stored. The only exception is for the value 0, which has an assumed leading 0. The sign of the mantissa is separated from the rest of the mantissa as shown in the preceding diagram. The mantissa is not complemented for negative values. That is, the mantissa for -10.0 is the same as for +10.0.

In terms of decimal values, the 32-bit floating-point format allows representation of numbers to about 7 significant decimal digits in the following approximate decimal range:

1.18 × 10^-38 < R < 3.4 × 10³⁸

A zero value is not biased and is represented as a word of all zeros.

The following are some sample numbers as represented within memory:

Decimal	Octal	Hexadecimal
10.0	010110000000	41200000
-10.0	030110000000	C1200000
0.1	007563146315	3DCCCCCD
-0.1	027563146315	BDCCCCCD

Figure 5-31. Binary version of 10.0

The leftmost bit, with a 0 value, indicates a positive mantissa; that is, the real value is positive. The next 8 bits (10000010, or decimal 130) are the exponent. Subtracting the bias of 127 yields an exponent of 3, meaning that the binary fraction in the mantissa is multiplied by 2³; to express it another way, the binary point is moved 3 bits to the right from the mantissa's highest bit. Interpreted this way, the first 4 bits of the mantissa, [1]010, indicate the real decimal value 10.0; remember that there is an assumed 1 to the left of the mantissa in the IEEE floating-point format with a binary point to its immediate right. You can display other values by printing them with formats O11, Z8, or B32.

KIND=8

Range: -2^-1021 .LE. I < 2¹⁰²⁴ or approximately -10^-308 .LE. I < 10³⁰⁸

Figure 5-32. REAL(KIND=8) on UNICOS/mk systems

To declare 64-bit reals, specify one of the following:

• KIND=8.

• KIND=KIND(kind_expr), where kind_expr is a scalar initialization expression with a kind type parameter that evaluates to 8.

The following sections describe complex data representation of KIND=4 and KIND=8 on UNICOS/mk systems. A complex value has two parts. The first part represents the real part, and the second represents the imaginary part. Each word has the same range as a real value.

KIND=4

A KIND=4 complex value consists of 2 parts. The first part represents the real portion, and the second represents the imaginary portion. Each part has the same range as a 32-bit (or KIND=4) real value.

Range: -2^-125 .LE. I < 2¹²⁸ or approximately -10^-38 .LE. I <10³⁸

Figure 5-33. COMPLEX(KIND=4) on UNICOS/mk systems (real portion)

Figure 5-34. COMPLEX(KIND=4) on UNICOS/mk systems (imaginary portion)

To declare an entity to be of complex type with a total length of 64 bits, specify one of the following:

• KIND=4.

• KIND=KIND(kind_expr), where kind_expr is a scalar initialization expression with a kind type parameter that evaluates to 4.

KIND=8

A single-precision, KIND=8, complex value is represented by 2 words. The first word represents the real part, and the second represents the imaginary part. Each word has the same range as a 64-bit (or KIND=8) real value.

Range: -2^-1021 .LE. I < 2¹⁰²⁴ or approximately -10^-308 .LE. I < 10³⁰⁸

Figure 5-35. COMPLEX(KIND=8) on UNICOS/mk systems (real portion)

Figure 5-36. COMPLEX(KIND=8) on UNICOS/mk systems (imaginary portion)

To declare an entity to be of single-precision, complex type, specify one of the following:

• KIND=8.

• KIND=KIND(kind_expr), where kind_expr is a scalar initialization expression with a kind type parameter that evaluates to 8.

Characters are represented by 8-bit ASCII codes. On UNICOS/mk systems, the codes are packed 8 per word.

Figure 5-37. Character type

The CF90 compiler does not support a nondefault character type. The only kind value supported is 1.

A logical variable uses one word. Its value is true if the numeric value in the word is nonzero, and it is false if the numeric value in the word is zero.

---

Note:: Silicon Graphics does not guarantee a particular internal representation of logical values on any machine or system; the CF90 compiler is designed on the assumption that logical values will be used only as described in the Fortran standard. Therefore, it is not good programming practice to use logical values as numbers or vice versa.

---

To declare an entity to be of logical type, you can specify one of the following:

On UNICOS/mk systems, all KIND=1, 2, and 4 occupy 32 bits. The KIND=8 specification occupies 64 bits.

Cray character pointers include a byte address and a byte length field. On UNICOS/mk systems, character pointers are 128-bit objects, as follows:

Figure 5-38. Cray character pointers on UNICOS/mk systems

The following sections describe integer data representation of KIND=1, 2, 4, and 8 on CRAY T90 systems that support IEEE floating-point arithmetic.

KIND=1, KIND=2, or KIND=4

Range: -2³¹ < I < 2³¹ or approximately -10⁹ < I < 10⁹

Figure 5-39. Integer KIND=1, 2, or 4 on CRAY T90 systems that support IEEE floating-point arithmetic

To declare 32-bit integers, specify one of the following:

• KIND=1, KIND=2, or KIND=4.

• KIND=KIND(kind_expr), where kind_expr is a scalar initialization expression with a kind type parameter that evaluates to 1, 2, or 4.

KIND=8

By default, the range for INTEGER(KIND=8) operations is -2⁶³ < I < 2⁶³ or approximately -10¹⁸ < I < 10¹⁸. When fast integer operations are specified on the f90(1) command line, the range for INTEGER(KIND=8) operations is -2⁵⁰ < I < 2⁵⁰ or approximately -10¹⁵ < I < 10¹⁵.

Figure 5-40. Default INTEGER(KIND=8) on CRAY T90 systems that support IEEE floating-point arithmetic

Figure 5-41. Fast operations with INTEGER(KIND=8) on CRAY T90 systems that support IEEE floating-point arithmetic

To declare 64-bit integers, specify one of the following:

• KIND=8.

• KIND=KIND(kind_expr), where kind_expr is a scalar initialization expression with a kind type parameter that evaluates to 8.

The following sections describe real data representation of KIND=4, 8, and 16 on CRAY T90 systems that support IEEE floating-point arithmetic. Real (floating-point) numbers are represented in a packed representation of a sign, an exponent (power of 2), and a binary mantissa.

KIND=4 and KIND=8

Range: -2^-1021 .LE. I < 2¹⁰²⁴ or approximately -10^-308 .LE. I < 10³⁰⁸

Figure 5-42. Real KIND=4 or 8 on CRAY T90 systems that support IEEE floating-point arithmetic

To declare 64-bit reals, specify one of the following:

• KIND=4 or KIND=8.

• KIND=KIND(kind_expr), where kind_expr is a scalar initialization expression with a kind type parameter that evaluates to 4 or 8.

For additional information on how real data is represented on CRAY T90 systems that support IEEE floating-point arithmetic, see "Notes on real data type representation" in “KIND=4”. The information presented there for UNICOS/mk systems applies to CRAY T90 systems that support IEEE floating-point arithmetic.

Note that a real data object with KIND=4 has the same internal representation as a real data object with KIND=8. Numeric inquiry functions on a real data object with KIND=4 return different values than on a real data object with KIND=8. A numeric operation on a real data object with KIND=4 returns the same result as the same numeric operation on a real data object with KIND=8.

KIND=16

Double precision, REAL(KIND=16), values are represented in 2 words on CRAY T90 systems that support IEEE floating-point arithmetic.

Range: -2^-16381 .LE. I < 2¹⁶³⁸⁴ or approximately -10^-4932 .LE. I < 10⁴⁹³²

Figure 5-43. REAL(KIND=16) on CRAY T90 systems that support IEEE floating-point arithmetic

To declare 64-bit reals, specify one of the following:

• KIND=16.

• KIND=KIND(kind_expr), where kind_expr is a scalar initialization expression with a kind type parameter that evaluates to 16.

The following sections describe complex data representation of KIND=4, 8, and 16 on CRAY T90 systems that support IEEE floating-point arithmetic. A complex value has two parts. The first part represents the real part, and the second represents the imaginary part. Each word has the same range as a real value.

KIND=4 and KIND=8

A single-precision, KIND=4 or KIND=8, complex value is represented by 2 words. The first word represents the real part, and the second represents the imaginary part. Each word has the same range as a real value.

Range: -2^-1021 .LE. I < 2¹⁰²⁴ or approximately -10^-308 .LE. I < 10³⁰⁸

Figure 5-44. Complex KIND=8 or 4 on CRAY T90 systems that support IEEE floating-point arithmetic (real portion)

Figure 5-45. Complex KIND=8 or 4 on CRAY T90 systems that support IEEE floating-point arithmetic (imaginary portion)

To declare an entity to be of single-precision, complex type, specify one of the following:

• KIND=4 or KIND=8.

• KIND=KIND(kind_expr), where kind_expr is a scalar initialization expression with a kind type parameter that evaluates to 4 or 8.

Note that a complex data object with KIND=4 has the same internal representation as a complex data object with KIND=8. Numeric inquiry functions on a complex data object with KIND=4 return different values than on a complex data object with KIND=8. A numeric operation on a complex data object with KIND=4 returns the same result as the same numeric operation on a complex data object with KIND=8.

KIND=16

A double-precision, KIND=16, complex value is represented by 4 words. The first two words represent the real part, and the second two words represent the imaginary part. Each word has the same range as a real value.

Range: -2^-16381 .LE. I < 2¹⁶³⁸⁴ or approximately -10^-4932 .LE. I < 10⁴⁹³²

Figure 5-46. COMPLEX(KIND=16) on CRAY T90 systems that support IEEE floating-point arithmetic (real portion)

Figure 5-47. COMPLEX(KIND=16) on CRAY T90 systems that support IEEE floating-point arithmetic (imaginary portion)

To declare an entity to be of double-precision, complex type, specify one of the following:

• KIND=16.

• KIND=KIND(kind_expr), where kind_expr is a scalar initialization expression with a kind type parameter that evaluates to 16.

Characters are represented by 8-bit ASCII codes. The codes are packed 8 per word.

Figure 5-48. Character type

The CF90 compiler does not support a nondefault character type. The only kind value supported is 1.

A logical variable uses one word. Its value is true if the numeric value in the word is nonzero, and it is false if the numeric value in the word is zero.

---

Note:: Silicon Graphics does not guarantee a particular internal representation of logical values on any machine or system; the CF90 compiler is designed on the assumption that logical values will be used only as described in the Fortran standard. Therefore, it is not good programming practice to use logical values as numbers or vice versa.

---

To declare an entity to be of logical type, you can specify one of the following:

On CRAY T90 systems that support IEEE floating-point arithmetic, all KIND=1, KIND=2, and KIND=4 specifications occupy 32 bits. The KIND=8 specification occupies 64 bits.

Cray character pointers are two words in length. The first word includes an offset and an address. The second word includes the byte length field.

Figure 5-49. Cray character pointer for CRAY T90 systems that support IEEE floating-point arithmetic

A numeric storage unit can be one of the following:

A character storage unit is an 8-bit byte.

A storage sequence is a contiguous group of storage units with a consecutive series of addresses. Each array and each common block is stored in a storage sequence. The size of a storage sequence is the number of storage units it contains. Two storage sequences are associated if they share at least one storage unit.

All nondefault types have an unspecified storage unit. The -s default32 option on the f90(1) command line changes the number of bits in a numeric storage unit for UNICOS/mk systems. There is no longer a relationship between storage units after this command line option is used.

The following list shows the storage units for the default types on UNICOS systems:

Complex values occupy twice the storage of real values. The real portion of the complex value occupies the first half of the total storage; the imaginary portion of the complex value occupies the second half of the total storage, as follows:

A character value is represented as an 8-bit ASCII code, packed 8 characters per word on UNICOS and UNICOS/mk systems; this value is packed 4 characters per byte on IRIX systems. The storage size depends on the length specification of the value.

---

Note: The Fortran standard does not specify the relationship between storage units and computer words, and it does not specify any relation between default numeric and character storage units.

---

With static storage, any variable that is allocated memory occupies the same address throughout program execution. Allocation is determined before program execution.

Code using static storage can be used with Autotasking, multitasking, and macrotasking if variables in static storage conform to the following guidelines:

For more information on Autotasking directives, see the CF90 Commands and Directives Reference Manual, or the MIPSpro 7 Fortran 90 Commands and Directives Reference Manual. For more information on locks, see the LOCKON(3f) or LOCKOFF(3f) man pages.

Stack storage is the default storage allocation for the CF90 compiler on UNICOS and UNICOS/mk systems. On IRIX systems, stack storage is the MIPSpro 7 Fortran 90 default for all subprograms, but static storage is the default for items that require 256 bits of storage in a main program. The stack is an area of memory where storage for variables is allocated when a subprogram or procedure begins execution. These variables are released when execution completes. The stack expands and contracts as procedures are entered and exited. Autotasking and recursion require a stack.

When stack storage is used, the value of a variable is not saved between invocations of a subprogram unless it is specified in a SAVE or DATA statement. When f90 -e v (UNICOS and UNICOS/mk systems) or f90 -static (IRIX systems) is specified, all user variables are treated as if they appeared in a SAVE statement. When -e v or -static is in effect, compiler-generated temporary variables and the calling sequence are still allocated to the stack.

---

Note:: If f90 -e i is specified, variables are reset for each invocation of a subprogram, even in static storage. Therefore, the SAVE or DATA statement is necessary to preserve the value of a variable between invocations. This information applies only to UNICOS and UNICOS/mk systems.

---

The way in which the amount of memory available for the stack is determined depends on your platform. On UNICOS and UNICOS/mk systems, it is determined by the STACK directive, available with the segldr(1) or cld(1) loaders; see the segldr(1) or cld(1) man pages for more information. On IRIX systems, you can use the limit(1) command to change the amount of stack space that a program is allowed; see the limit(1) man page for more information.

A heap is memory that, like a stack, is dynamically allocated; it is used internally.

The CF90 and MIPSpro 7 Fortran 90 compilers allocate variables to storage according to the following criteria:

Many FORTRAN 77 programs contain a memory allocation scheme that expands an array in a common block located in central memory at the end of the program. This practice of expanding a blank common block or expanding a dynamic common block (sometimes referred to as overindexing) causes conflicts between user management of memory and the dynamic memory requirements of UNICOS libraries. It is recommended that you modify programs rather than expand blank common blocks, particularly when migrating from other environments.

Figure 5-50, shows the structure of a program under the UNICOS operating system in relation to expanding a blank common block. In both figures, the user area includes code, data, and common blocks.

Figure 5-50. Memory use under UNICOS

There are two ways to change your code. The standard method, shown in “Changing Your Code: Standard Method” is preferred.

      PROGRAM TEST
C Puts array X in blank common:
      COMMON X(1)
...
C Adds 100000 words to blank common:
      CALL MEMORY ('UC',100000)
...
      DO 10, I=1,100000
        X(I) = RANF()
10    CONTINUE
...

      MODULE GLOBAL_DATA              ! STEP 1
      REAL, SAVE, ALLOCATABLE :: X(:)
      END MODULE
...
      PROGRAM TEST
      USE GLOBAL_DATA                 ! STEP 2
      LIMIT = 100000
      ALLOCATE (X(LIMIT))             ! STEP 3
...
      DO 10 I = 1,LIMIT
        X(I) = RANF()
10    CONTINUE
...
      END

      PROGRAM TEST
C Puts array X in blank common:
      COMMON X(1)
...
C Adds 100000 words to blank common:
      CALL MEMORY ('UC',100000)
...
      DO 10, I=1,100000
        X(I) = RANF()
10    CONTINUE
...

      PROGRAM TEST
      COMMON /WORK/ IPTR
...
C Establish array location at runtime:
      POINTER (IPTR,X(1))
...
C Effective common block size:
      CALL HPALLOC (IPTR,100000,ERRCODE,0)
...
      DO 10 I=1,100000
        X(I) = RANF()
10    CONTINUE
...