HP OpenVMS Systems Documentation

HP Fortran for OpenVMS
Language Reference Manual

Binary, octal, hexadecimal, and Hollerith constants are nondecimal constants. They have no intrinsic data type, but assume a numeric data type depending on their use.

Fortran 95/90 allows unsigned binary, octal, and hexadecimal constants to be used in DATA statements; the constant must correspond to an integer scalar variable.

In HP Fortran, binary, octal, hexadecimal, and Hollerith constants can appear wherever numeric constants are allowed.

3.4.1 Binary Constants

A binary constant is an alternative way to represent a numeric constant. A binary constant takes one of the following forms:

d

Is a binary (base 2) digit (0 or 1).

You can specify up to 256 binary digits in a binary constant. Leading zeros are ignored.

Examples

The following examples demonstrate valid and invalid binary constants:

An octal constant is an alternative way to represent numeric constants. An octal constant takes one of the following forms:

d

Is an octal (base 8) digit (0 through 7).

You can specify up to 256 bits in octal (86 octal digits) constants. Leading zeros are ignored.

Examples

The following examples demonstrate valid and invalid octal constants:

For More Information:

On an alternative form for octal constants, see Section B.7.

3.4.3 Hexadecimal Constants

A hexadecimal constant is an alternative way to represent numeric constants. A hexadecimal constant takes one of the following forms:

d

Is a hexadecimal (base 16) digit (0 through 9, or an uppercase or lowercase letter in the range of A to F).

You can specify up to 256 bits in hexadecimal (64 hexadecimal digits) constants. Leading zeros are ignored.

Examples

The following examples demonstrate valid and invalid hexadecimal constants:

For More Information:

On an alternative form for hexadecimal constants, see Section B.7.

3.4.4 Hollerith Constants

Binary, octal, hexadecimal, and Hollerith constants have no intrinsic data type. These constants assume a numeric data type depending on their use.

When the constant is used with a binary operator (including the assignment operator), the data type of the constant is the data type of the other operand. For example:

When a specific data type (generally integer) is required, that type is assumed for the constant. For example:

When a nondecimal constant is used as an actual argument, the following occurs:

• For binary, octal, and hexadecimal constants, INTEGER(8) is assumed.
• For Hollerith constants, no data type is assumed.

For example:

When a binary, octal, or hexadecimal constant is used in any other context, the default integer data type is assumed (default integer can be affected by compiler options). In the following examples, default integer is INTEGER(4):

When nondecimal constants are not the same length as the length implied by a data type, the following occurs:

• Binary, octal, and hexadecimal constants
  These constants can specify up to 16 bytes of data. When the length of the constant is less than the length implied by the data type, the leftmost digits have a value of zero.
  When the length of the constant is greater than the length implied by the data type, the constant is truncated on the left. An error results if any nonzero digits are truncated.
  Table 15-2 lists the number of bytes that each data type requires.
• Hollerith constants
  When the length of the constant is less than the length implied by the data type, blanks are appended to the constant on the right.
  When the length of the constant is greater than the length implied by the data type, the constant is truncated on the right. If any characters other than blank characters are truncated, an error occurs.
  Each Hollerith character occupies one byte of memory.

For More Information:

On compiler options, see the HP Fortran for OpenVMS User Manual.

3.5 Variables

A variable is a data object whose value can be changed at any point in a program. A variable can be any of the following:

• A scalar
  A scalar is a single object that has a single value; it can be of any intrinsic or derived (user-defined) type.
• An array
  An array is a collection of scalar elements of any intrinsic or derived type. All elements must have the same type and kind parameters.
• A subobject designator
  A subobject is part of an object. The following are subobjects:

  An array element
  An array section
  A structure component
  A character substring

  
  For example, B(3) is a subobject (array element) designator for array B. A subobject cannot be a variable if its parent object is a constant.

The name of a variable is associated with a single storage location.

Variables are classified by data type, as constants are. The data type of a variable indicates the type of data it contains, including its precision, and implies its storage requirements. When data of any type is assigned to a variable, it is converted to the data type of the variable (if necessary).

A variable is defined when you give it a value. A variable can be defined before program execution by a DATA statement or a type declaration statement. During program execution, variables can be defined or redefined in assignment statements and input statements, or undefined (for example, if an I/O error occurs). When a variable is undefined, its value is unpredictable.

When a variable becomes undefined, all variables associated by storage association also become undefined.

For More Information:

• On arrays, see Section 3.5.2.
• On storage association of variables, see Section 15.5.3.
• On type declaration statements, see Section 5.1.
• On the DATA statement, see Section 5.5.
• On the data type of a numeric expression, see Section 4.1.1.2.

The data type of a scalar variable can be explicitly declared in a type declaration statement. If no type is declared, the variable has an implicit data type based on predefined typing rules or definitions in an IMPLICIT statement.

An explicit declaration of data type takes precedence over any implicit type. Implicit type specified in an IMPLICIT statement takes precedence over predefined typing rules.

3.5.1.1 Specification of Data Type

Type declaration statements explicitly specify the data type of scalar variables. For example, the following statements associate VAR1 with an 8-byte complex storage location, and VAR2 with an 8-byte double-precision storage location:

COMPLEX VAR1
DOUBLE PRECISION VAR2

