HP Fortran for OpenVMS
Language Reference Manual


Previous Contents Index

3.2.2 Real Data Types

Real data types can be specified as follows:

  • REAL
  • REAL([KIND=]n)
  • REAL*n
  • DOUBLE PRECISION

n

Is kind 4, 8, or 16.

If a kind parameter is specified, the real constant has the kind specified. If a kind parameter is not specified, the kind is default real.

DOUBLE PRECISION is REAL(8). No kind parameter is permitted for data declared with type DOUBLE PRECISION.

3.2.2.1 General Rules for Real Constants

A real constant approximates the value of a mathematical real number. The value of the constant can be positive, zero, or negative.

The following is the general form of a real constant with no exponent part:

[s]n[n...][ _k]

A real constant with an exponent part has one of the following forms:

  • [s]n[n...]E[s]nn...[ _k]
  • [s]n[n...]D[s]nn...
  • [s]n[n...]Q[s]nn...

s

Is a sign; required if negative (--), optional if positive (+).

n

Is a decimal digit (0 through 9). A decimal point must appear if the real constant has no exponent part.

k

Is the optional kind parameter: 4 for REAL(4), 8 for REAL(8), or 16 for REAL(16). It must be preceded by an underscore (_).

Rules and Behavior

Leading zeros (zeros to the left of the first nonzero digit) are ignored in counting significant digits. For example, in the constant 0.00001234567, all of the nonzero digits, and none of the zeros, are significant. (See the following sections for the number of significant digits each kind type parameter typically has).

The exponent represents a power of 10 by which the preceding real or integer constant is to be multiplied (for example, 1.0E6 represents the value 1.0 * 10**6).

A real constant with no exponent part and no kind type parameter is (by default) a single-precision (REAL(4)) constant. You can change the default behavior by specifying the compiler option that controls the default real kind.

If the real constant has no exponent part, a decimal point must appear in the string (anywhere before the optional kind parameter). If there is an exponent part, a decimal point is optional in the string preceding the exponent part; the exponent part must not contain a decimal point.

The exponent letter E denotes a single-precision real (REAL(4)) constant, unless the optional kind parameter specifies otherwise. For example, --9.E2_8 is a double-precision constant (which can also be written as --9.D2).

The exponent letter D denotes a double-precision real (REAL(8)) constant.

The exponent letter Q denotes a quad-precision real (REAL(16)) constant.

A minus sign must appear before a negative real constant; a plus sign is optional before a positive constant. Similarly, a minus sign must appear between the exponent letter (E, D, or Q ) and a negative exponent, whereas a plus sign is optional between the exponent letter and a positive exponent.

If the real constant includes an exponent letter, the exponent field cannot be omitted, but it can be zero.

To specify a real constant using both an exponent letter and a kind parameter, the exponent letter must be E, and the kind parameter must follow the exponent part.

3.2.2.2 REAL(4) Constants

A single-precision REAL constant occupies four bytes of memory. The number of digits is unlimited, but typically only the leftmost seven digits are significant.

Either VAX F_floating or IEEE S_floating format is used, depending on the compiler option specified.

Examples

The following examples show valid and invalid REAL(4) constants:
Valid  
3.14159  
3.14159_4  
621712._4  
-.00127  
+5.0E3  
2E-3_4  
Invalid Explanation
1,234,567. Commas not allowed.
325E-47 Too small for REAL; this is a valid DOUBLE PRECISION constant.
-47.E47 Too large for REAL; this is a valid DOUBLE PRECISION constant.
625._6 6 is not a valid kind for reals.
100 Decimal point missing; this is a valid integer constant.
$25.00 Special character not allowed.

For More Information:

3.2.2.3 REAL(8) or DOUBLE PRECISION Constants

A REAL(8) or DOUBLE PRECISION constant has more than twice the accuracy of a REAL(4) number, and greater range.

A REAL(8) or DOUBLE PRECISION constant occupies eight bytes of memory. The number of digits that precede the exponent is unlimited, but typically only the leftmost 15 digits are significant.

Either VAX D_floating, G_floating, or IEEE T_floating format is used, depending on the compiler option specified.

Examples

