[an error occurred while processing this directive]

HP OpenVMS Systems Documentation

Content starts here

HP Fortran for OpenVMS
Language Reference Manual


Previous Contents Index

3.4 Binary, Octal, Hexadecimal, and Hollerith Constants

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:


  • B'd[d...]'
  • B"d[d...]"

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:

Valid  
B'0101110'  
B"1"  
Invalid Explanation
B'0112' The character 2 is invalid.
B10011' No apostrophe after the B.
"1000001" No B before the first quotation mark.

3.4.2 Octal Constants

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


  • O'd[d...]'
  • O"d[d...]"

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:

Valid  
O'07737'  
O"1"  
Invalid Explanation
O'7782' The character 8 is invalid.
O7772' No apostrophe after the O.
"0737" No O before the first quotation mark.

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:


  • Z'd[d...]'
  • Z"d[d...]"

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:

Valid  
Z'AF9730'  
Z"FFABC"  
Z'84'  
Invalid Explanation
Z'999.' Decimal not allowed.
ZF9" No quotation mark after the Z.

For More Information:

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

3.4.4 Hollerith Constants

A Hollerith constant is a string of printable ASCII characters preceded by the letter H. Before the H, there must be an unsigned, nonzero default integer constant stating the number of characters in the string (including blanks and tabs).

Hollerith constants are strings of 1 to 2000 characters. They are stored as byte strings, one character per byte.

Examples

The following examples demonstrate valid and invalid Hollerith constants:

Valid  
16HTODAY'S DATE IS:  
1HB  
4H ABC  
Invalid Explanation
3HABCD Wrong number of characters.
0H Hollerith constants must contain at least one character.

3.4.5 Determining the Data Type of Nondecimal 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:

Statement Data Type of
Constant
Length of
Constant (in bytes)
INTEGER(2) ICOUNT    
INTEGER(4) JCOUNT    
INTEGER(4) N    
REAL(8) DOUBLE    
REAL(4) RAFFIA, RALPHA    
RAFFIA = B'1001100111111010011' REAL(4) 4
RAFFIA = Z'99AF2' REAL(4) 4
RALPHA = 4HABCD REAL(4) 4
DOUBLE = B'1111111111100110011010' REAL(8) 8
DOUBLE = Z'FFF99A' REAL(8) 8
DOUBLE = 8HABCDEFGH REAL(8) 8
JCOUNT = ICOUNT + B'011101110111' INTEGER(2) 2
JCOUNT = ICOUNT + O'777' INTEGER(2) 2
JCOUNT = ICOUNT + 2HXY INTEGER(2) 2
IF (N .EQ. B'1010100') GO TO 10 INTEGER(4) 4
IF (N .EQ. O'123') GO TO 10 INTEGER(4) 4
IF (N. EQ. 1HZ) GO TO 10 INTEGER(4) 4

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

Statement Data Type of
Constant
Length of Constant
(in bytes)
Y(IX) = Y(O'15') + 3. INTEGER(4) 4
Y(IX) = Y(1HA) + 3. INTEGER(4) 4

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:

Statement Data Type of
Constant
Length of Constant
(in bytes)
CALL APAC(Z'34BC2') INTEGER(8) 8
CALL APAC(9HABCDEFGHI) None 9

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):

Statement Data Type of
Constant
Length of Constant
(in bytes)
IF (Z'AF77') 1,2,3 INTEGER(4) 4
IF (2HAB) 1,2,3 INTEGER(4) 4
I = O'7777' - Z'A39' 1 INTEGER(4) 4
I = 1HC - 1HA INTEGER(4) 4
J = .NOT. O'73777' INTEGER(4) 4
J = .NOT. 1HB INTEGER(4) 4

1When two typeless constants are used in an operation, they both take default integer type.

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:

3.5.1 Data Types of Scalar Variables

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:

3.5.1.2 Implicit Typing Rules

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:

Real Variables Integer Variables
ALPHA JCOUNT
BETA ITEM_1
TOTAL_NUM NTOTAL

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:

3.5.2 Arrays

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:

Data type: INTEGER
Rank: 2 (two dimensions)
Bounds: First dimension: 2 to 11
  Second dimension: 1 to 3
Size: 30; the product of the extents: 10 x 3
Shape: (/10,3/) (or 10 by 3); a vector of the extents 10 and 3

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)


Previous Next Contents Index