You can explicitly specify the data type of a scalar variable only once.

If no explicit data type specification appears, any variable with a name that begins with the letter in the range specified in the IMPLICIT statement becomes the data type of the variable.

Character type declaration statements specify that given variables represent character values with the length specified. For example, the following statements associate the variable names INLINE, NAME, and NUMBER with storage locations containing character data of lengths 72, 12, and 9, respectively:

CHARACTER*72 INLINE
CHARACTER NAME*12, NUMBER*9

In single subprograms, assumed-length character arguments can be used to process character strings with different lengths. The assumed-length character argument has its length specified with an asterisk, for example:

CHARACTER*(*) CHARDUMMY

The argument CHARDUMMY assumes the length of the actual argument.

For More Information:

• On type declaration statements, see Section 5.1.
• On character type declaration statements, see Section 5.1.2.
• On assumed-length character arguments, see Section 8.8.4.
• On the IMPLICIT statement, see Section 5.9.

By default, all scalar variables with names beginning with I, J, K, L, M, or N are assumed to be default integer variables. Scalar variables with names beginning with any other letter are assumed to be default real variables. For example:

Names beginning with a dollar sign ($) are implicitly INTEGER.

You can override the default data type implied in a name by specifying data type in either an IMPLICIT statement or a type declaration statement.

For More Information:

• On type declaration statements, see Section 5.1.
• On the IMPLICIT statement, see Section 5.9.

An array is a set of scalar elements that have the same type and kind parameters. Any object that is declared with an array specification is an array. Arrays can be declared by using a type declaration statement, or by using a DIMENSION, COMMON, ALLOCATABLE, POINTER, or TARGET statement.

An array can be referenced by element (using subscripts), by section (using a section subscript list), or as a whole. A subscript list (appended to the array name) indicates which array element or array section is being referenced.

A section subscript list consists of subscripts, subscript triplets, or vector subscripts. At least one subscript in the list must be a subscript triplet or vector subscript.

When an array name without any subscripts appears in an intrinsic operation (for example, addition), the operation applies to the whole array (all elements in the array).

An array has the following properties:

• Data type
  An array can have any intrinsic or derived type. The data type of an array (like any other variable) is specified in a type declaration statement or implied by the first letter of its name. All elements of the array have the same type and kind parameters. If a value assigned to an individual array element is not the same as the type of the array, it is converted to the array's type.
• Rank
  The rank of an array is the number of dimensions in the array. An array can have up to seven dimensions. A rank-one array represents a column of data (a vector), a rank-two array represents a table of data arranged in columns and rows (a matrix), a rank-three array represents a table of data on multiple pages (or planes), and so forth.
• Bounds
  Arrays have a lower and upper bound in each dimension. These bounds determine the range of values that can be used as subscripts for the dimension. The value of either bound can be positive, negative, or zero.
  The bounds of a dimension are defined in an array specification.
• Size
  The size of an array is the total number of elements in the array (the product of the array's extents).
  The extent is the total number of elements in a particular dimension. It is determined as follows: upper bound - lower bound + 1. If the value of any of an array's extents is zero, the array has a size of zero.
• Shape
  The shape of an array is determined by its rank and extents, and can be represented as a rank-one array (vector) where each element is the extent of the corresponding dimension.
  Two arrays with the same shape are said to be conformable. A scalar is conformable to an array of any shape.

The name and rank of an array must be specified when the array is declared. The extent of each dimension can be constant, but does not need to be. The extents can vary during program execution if the array is a dummy argument array, an automatic array, an array pointer, or an allocatable array.

A whole array is referenced by the array name. Individual elements in a named array are referenced by a scalar subscript or list of scalar subscripts (if there is more than one dimension). A section of a named array is referenced by a section subscript.

Examples

The following are examples of valid array declarations:

DIMENSION     A(10, 2, 3)    ! DIMENSION statement
ALLOCATABLE   B(:, :)        ! ALLOCATABLE statement
POINTER       C(:, :, :)     ! POINTER statement
REAL, DIMENSION (2, 5)       ! Type declaration with
                             !   DIMENSION attribute

Consider the following array declaration:

INTEGER L(2:11,3)

The properties of array L are as follows:

The following example shows other valid ways to declare this array:

DIMENSION L(2:11,3)
INTEGER, DIMENSION(2:11,3) :: L
COMMON L(2:11,3)

The following example shows references to array elements, array sections, and a whole array:

REAL B(10)           ! Declares a rank-one array with 10 elements

INTEGER C(5,8)       ! Declares a rank-two array with 5 elements in
                     !   dimension one and 8 elements in dimension two
...
B(3) = 5.0           ! Reference to an array element
B(2:5) = 1.0         ! Reference to an array section consisting of
                     !   elements: B(2), B(3), B(4), B(5)
...
C(4,8) = I           ! Reference to an array element
C(1:3,3:4) = J       ! Reference to an array section consisting of
                     !   elements:  C(1,3) C(1,4)
                     !              C(2,3) C(2,4)
                     !              C(3,3) C(3,4)
B = 99               ! Reference to a whole array consisting of
                     !   elements: B(1), B(2), B(3), B(4), B(5),
                     !   B(6), B(7), B(8), B(9), and B(10)