The following examples show valid and invalid REAL(8) or DOUBLE PRECISION constants:
Valid  
123456789D+5  
123456789E+5_8  
+2.7843D00  
-.522D-12  
2E200_8  
2.3_8  
3.4E7_8  
Invalid Explanation
-.25D0_2 2 is not a valid kind for reals.
+2.7182812846182 No D exponent designator is present;
this is a valid single-precision constant.
1234567890D45 Too large for D_floating format; valid for G_floating and T_floating format.
123456789.D400 Too large for any double-precision format.
123456789.D-400 Too small for any double-precision format.

For More Information:

3.2.2.4 REAL(16) Constants

A REAL(16) constant has more than four times the accuracy of a REAL(4) number, and a greater range.

A REAL(16) constant occupies 16 bytes of memory. The number of digits that precede the exponent is unlimited, but typically only the leftmost 33 digits are significant.

Examples

The following examples demonstrate valid and invalid REAL(16) constants:
Valid  
123456789Q4000  
-1.23Q-400  
+2.72Q0  
1.88_16  
Invalid Explanation
1.Q5000 Too large.
1.Q-5000 Too small.

For More Information:

3.2.3 Complex Data Types

Complex data types can be specified as follows:

  • COMPLEX
  • COMPLEX([KIND=]n)
  • COMPLEX*s
  • DOUBLE COMPLEX

n

Is kind 4, 8, or 16.

s

Is 8, 16, or 32. COMPLEX(4) is specified as COMPLEX*8; COMPLEX(8) is specified as COMPLEX*16; COMPLEX(16) is specified as COMPLEX*32.

If a kind parameter is specified, the complex constant has the kind specified. If no kind parameter is specified, the kind of both parts is default real, and the constant is of type default complex.

DOUBLE COMPLEX is COMPLEX(8). No kind parameter is permitted for data declared with type DOUBLE COMPLEX.

3.2.3.1 General Rules for Complex Constants

A complex constant approximates the value of a mathematical complex number. The constant is a pair of real or integer values, separated by a comma, and enclosed in parentheses. The first constant represents the real part of that number; the second constant represents the imaginary part.

The following is the general form of a complex constant:

(c,c)

c

Is as follows:

Note that the comma and parentheses are required.

3.2.3.2 COMPLEX(4) Constants

A COMPLEX(4) constant is a pair of integer or single-precision real constants that represent a complex number.

A COMPLEX(4) constant occupies eight bytes of memory and is interpreted as a complex number.

If the real and imaginary part of a complex literal constant are both real, the kind parameter value is that of the part with the greater decimal precision.

The rules for REAL(4) constants apply to REAL(4) constants used in COMPLEX constants. (See Sections 3.2.2.1 and 3.2.2.2 for the rules on forming REAL(4) constants.)

The REAL(4) constants in a COMPLEX constant have one of the following formats: VAX F_floating or IEEE S_floating format (depending on the hardware (Itanium or Alpha) and the compiler option specified).

Examples

The following examples demonstrate valid and invalid COMPLEX(4) constants:
Valid  
(1.7039,-1.70391)  
(44.36_4,-12.2E16_4)  
(+12739E3,0.)  
(1,2)  
Invalid Explanation
(1.23,) Missing second integer or single-precision real constant.
(1.0, 2H12) Hollerith constant not allowed.

For More Information:

3.2.3.3 COMPLEX(8) or DOUBLE COMPLEX Constants

A COMPLEX(8) or DOUBLE COMPLEX constant is a pair of constants that represents a complex number. One of the pair must be a double-precision real constant, the other can be an integer, single-precision real, or double-precision real constant.

A COMPLEX(8) or DOUBLE COMPLEX constant occupies 16 bytes of memory and is interpreted as a complex number.

The rules for DOUBLE PRECISION (REAL(8)) constants also apply to the double precision portion of COMPLEX(8) or DOUBLE COMPLEX constants. (See Sections 3.2.2.1 and 3.2.2.3 for the rules on forming DOUBLE PRECISION constants.)

The DOUBLE PRECISION constants in a COMPLEX(8) or DOUBLE COMPLEX constant have one of the following formats: VAX D_floating, G_floating, or IEEE T_floating format (depending on the hardware (Itanium or Alpha) and the compiler option specified).

Examples

The following examples demonstrate valid and invalid COMPLEX(8) or DOUBLE COMPLEX constants:
Valid  
(1.7039,-1.7039D0)  
(547.3E0_8,-1.44_8)  
(1.7039E0,-1.7039D0)  
(+12739D3,0.D0)  
Invalid Explanation
(1.23D0,) Second constant missing.
(1D1,2H12) Hollerith constants not allowed.
(1,1.2) Neither constant is DOUBLE PRECISION; this is a valid single-precision constant.

