A primary is defined as follows:

constant

constant_subobject

variable

array_constructor

structure_constructor

function_reference

(expr)

subobject

A variable that is a primary must not be a whole assumed-size array or a section of an assumed-size array name, unless the last subscript position of the array is specified with a scalar subscript or a section subscript in which the upper bound is specified.

The following examples show primaries:

In the previous examples, ONE is a named constant if it has the PARAMETER attribute or appears in a PARAMETER statement. 'ABCS'(I:I) is a constant subobject even though I may be a variable because its parent ('ABCS') is a constant; the reference 'ABCS'(I:I) is a constant subobject because it cannot be defined like a variable can be defined. RATIONAL is a derived type and FCN is a user-defined function.

When an array variable is a primary, the whole array is used, except in a masked assignment statement. In a masked assignment statement, only that part of the array specified by the mask is used.

When a pointer is a primary, the target associated with (pointed to by) the pointer is used, except possibly when the pointer is an actual argument of a procedure, or is an operand of a defined operation or a defined assignment. Whether the pointer or the target is used in these exceptional cases is determined by the procedure invoked by the reference.

Recall that an assumed-size array is a dummy argument whose shape is not completely specified in the subprogram in that the extent in the last dimension is determined by its corresponding actual argument. The implementation model is that the extent in the last dimension is never known to the subprogram but is specified by the use of a subscript, section subscript, or vector subscript expression that defines an upper bound in the last dimension. Unless the extent is specified in this way, such an object must not be used as a primary in an expression. On the other hand, if a subscript, section subscript with an extent for the upper bound, or a vector subscript is specified for the last dimension, the array value has a well-defined shape and hence can be used as a primary in any expression. For example, if A is declared as REAL A(3,*), array A(:,3) has a well-defined shape and can be used as a primary in an expression.

Expressions can be used as actual arguments in procedure references (function references or subroutine calls). Because actual arguments can be expressions involving operations, actual arguments must not contain assumed-size arrays, unless their shape is well-defined, as described above. An actual argument, however, can be just a variable, which then allows the actual argument to be the name of an assumed-size array. This implies that such actual arguments can be assumed-size arrays, unless the procedure requires the shape of the argument to be specified by the actual argument. Most of the intrinsic procedures that allow array arguments require the shape to be specified for the actual array arguments, and therefore assumed-size arrays cannot be used as actual arguments for most intrinsic functions. The exceptions are all references to the intrinsic function LBOUND(3i), and certain references to the intrinsic functions UBOUND(3i) and SIZE(3i).

Defined unary expressions have the highest operator precedence. A defined unary expression is a defined operator followed by a primary. These are defined as follows:

[defined_operator]primary

. letter[letter] ... .

A defined operator must not contain more than 31 letters.

A defined operator must not be the same as any intrinsic operator (.NOT., .AND., .OR., .EQV., .NEQV., .EQ., .NE., .GT., .GE., .LT., .LE., or .LG.) or any logical literal constant (.FALSE. or .TRUE.).

---

Note: The Fortran standard does not describe the .LG. operator.

---

A defined operator can be the same as one of the masking or Boolean operators supported by the CF90 and MIPSpro 7 Fortran 90 compilers as extensions to the Fortran standard. The corresponding CF90 and MIPSpro 7 Fortran 90 operator loses its intrinsic properties. Note that the abbreviations .T., .F., .A., .O., .N., and .X. are synonyms for .TRUE., .FALSE., .AND., .OR., .NOT., and .XOR., respectively. If you define the abbreviated operator for any type, the abbreviated form of the intrinsic operator also cannot be used in any scope in which the defined operator is accessible, and the redefined abbreviated logical constants can no longer be used as logical constants.

The following examples show defined unary expressions:

An exponentiation expression is an expression in which the operator is the exponentiation operator **. This is defined as follows:

defined_unary_expr[ ** exponentiation_expr]

Note that the definition is right recursive (that is, the defined term appears to the right of the operator **) which indicates that the precedence of the ** operator in contexts of equal precedence is right-to-left. Thus, the interpretation of the expression A ** B ** C is A ** ( B ** C ).

The following examples show exponentiation expressions:

A multiplication expression is an expression in which the operator is either * or /. It is defined as follows:

[multiplication_expr * ]exponentiation_expr

[multiplication_expr / ]exponentiation_expr

Note that the definition is left recursive (that is, the defined term appears to the left of the operator * or /) which indicates that the precedence of the * and / operators in contexts of equal precedence is left-to-right. Thus, the interpretation of the expression A * B * C is (A * B) * C, or A / B * C is (A / B) * C. This left-to-right precedence rule applies to the remaining binary operators except the relational operators.

The following examples show multiplication expressions:

A summation expression is an expression in which the operator is either + or -. It is defined as follows:

[[summation_expr] + ]multiplication_expr

[[summation_expr] - ]multiplication_expr

The following examples show summation expressions:

A concatenation expression is an expression in which the operator is //. It is defined as follows:

[concatenation_expr // ]summation_expr

The following examples show concatenation expressions:

A comparison expression is an expression in which the operator is a relational operator. It is defined as follows:

[concatenation_expr rel_op]concatenation_expr

.EQ.

.NE.

.LT.

.LE.

.GT.

.GE.

.LG.

==

/=

<

<=

>

>=

<>

The operators ==, /=, <, <=, >, >=, and <> are synonyms in all contexts for the operators .EQ., .NE., .LT., .LE., .GT., .GE., and .LG., respectively.

---

Note: The Fortran standard does not describe the .LG. or <> operators.

---

Note that the definition of a comparison expression is not recursive, and therefore comparison expressions cannot contain relational operators in contexts of equal precedence.

The following examples show comparison expressions:

A not expression is an expression in which the operator is .NOT.. It is defined as follows:

[ .NOT. ]comparison_expr

Note that the definition of a not expression is not recursive, and therefore not expressions cannot contain adjacent .NOT. operators.

The following examples show not expressions:

A conjunct expression is an expression in which the operator is .AND.. It is defined as follows:

[conjunct_expr .AND. ]not_expr

Note that the definition of a conjunct expression is left recursive, and therefore the precedence of the .AND. operator in contexts of equal precedence is left-to-right. Thus, the interpretation of the expression A .AND. B .AND. C is (A .AND. B) .AND. C.

The following examples show conjunct expressions:

An inclusive disjunct expression is an expression in which the operator is .OR.. It is defined as follows:

[inclusive_disjunct_expr .OR. ]conjunct_expr

Note that the definition of an inclusive disjunct expression is left recursive, and therefore the precedence of the .OR. operator in contexts of equal precedence is left-to-right. Thus, the interpretation of the expression A. OR. B .OR. C is (A .OR. B) .OR. C.

The following examples show inclusive disjunct expressions:

An equivalence expression is an expression in which the operator is either .EQV. or .NEQV.. It is defined as follows:

[equivalence_expr .EQV. ]inclusive_disjunct_expr

[equivalence_expr .NEQV. ]inclusive_disjunct_expr

An exclusive disjunct expression is an expression in which the operator is .XOR.. It is defined as follows:

[exclusive_disjunct_expr .XOR. ]inclusive_disjunct_expr

---

Note: The Fortran standard does not specify the .XOR. operator.

---

Note the following:

The following examples show equivalence expressions:

The most general form of an expression is defined as follows:

[expr defined_binary_op]equivalence_expr

.letter[letter] ....

Note that the definition of an expression is left recursive, and therefore the precedence of the binary defined operator in contexts of equal precedence is left-to-right. The interpretation of the expression A .PLUS. B .MINUS. C is thus (A .PLUS. B) .MINUS. C (where .MINUS. is a defined operator).

The following examples show expressions:

The previous sections have described in detail the sorts of expressions that can be formed. These expressions form a hierarchy that can best be illustrated by a figure. Figure 7-1, describes the hierarchy by placing the simplest form of an expression, a variable, at the center of a set of nested rectangles. The more general forms of an expression are the enclosing rectangles, from a primary to an exponentiation expression, to a summation expression, and finally to a general expression using a defined binary operator .CROSS.. Figure 7-1 demonstrates that an expression is all of these special case forms, including the simplest form, a primary.

Figure 7-1. The hierarchy of expressions by examples

Table 7-2, illustrates the relationship between the different sorts of expressions by summarizing the definitional forms in one table. The simplest form of an expression is at the bottom and is the primary, as in Figure 7-1. The next, more general, form is second from the bottom and is the defined unary expression; it uses the primary in its definition. At the top of the table is the most general form of an expression.

The type, type parameters, and shape of a primary that is a nonpointer variable or constant are straightforward because these properties are determined by specification statements for the variable or named constant, or by the form of the constant. For example, if A is a variable, its declaration in a specification statement such as the following determines it as an explicit-shaped array of type real with a default kind parameter:

REAL A(10, 10)

For a constant such as the following, the form of the constant indicates that it is a scalar constant of type complex and of default kind:

(1.3, 2.9)

For a pointer variable, the type, type parameters, and rank are determined by the declaration of the pointer variable. However, if the pointer is of deferred shape, the shape (in particular, the extents in each dimension) is determined by the target of the pointer. Consider the following declarations and assume that pointer A is associated with the target B:

REAL, POINTER :: A(:, :)
REAL, TARGET  :: B(10, 20)

The shape of A is (10, 20).

The type and type parameters of an array constructor are determined by the contents of the constructor. Unless the element is of type Boolean (typeless), its type and type parameters are those of any element of the constructor because they must all be of the same type and type parameters. If the element is of type Boolean, the type and kind type of the array constructor are the same as the default integer type. Therefore, the type and type parameters of the following array constructor are integer and kind value 1:

(/ 1_1, 123_1, -10_1 /)

Its shape is always of rank one and of size equal to the number of elements.

The type of a structure constructor is the derived type used as the name of the constructor. A structure has no type parameters. So, the type of the following structure constructor is the derived type PERSON:

PERSON(56, 'Father')

(See “Array Constructors” in Chapter 4, for the type definition PERSON.)

A structure constructor is always a scalar.

The type, type parameters, and shape of a function are determined by one of the following:

If the interface is explicit, the type, type parameter, and shape are determined by one of the following:

Note, however, that because intrinsic functions and functions with interface blocks can be generic, these properties are determined by the type, type parameters, and shapes of the actual arguments of the particular function reference.

For example, consider the following statements as part of the program unit specifying an internal function FCN:

REAL FUNCTION FCN(X)
DIMENSION FCN(10, 15)

A reference to FCN(3.3) is of type default real with shape (10,15). As a second example, consider the following:

REAL(SINGLE)  X(10, 10, 10)
   . . .
   . . .  SIN(X)   . . .  

The interface to SIN(3i) is specified by the definition of the sine intrinsic function. In this case, the function reference SIN(X) is of type real with kind parameter value SINGLE and of shape (10,10,10).

The interface is implicit if the function is external (and no interface block is provided) or is a statement function. In these cases, the shape is always that of a scalar, and the type and type parameters are determined by the implicit type declaration rules in effect, or by an explicit type declaration for the function name. In the following example, FCN(X) is a scalar of type integer with kind type parameter value SHORT:

IMPLICIT INTEGER(SHORT) (A-F)
   . . .
   . . .  FCN(X)   . . .  

The one case for variables and functions that is not straightforward is the determination of the shape of a variable when it is of deferred shape or of assumed shape. For a deferred-shape array, the rank is known from the declaration but the size of each dimension is determined as the result of executing an ALLOCATE statement or a pointer assignment statement. For an assumed-shape array, the rank is also known from the declaration but the size is determined by information passed into the subprogram. In the case of pointers, the shape of the object is that of the target associated with (pointed to by) the pointer. The shape of deferred-shape and assumed-shape arrays thus cannot be determined in general until execution time.

The type of the result of an intrinsic operation is determined by the type of the operands and the intrinsic operation and is specified by Table 7-4.

For nonnumeric operations, the type parameters of the result of an operation are determined as follows:

For numeric intrinsic operations, the kind type parameter value of the result is determined as follows:

For numeric intrinsic operations, an easy way to remember the result type and type parameter rules is to consider that the numeric types (integer, real, complex, and CF90 and MIPSpro 7 Fortran 90 Boolean) are ordered by the increasing generality of numbers. Integers are contained in the set of real numbers and real numbers are contained in the set of complex numbers. Within the integer type, the kinds are ordered by increasing decimal exponent ranges. Within the real and complex types, the kinds for each type are ordered by increasing decimal precision.

Using this model, the result type of a numeric intrinsic operation is the same type as the operand of the greater generality. For the result type parameter, the rule is complicated: if one or both of the operands is of type real or complex, the type parameter is that of the set of numbers of the more general type described above and with a precision as large as the precision of the operands; if both are of type integer, the result type parameter is of a set of numbers that has a range as large as the range of the operands.

Figure 7-2. Example ordering of numeric types on UNICOS systems

To illustrate this ordering, consider Figure 7-2, which shows ordering on UNICOS systems. For integers, KIND=4 is 32-bit format and KIND=8 is a 64-bit format, with decimal exponent ranges 9 and 18. For the two kinds of reals, KIND=8 is a 64-bit format and KIND=16 is a 128-bit format, with decimal precisions 13 and 27. For the two kinds of complex, KIND=8 is a 128-bit format and KIND=16 is a 256-bit format, with decimal precisions 13 and 27. Let variables of the 6 numeric types be I4, I8, R8, R16, C8, and C16, where the letter designates the type and the digits designate the kind type parameter. Using this ordering, Table 7-5 shows the type and type parameters of some simple expressions.

The type and type parameter values of a defined operation are determined by the interface block for the referenced operation and are the type and type parameters of the name of the function specified by the interface block. Note that the operator can be generic and therefore the type and type parameters can be determined by the operands. For example, consider the following interface:

INTERFACE OPERATOR (.PLUS.)

   TYPE(SET) FCN_SET_PLUS(X, Y)
      USE DEFINITIONS
      TYPE (SET)  X, Y
      INTENT(IN) X, Y
   END FUNCTION FCN_SET_PLUS

   TYPE(RATIONAL) FCN_RAT_PLUS(X, Y)
      USE DEFINITIONS
      TYPE(RATIONAL)  X, Y
      INTENT(IN) X, Y
   END FUNCTION FCN_RAT_PLUS

END INTERFACE

The operation A .PLUS. B, where A and B are of type RATIONAL, is an expression of type RATIONAL with no type parameters. The operation C .PLUS. D, where C and D are of type SET is an expression of type SET with no type parameters.

The shape of an expression is determined by the shape of each operand in the expression in the same recursive manner as for the type and type parameters for an expression. That is, the shape of an expression is the shape of the result of the last operation determined by the interpretation of the expression.

However, the shape rules are simplified considerably by the requirement that the operands of binary intrinsic operations must be in shape conformance; two operands are in shape conformance if both are arrays of the same shape, or one or both operands are scalars. The operands of a defined operation have no such requirement but must match the shape of the corresponding dummy arguments of the defining function.

For primaries that are constants, variables, constructors, or functions, the shape is that of the constant, variable, constructor, or function name. Recall that structure constructors are always scalar, and array constructors are always rank-one arrays of size equal to the number of elements in the constructor. For unary intrinsic operations, the shape of the result is that of the operand. For binary intrinsic operations, the shape is that of the array operand if there is one and is scalar otherwise. For defined operations, the shape is that of the function name specifying the operation.

For example, consider the intrinsic operation A + B where A and B are of type default integer and default real respectively; assume A is a scalar and B is an array of shape (3, 5). Then, the result is of type default real with shape (3, 5).

For most contexts, the lower and upper bounds of an array expression are not needed; only the sizes of each dimension are needed to satisfy array conformance requirements for expressions. The bounds of an array expression when it is the ARRAY argument (first positional argument) of the LBOUND(3i) and UBOUND(3i) intrinsic functions are needed, however.

The functions LBOUND(3i) and UBOUND(3i) have two keyword arguments ARRAY and DIM. ARRAY is an array expression and DIM, which is optional, is an integer. If the DIM argument is present, LBOUND(3i) and UBOUND(3i) return the lower and upper bounds, respectively, of the dimension specified by the DIM argument. If DIM is absent, they return a rank-one array of the lower and upper bounds, respectively, of all dimensions of the ARRAY argument. As described below, these functions distinguish the special cases when the array argument is a name or structure component with no section subscript list from the general case when the array argument is a more general expression. Note that if A is a structure with an array component B, A%B is treated as if it were an array name and not an expression.

When the ARRAY argument is an array expression that is not a name or a structure component, the function LBOUND(3i) returns 1 if the DIM argument is specified and returns a rank-one array of 1s if the DIM argument is absent. For the same conditions, the function UBOUND(3i) returns as the upper bound the size of the requested dimension or the size of all dimensions in a rank-one array.

When the ARRAY argument is an array name or a structure component with no section subscript list, there are four cases to distinguish depending on the array specifier for the name. The following sections describe these four cases.

INTEGER  A(2:10, 11:12)
. . .
TYPE PASSENGER_INFO
   INTEGER NUMBER
   INTEGER TICKET_IDS(2:500)
END TYPE PASSENGER_INFO
. . .
TYPE(PASSENGER_INFO) PAL, MANY(3:10)

REAL  C(2:10, 11:12)
   . . .
CALL  S(C(4:8, 7:9))
CONTAINS
  SUBROUTINE S(A)
    REAL  A(:, 2:)
       . . .
    ! Reference to LBOUND(A)  and  UBOUND(A)
       . . .  

REAL  C(2:10, 11:12)
   . . .
CALL  S (C(4:8, 7:9))
CONTAINS
  SUBROUTINE  S (A)
    REAL  A(-2:2, *)
       . . .
 ! Reference to LBOUND(A, 1)  and  UBOUND(A(:, 2))
 ! A reference to UBOUND(A) would be illegal.
 ! A reference to UBOUND(A, 2) would be illegal.
    . . .  

REAL, ALLOCATABLE ::  A(:, :)
   . . .
ALLOCATE  ( A(5, 7:9) )
   . . .! Reference to LBOUND(A)  and  UBOUND(A)
   . . .  

A constant expression is one of the following constant values or is an expression consisting of intrinsic operators whose operands are any of the following constant values:

The restriction in item 4 to intrinsic functions that can be evaluated at compile-time eliminates the use of the intrinsic functions PRESENT(3i), ALLOCATED(3i), and ASSOCIATED(3i). It also requires that each argument of the intrinsic function reference be a constant expression or a variable whose type parameters or bounds are known at compile time. This restriction excludes, for example, named variables that are assumed-shape arrays, assumed-size arrays for inquiries requiring the size of the last dimension, and variables that are pointer arrays or allocatable arrays. For example, if an array X has explicit bounds in all dimensions, an inquiry such as SIZE(X) can be computed at compile-time, and SIZE(X) + 10 is considered a constant expression.

Constant expressions can be used in any executable statement where general expressions (that is, unrestricted expressions) are permitted.

The following examples show constant expressions:

An initialization expression is a constant expression restricted as follows:

All but the last examples in “Constant Expressions”, are initialization expressions. The last are not because initialization expressions cannot contain functions that return results of type real (REAL(3i), LOG(3i)), must not reference certain transformational functions (COUNT(3i), SUM(3i)), or cannot use the exponentiation operator when the second operand is of type real.

The following are examples of initialization expressions:

Initialization expressions must be used in the following contexts:

Initialization expressions must be used for situations where the value of the expression is needed at compile time. Note that the initialization expressions do not include intrinsic functions that return values of type real, logical, or complex, or have arguments of type real, logical, or complex.

A specification expression is a restricted expression that has a scalar value and is of type integer. Specification expressions are used as bounds for arrays and length parameter values for character entities in type declarations, attribute specifications, dimension declarations, and other specification statements (see Table 7-6). A constant specification expression is a specification expression that is also a constant.

Specification expressions are forms of restricted expressions (defined below), limited in type and rank. Briefly, a restricted expression is limited to constants and certain variables accessible to the scoping unit whose values can be determined on entry to the program unit before any executable statement is executed. For example, variables that are dummy arguments, are in a common block, are in a host program unit, or are in a module made accessible to the program unit can be evaluated on entry to a program unit. Array constructors, structure constructors, intrinsic function references, and parenthesized expressions made up of these primaries must depend only on restricted expressions as building blocks for operands in a restricted expression.

A restricted expression is an expression in which each operation is intrinsic and each primary is limited to one of the following:

A function is a specification function if it is a pure function, is not an intrinsic function, is not an internal function, is not a statement function, does not have a dummy procedure argument, and is not RECURSIVE.

---

Note: The Fortran standard does not specify restricted expressions in which a primary can be a reference to an external function that is not a specification function and with a result that is a nonpointer scalar intrinsic type.

---

The following rules and restrictions apply to the use of initialization and specification expressions in specification statements.

The type and type parameters of a variable or named constant in one of these expressions must be specified in a prior specification in the same scoping unit, in a host scoping unit, in a module scoping unit made accessible to the current scoping unit, or by the implicit typing rules in effect. If the variable or named constant is explicitly given these attributes in a subsequent type declaration statement, it must confirm the implicit type and type parameters.

If an element of an array is referenced in one of these expressions, the array bounds must be specified in a prior specification.

If a specification expression includes a variable that provides a value within the expression, the expression must appear within the specification part of a subprogram. For example, consider variable N in the following program segment:

INTEGER  N
COMMON   N
REAL  A (N)

N is providing a value that determines the size of the array A. This program segment must not appear in a main program but may appear in the specification part of a subprogram.

A prior specification in the above cases may be in the same specification statement, but to the left of the reference. For example, the following declarations are valid:

INTEGER, DIMENSION(4), PARAMETER :: A = (/4, 3, 2, 1 /)
REAL, DIMENSION(A (2)) :: B, C(SIZE(B))

B and C are of size 3 (the second element of the array A). The following declaration, however, is invalid because SIZE(E) precedes E:

REAL, DIMENSION(2) :: D(SIZE(E)), E

The various kinds of expressions may be somewhat confusing, and it can be difficult to remember where they can be used. To summarize the differences, “Rules for Forming Expressions”, specifies the most general kind of expression; the other kinds of expressions are restrictions of the most general kind. The classification of expressions forms two orderings, each from most general to least general, as follows:

The relationship between the various kinds of expression can be seen in the diagram in Figure 7-3.

Figure 7-3. Relationships between the kinds of expressions

Initialization expressions are not a subset of specification expressions because the result of an initialization expression can be of any type, whereas the result of a specification expression must be of type integer and scalar. Also, specification expressions are not a subset of initialization expressions because specification expressions allow certain variables (such as dummy arguments and variables in common blocks) to be primaries, where as initialization expressions do not allow such variables.

Table 7-6, describes the differences between initialization and specification expressions. Table 7-7, summarizes where each kind of expression is used and gives the restrictions as to their type and rank when used in the various contexts. For example, Table 7-6, indicates that initialization and specification expressions are different in that initialization expressions can be array valued, whereas specification expressions are scalar. A consequence of this difference, as indicated in Table 7-7, is that an initialization expression is used in a type declaration statement or a PARAMETER statement to specify the value of a named constant array, whereas a specification expression is used to specify the bounds of an array in a declaration statement.

Example 1: The expressions I*3, 1+2*J, 5*J/3, 1, and 10 in the following statement, are all expressions allowed in subscripts and implied-DO parameter expressions in an implied-DO list in a DATA statement:

DATA ((A(I*3), I = 1+2*J, 5*J/3), J = 1, 10) /.../

Example 2: An expression such as RADIX(I) is not allowed as a data implied-DO parameter or subscript of a DATA statement object.

An expression such as N, where N is a variable in the scoping unit that contains the DATA statement, is not allowed because N is neither a named constant nor an implied-DO variable in a containing implied-DO list.

Such special expressions in DATA statements are restricted forms of initialization expressions in the sense that the primaries must not include references to any intrinsic function. On the other hand, they are extended forms of initialization expressions in the sense that they permit the use of implied-DO variables that have the scope of the implied-DO list.

Except for exponentiation to an integer power, when an operand for a numeric intrinsic operation does not have the same type or type parameters as the result of the operation, the operand is converted to the type, type parameter, and shape of the result and the operation is then performed. For exponentiation to an integer power, the operation can be performed without the conversion of the integer power, say, by developing binary powers of the first operand and multiplying them together to obtain an efficient computation of the result.

For integer division, when both operands are of type integer, the result is of type integer, but the mathematical quotient is often not an integer. In this case, the result is specified to be the integer value closest to the quotient and between zero and the quotient inclusively.

For exponentiation, there are three cases that need to be further described. When both operands are of type integer, the result is of type integer; when x₂ is negative, the operation x₁**x₂ is interpreted as the quotient 1/(x₁**ABS(x₂)). Note that it is subject to the rules for integer division. For example, 4**(-2) is 0.

The second case occurs when the first operand is a negative value of type integer or real and the second operand is of type real. A program is invalid if it causes a reference to the exponentiation operator with such operands. For example, a program that contains the expression (-1.0)**0.5 is an invalid program.

The third case occurs when the second operand is of type real or of type complex. In this case, the result returned is the principal value of the mathematical power function.

There is only one intrinsic character operation: concatenation. For this operation, the operands must be of type character. The length parameter values can be different. The result is of type character with a character length parameter value equal to the sum of the lengths of the operands. The result consists of the characters of the first operand in order followed by those of the second operand in order. For example, 'Fortran' // '95' yields the result 'Fortran 95'.

The intrinsic relational operations perform comparison operations for character and most numeric operands. For these operations, the operands must both be of numeric type or both be of character type. The kind type parameter values of the operands of the numeric types can be different and the lengths of character operands can be different. Complex operands must only be compared for equality and inequality; the reason is that complex numbers are not totally ordered. The result in all cases is of type default logical.

When the operands of an intrinsic relational operation are both numeric, but of different types or type parameters, each operand is converted to the type and type parameters they would have if the two operands were being added. Then, the operands are compared according to the usual mathematical interpretation of the particular relational operator.

When the operands are both of type character, the shorter one is padded on the right with blank padding characters until the operands are of equal length. Then, the operands are compared one character at a time in order, starting from the leftmost character of each operand until the corresponding characters differ. The first operand is less than or greater than the second operand according to whether the characters in the first position where they differ are less than or greater than each other. The operands are equal if both are of zero length or all corresponding characters are equal, including the padding characters.

There is no ordering defined for logical values. However, logical values can be compared for equality and inequality by using the logical equivalence and not equivalence operators .EQV. and .NEQV.. That is, L1 .EQV. L2 is true when L1 and L2 are both true or both false and is false otherwise. L1.NEQV. L2 is true if either L1 or L2 is true (but not both true) and is false otherwise.

The intrinsic logical operations perform many of the common operations for logical computation. For these operations, the operands must both be of logical type but can have different kind type parameters. If the kind type parameter values are the same, the kind type parameter value of the result is the kind type parameter value of the operands. If the kind type parameter values are different, the kind type parameter value is the larger of the two kind type parameter values. The values of the result in all cases are specified in Table 7-9.

Each of the intrinsic operations can have array operands; however, for the binary intrinsic operations, the operands must both be of the same shape, if both are arrays. When one operand is an array and the other is a scalar, the operation behaves as if the scalar operand were broadcast to an array of the result shape and the operation performed.

For both the unary and binary intrinsic operators, the operation is interpreted element-by-element; that is, the scalar operation is performed on each element of the operand or operands. For example, if A and B are arrays of the same shape, the expression A * B is interpreted by taking each element of A and the corresponding element of B and multiplying them together using the scalar intrinsic operation * to determine the corresponding element of the result. Note that this is not the same as matrix multiplication. As a second example, the expression -A is interpreted by taking each element of A and negating it to determine the corresponding element of the result.

For intrinsic operations that appear in masked assignment statements (in WHERE blocks, ELSEWHERE blocks, or in a WHERE statement), the scalar operation is performed only for those elements selected by the logical mask expression.

Note that there is no order specified for the interpretation of the scalar operations. A processor is allowed to perform them in any order, including all at the same time.

The intrinsic operations can have operands with the POINTER attribute. In such cases, each pointer must be associated with a target that is defined, and the value of the target is used as the operand. The target can be scalar or array-valued; the rules for interpretation of the operation are those appropriate for the operand being a scalar or an array, respectively.

Recall that an operand can be a structure component that is the component of a structure variable that is itself a pointer. In this case, the value used for the operand is the named component of the target structure associated with the structure variable. For example, consider the following declarations and assume that the pointer PTR is associated with T:

TYPE RATIONAL
   INTEGER :: N, D
END TYPE

TYPE(RATIONAL), POINTER :: PTR
TYPE(RATIONAL), TARGET  :: T

If PTR%N appears as an operand, its value is the component N of the target T, namely T%N.

The WHERE construct is defined as follows:

WHERE (mask_expr) where_assignment_stmt

where_construct_stmt
[where_body_construct] ...
[masked_elsewhere_stmt
[where_body_construct] ...] ...
[elsewhere_stmt
[where_body_construct] ... ]
end_where_stmt

[where_construct_name: ] WHERE (mask_expr)

where_assignment_stmt

where_stmt

where_construct

assignment_stmt

logical_expr

ELSEWHERE (mask_expr) [where_construct_name]

ELSEWHERE [where_construct_name]

END WHERE [where_construct_name]

The definition of the WHERE construct can be simplified to the following general format:

WHERE (condition_1) ! STATEMENT_1
...
ELSEWHERE (condition_2)    ! STATEMENT_2
...
ELSEWHERE           ! STATEMENT_3
...
END WHERE

The following information applies to the preceding general format:

If an array constructor appears in a where_assignment_stmt or in a mask_expr, the array constructor is evaluated without any masked control. After that, the where_assignment_stmt is executed or the mask_expr is evaluated.

When a where_assignment_stmt is executed, the values of expr that correspond to true values of the control mask are assigned to the corresponding elements of variable.

A statement that is part of a where_body_construct must not be a branch target statement. The value of the control mask is established by the execution of a WHERE statement, a WHERE construct statement, an ELSEWHERE statement, a masked ELSEWHERE statement, or an ENDWHERE statement. Subsequent changes to the value of entities in a mask_expr have no effect on the value of the control mask. The execution of a function reference in the mask expression of a WHERE statement is permitted to affect entities in the assignment statement. Execution of an END WHERE has no effect.

If the where_construct_stmt has a where_construct_name, then the corresponding end_where_stmt must specify the same name. If the construct also has an elsewhere_stmt or masked_ elsewhere_stmt, it must have the same where_construct_name. If no where_construct_name is specified for the where_construct, then the end_where_stmt and any elsewhere_stmt or masked_elsewhere_stmt must have the where_construct_name.

In a WHERE construct, only the WHERE construct statement can be labeled as a branch target statement.

The WHEREblock is the set of assignments between the WHERE construct statement and the ELSEWHERE statement (or END WHERE statement, if the ELSEWHERE statement is not present). The ELSEWHEREblock is the set of assignment statements between the ELSEWHERE and the END WHERE statements.

Each assignment in the ELSEWHERE block assigns a value to each array element that corresponds with a mask array element that is false.

The ELSEWHERE block is optional; when it is not present, no assignment is made to elements corresponding to mask array elements that are false.

All of the assignment statements are executed in sequence as they appear in the construct (in both the WHERE and ELSEWHERE blocks).

Any elemental intrinsic operation or function within an array assignment statement is evaluated only for the selected elements. In the following example, the square roots are taken only of the elements of A that are positive:

REAL  A(10, 20)
  ...
WHERE (A > 0.0)
  SQRT_A = SQRT(A)
END WHERE

An elemental function reference is evaluated independently for each element, and only those elements needed in the array assignment are referenced. A where_assignment_stmt that is a defined assignment must be elemental.

The expression in the array assignment statement can contain nonelemental function references. Nonelemental function references are references to any function or operation defined by a subprogram, without the ELEMENTAL keyword. All elements of the arguments of such functions and returned results (if arrays) are evaluated in full. If the result of the nonelemental function is an array and is an operand of an elemental operation or function, then only the selected elements are used in evaluating the remainder of the expression.

Example 1:

REAL  A(2, 3), B(3, 10), C(2, 10), D(2, 10)
INTRINSIC  MATMUL
  ...
WHERE (D < 0.0)
  C = MATMUL(A, B)
END WHERE

The matrix product A multiplied by B is performed, yielding all elements of the product, and only for those elements of D that are negative are the assignments to the corresponding elements of C made.

Example 2:

WHERE (TEMPERATURES > 90.0)  HOT_TEMPS = TEMPERATURES
WHERE (TEMPERATURES < 32.0)  COLD_TEMPS = TEMPERATURES

Example 3:

WHERE (TEMPERATURES > 90.0)
   NUMBER_OF_SWEATERS = 0
ELSEWHERE (TEMPERATURES < 0.0)
   NUMBER_OF_SWEATERS = 3
ELSEWHERE (TEMPERATURES < 40)
   NUMBER_OF_SWEATERS = 2
ELSEWHERE
   NUMBER_OF_SWEATERS = 1
ENDWHERE

One major difference between the WHERE construct and control constructs has been described in “Masked Array Assignment”. Another difference is that no transfers out of WHERE or ELSEWHERE blocks are possible (except by a function reference) because only intrinsic assignment statements are permitted within these blocks. Note that the execution of statements in the WHERE block can affect variables referenced in the ELSEWHERE block (because the statements in both blocks are executed).

The FORALL construct allows multiple assignments, masked array (WHERE) assignments, and nested FORALL constructs and statements to be controlled by a single forall_triplet_spec_list and scalar_mask.

The format of the FORALL construct is as follows:

forall_construct_stmt
[forall_body_construct] ...
end_forall_stmt

[forall_construct_name: ] FORALL forall_header

(forall_triplet_spec_list[, scalar_mask_expr])

index_name = subscript : subscript[: stride]

scalar_int_expr

scalar_int_expr

forall_assignment_stmt

where_stmt

where_construct

forall_construct

forall_stmt

assignment_stmt

pointer_assignment_stmt

END FORALL [forall_construct_name]

If the forall_construct_stmt has a forall_construct_name, the end_forall_stmt must have the same forall_construct_name. If the end_forall_stmt has a forall_construct_name, the forall_construct_stmt must have the same forall_construct_name.

The scalar_mask_expr must be scalar and of type logical.

A procedure that is referenced in the scalar_mask_expr, including one referenced by a defined operation, must be a pure procedure.

A procedure that is referenced in a forall_body_construct, including one referenced by a defined operation or assignment, must be a pure procedure.

The index_name must be a named scalar variable of type integer.

A subscript or stride in a forall_triplet_spec must not contain a reference to any index_name in the forall_triplet_spec_list in which it appears.

A statement in a forall_body_construct must not define an index_name of the forall_construct.

A forall_body_construct must not be a branch target.

Example:

REAL :: A(10, 10), B(10, 10) = 1.0
...
FORALL (I = 1:10, J = 1:10, B(I, J) /= 0.0)
   A(I, J) = REAL (I + J - 2)
   B(I, J) = A(I, J) + B(I, J) * REAL (I * J)
END FORALL

Each forall_body_construct is executed in the order in which it appears. Each construct is executed for all active combinations of the index_name values.

Execution of a forall_assignment_stmt that is an assignment_stmt causes the evaluation of expr and all expressions within variable for all active combinations of index_name values. After all evaluations have been performed, each expr value is assigned to the corresponding variable.

Execution of a forall_assignment_stmt that is a pointer_assignment_stmt causes the evaluation of all expressions within target and pointer_object, the determination of any pointers within pointer_object, and the determination of the target for all active combinations of index_name values. After these evaluations have been performed, each pointer_object is associated with the corresponding target.

In a forall_assignment_stmt, a defined assignment subroutine must not reference any variable that becomes defined or a pointer_object that becomes associated by the statement.

The following code fragment shows a FORALL construct with two assignment statements. The assignment to array B uses the values of array A computed in the previous statement, not the values A had prior to execution of the FORALL:

FORALL (I = 2:N-1, J = 2:N-1 )
   A (I, J) = A(I, J-1) + A(I,J+1) + A(I-1,J) + A(I+1, J)
   B (I, J) = 1.0 / A(I, J)
END FORALL

The following code fragment shows how to avoid an error condition by using an appropriate scalar_mask_expr that limits the active combinations of the index_name values:

FORALL (I = 1:N, Y(I) .NE. 0.0)
   X(I) = 1.0 / Y(I)
END FORALL

Each statement in a where_construct within a forall_construct is executed in sequence. When a where_stmt, where_construct_stmt, or masked_elsewhere_stmt is executed, the statement's mask_expr is evaluated for all active combinations of index_name values as determined by the outer forall_constructs, masked by any control mask corresponding to outer where_constructs. Any where_assignment_stmt is executed for all active combinations of index_name values, masked by the control mask in effect for the where_assignment_stmt. The following FORALL construct contains a WHERE statement and an assignment statement:

INTEGER A(5,4), B(5,4)
FORALL ( I = 1:5 )
   WHERE ( A(I,:) .EQ. 0 ) A(I,:) = I
   B (I,:) = I / A(I,:)
END FORALL

The preceding code is executed with array A as follows::

    0 0 0 0
    1 1 1 0
A = 2 2 0 2
    1 0 2 3
    0 0 0 0

The result is as follows:

    1 1 1 1         1 1 1 1
    1 1 1 2         2 2 2 1
A = 2 2 3 2     B = 1 1 1 1
    1 4 2 3         4 1 2 1
    5 5 5 5         1 1 1 1

When a forall_stmt or forall_construct is executed, the compiler evaluates the subscript and stride expressions in the forall_triplet_spec_list for all active combinations of the index_name values of the outer FORALL construct. The set of combinations of index_name values for the inner FORALL is the union of the sets defined by these bounds and strides for each active combination of the outer index_name values; it also includes the outer index_name values. The scalar_mask_expr is then evaluated for all combinations of the index_name values of the inner construct to produce a set of active combinations for the inner construct. If no scalar_mask_expr is specified, the compiler uses .TRUE. as its value. Each statement in the inner FORALL is then executed for each active combination of the index_name values. The following FORALL construct contains a nested FORALL construct. It assigns the transpose of the lower triangle of array A, which is the section below the main diagonal, to the upper triangle of A. The code fragment is as follows:

INTEGER A (3, 3)
FORALL (I = 1:N-1 )
   FORALL ( J=I+1:N )
      A(I,J) = A(J,I)
   END FORALL
END FORALL

Prior to execution of the preceding code, N=3 and array A is as follows:

    0 3 6
A = 1 4 7
    2 5 8

After the preceding code is executed, array A is as follows:

    0 1 2
A = 1 4 5
    2 5 8

You could also use the following FORALL statement to obtain identical results:

FORALL ( I = 1:N-1, J=1:N, J > I ) A(I,J) = A(J,I)

For more information on the FORALL statement, see “FORALL Statement”.

The FORALL statement allows a single assignment statement or pointer assignment to be controlled by a set of values and an optional mask expression. The format for this statement is as follows:

FORALL forall_headerforall_assignment_stmt

Execution of a FORALL statement starts with the evaluation of the forall_triplet_spec_list for each index_name variable. All possible combinations of the values of the index_name variables are considered for execution of the FORALL body. The mask expression, if present, is then evaluated for each combination of index_name values and each combination that has a .TRUE. outcome is in the active combination of index_name values. This set of active combinations is then used in executing the FORALL body.

A FORALL statement is equivalent to a FORALL construct that contains a single forall_body_construct that is a forall_assignment_stmt.

The scope of an index_name in a forall_stmt is the statement itself.

The following FORALL statement assigns the elements of vector X to the elements of the main diagonal of matrix A:

FORALL (I=1:N) A(I,I) = X(I)

In the following FORALL statement, array element X(I,J) is assigned the value (1.0 / REAL (I+J-1)) for values of I and J between 1 and N, inclusive:

FORALL (I = 1:N, J = 1:N) X(I,J) = 1.0 / REAL (I+J-1)

The following statement takes the reciprocal of each nonzero off-diagonal element of array Y(1:N, 1:N) and assigns it to the corresponding element of array X. Elements of Y that are zero or are on the diagonal do not participate, and no assignments are made to the corresponding elements of X:

FORALL (I=1:N, J=1:N, Y(I,J) /= 0 .AND. I /= J) X(I,J) = 1.0 / Y(I,J)

A many-to-one assignment is more than one assignment to the same object or subobject, or association of more than one target with the same pointer, whether the object is referenced directly or indirectly through a pointer. A many-to-one assignment must not occur within a single statement in a FORALL construct or statement. It is possible to assign, or pointer assign, to the same object in different assignment statements in a FORALL construct.

The appearance of each index_name in the identification of the left-hand side of an assignment statement is helpful in eliminating many-to-one assignments, but it is not sufficient to guarantee that there will be none. The following code fragment is permitted only if INDEX(1:10) contains no repeated values:

FORALL (I = 1:10)
   A (INDEX (I)) = B(I)
END FORALL

Within the scope of a FORALL construct, a nested FORALL statement or FORALL construct cannot have the same index_name. The forall_header expressions within a nested FORALL can depend on the values of outer index_name variables.