For More Information:

3.2.3.4 COMPLEX(16) Constants

A COMPLEX(16) constant is a pair of constants that represents a complex number. One of the pair must be a REAL(16) constant, the other can be an integer, single-precision real, or double-precision real constant.

A COMPLEX(16) constant occupies 32 bytes of memory and is interpreted as a complex number.

The rules for REAL(16) constants apply to REAL(16) constants used in COMPLEX(16) constants. (See Sections 3.2.2.1 and 3.2.2.4 for the rules on forming REAL(16) constants.)

The REAL(16) constants in a COMPLEX(16) constant have one of the following formats: VAX X_floating or IEEE X_floating format (depending on the hardware (Itanium or Alpha) and the compiler option specified)

Examples

The following examples demonstrate valid and invalid COMPLEX(16) constants:
Valid  
(1.7039,-1.7039Q2)  
(547.3E0_16,-1.44)  
(+12739Q3,0.Q0)  
Invalid Explanation
(1.23Q0,) Second constant missing.
(1D1,2H12) Hollerith constants not allowed.
(1.7039,-1.7039D0) Neither constant is REAL(16); this is a valid double-precision constant.

For More Information:

3.2.4 Logical Data Types

Logical data types can be specified as follows:

  • LOGICAL
  • LOGICAL([KIND=]n)
  • LOGICAL*n

n

Is kind 1, 2, 4, or 8.

If a kind parameter is specified, the logical constant has the kind specified. If no kind parameter is specified, the kind of the constant is default logical.

Logical Constants

A logical constant represents only the logical values true or false, and takes one of the following forms:

  • .TRUE.[ _k]
  • .FALSE.[ _k]

k

Is the optional kind parameter: 1 for LOGICAL(1), 2 for LOGICAL(2), 4 for LOGICAL(4), or 8 for LOGICAL(8). It must be preceded by an underscore (_).

Logical data type ranges correspond to their comparable integer data type ranges. For example, the LOGICAL(2) range is the same as the INTEGER(2) range.

For More Information:

On integer data type ranges, see the HP Fortran for OpenVMS User Manual.

3.2.5 Character Data Type

The character data type can be specified as follows:

  • CHARACTER
  • CHARACTER([KIND=]n)
  • CHARACTER ([LEN=]len)
  • CHARACTER ([LEN=]len [,[KIND=]n])
  • CHARACTER (KIND=n [,LEN=len])
  • CHARACTER*len[,]

n

Is kind 1.

len

Is a string length (not a kind). For more information, see Section 5.1.2.

If no kind type parameter is specified, the kind of the constant is default character.

Character Constants

A character constant is a character string enclosed in delimiters (apostrophes or quotation marks). It takes one of the following forms:

  • [k_ ]'[ch...]'[C]
  • [k_ ]"[ch...]"[C]

k

Is the optional kind parameter: 1 (the default). It must be followed by an underscore (_). Note that in character constants, the kind must precede the constant.

ch

Is an ASCII character.

C

Is a C string specifier. C strings can be used to define strings with nonprintable characters. For more information, see Section 3.2.5.1.

Rules and Behavior

The value of a character constant is the string of characters between the delimiters. The value does not include the delimiters, but does include all blanks or tabs within the delimiters.

If a character constant is delimited by apostrophes, use two consecutive apostrophes ( '' ) to place an apostrophe character in the character constant.

Similarly, if a character constant is delimited by quotation marks, use two consecutive quotation marks ("") to place a quotation mark character in the character constant.

The length of the character constant is the number of characters between the delimiters, but two consecutive delimiters are counted as one character.

The length of a character constant must be in the range of 0 to 2000. Each character occupies one byte of memory.

If a character constant appears in a numeric context (such as an expression on the right side of an arithmetic assignment statement), it is considered a Hollerith constant.

A zero-length character constant is represented by two consecutive apostrophes or quotation marks.

Examples

The following examples demonstrate valid and invalid character constants:
Valid  
"WHAT KIND TYPE? "  
'TODAY''S DATE IS: '  
"The average is: "  
''  
Invalid Explanation
'HEADINGS No trailing apostrophe.
'Map Number:" Beginning delimiter does not match ending delimiter.

For More Information:

On declaring data of type character, see Section 5.1.2.


Previous Next Contents Index