Table 3-1 shows the arithmetic operators.

Use the exponentiation, division, and multiplication operators between exactly two operands. You can use the addition and subtraction operators with one or two operands; in the latter case, specify the operator before the operand; for example, -TOTAL.

Do not specify two operators in succession. Note that the exponentiation operator consists of the two characters (**), but is a single operator. Implied operators, as in implied multiplication, are not allowed.

Table 3-2 interprets sample arithmetic expressions.

An arithmetic expression containing two or more operators is interpreted based on a precedence relation among the arithmetic operators. This precedence, from highest to lowest, is

Use parentheses to override the order of precedence.

The following is an example of an arithmetic expression:

A/B-C**D 

The operators are executed in the following sequence:

A unary operator (-) can follow another operator. Specifying the unary operator after the exponentiation operator produces a variation on the standard order of operations. The unary operator is evaluated first in that case, resulting in exponentiation taking a lower precedence in the expression.

For example, the following expression

A ** - B * C

is interpreted as

A ** ( - B * C ) 

Arithmetic operands must specify values with integer, real, double-precision, complex, or double-complex data types. You can combine specific operands in an arithmetic expression. The arithmetic operands, in order of increasing complexity, are

A primary is the basic component in an arithmetic expression. The forms of a primary are the following:

A factor consists of one or more primaries separated by the exponentiation operator. The following are the forms of a factor:

Factors with more than one exponentiation operator are interpreted from right to left. For example, I**J**K is interpreted as I**(J**K), and I**J**K**L is interpreted as I**(J**(K**L)).

The term incorporates multiplicative operators into arithmetic expressions. Its forms are the following:

The above definition indicates that factors are combined from left to right in a term containing two or more multiplication or division operators.

Finally, at the highest level of the hierarchy, are the arithmetic expressions. The forms of an arithmetic expression are

An arithmetic expression consists of one or more terms separated by an addition operator or a subtraction operator. The terms are combined from left to right. For example, A+B-C has the same interpretation as the expression (A+B)-C. Expressions such as A*-B and A+-B are not allowed. The correct forms are A*(-B) and A+(-B).

An arithmetic expression can begin with a plus or minus sign.

An arithmetic constant expression is an arithmetic expression containing no variables. Thus, each primary in an arithmetic constant expression must be one of the following:

In an arithmetic constant expression, do not specify the exponentiation operator unless the exponent is of type integer. Variable, array element, and function references are not allowed. Examples of integer constant expressions are

7
-7
-7+5
3**2
x+3

where x is the symbolic name of a constant

An integer constant expression is an arithmetic constant expression containing only integers. It can contain constants or symbolic names of constants, provided they are of type integer. As with all constant expressions, no variables, array elements, or function references are allowed.

The data type of an expression is determined by the data types of the operands and functions that are referenced. Thus, integer expressions, real expressions, double-precision expressions, complex expressions, and double expressions have values of type integer, real, double-precision, complex, and double-complex, respectively.

Exponentiation is an exception to the above rules for mixed-mode expressions. When raising a value to an integer power, the integer is not converted. The result is assigned the type of the left operand.

When a complex value is raised to a complex power, the value of the expression is defined as follows:

xy = EXP (y * LOG(x))

One operand of type INTEGER can be divided by another operand of type INTEGER. The result of an integer division operation is a value of type integer, referred to as an integer quotient. The integer quotient is obtained as follows:

A character constant expression is made up of operands that cannot vary. Each primary in a character constant expression must be one of the following:

For the details of character constant syntax see “Character Constants” in Chapter 2 and “Hollerith Constants” in Chapter 2. A character constant expression cannot contain variable, array element, substring, or function references.

A character substring is a contiguous sequence of characters that is part of a character data item. A character substring cannot be empty; that is, it must contain at least one byte of data.

var([e1]:[e2])

arra(sub[,sub]...) ([e1]:[e2])

EX(3:5)

NAME(2,4)(1:5)

XCHAR = 'QRSTUVWXYZ' 

The concatenate operator (//) is the only character operator defined in Fortran. A character expression formed from the concatenation of two character operands x1 and x2 is specified as the following:

x1 // x2   

The result of this operation is a character string with a value of x1 extended on the right with the value of x2. The length of the result is the sum of the lengths of the character operands. For example,

'HEL' // 'LO2' 

The result of the above expression is the string HELLO2 of length six.

Except in a character assignment statement, concatenation of an operand with an asterisk (*) as its length specification is not allowed unless the operand is the symbolic name of a constant.

'A' // 'BCD' // 'EF' 

('A' // 'BCD') // 'EF' 

Table 3-4 lists the Fortran relational operators. Arithmetic and character operators are evaluated before relational operators.

The operands of a relational operator can be arithmetic or character expressions. The relational expression requires exactly two operands and is written in the following form:

e1 relop e2

where e1 and e2 are arithmetic or character expressions and relop is the relational operator.

---

Note: Both e1 and e2 must be the same type of expression, either arithmetic or character.

---

The result of a relational expression is of type logical, with a value of .TRUE. or .FALSE.. The manner in which the expression is evaluated depends on the data type of the operands.

In an arithmetic relational expression, e1 and e2 must each be an integer, real, double precision, complex, or double complex expression. relop must be a relational operator.

The following are examples of arithmetic relational expressions:

(a + b) .EQ. (c + 1)
HOURS .LE. 40

You can use complex type operands only when specifying either the .EQ. or .NE. relational operator.

An arithmetic relational expression has the logical value .TRUE. only if the values of the operands satisfy the relation specified by the operator. Otherwise, the value is .FALSE..

If the two arithmetic expressionse1 and e2 differ in type, the expression is evaluated as follows:

((e1) - (e2)) relop 0

where the value 0 (zero) is of the same type as the expression ((e1)- (e2)) and the type conversion rules apply to the expression. Do not compare a double precision value with a complex value.

In a character relational expression, e1 and e2 are character expressions and relop is a relational operator.

The following is an example of a character relational expression:

NAME .EQ. 'HOMER'

A character relational expression has the logical value .TRUE. only if the values of the operands satisfy the relation specified by the operator. Otherwise, the value is .FALSE.. The result of a character relational expression depends on the collating sequence as follows:

The collating sequence depends partially on the processor; however, equality tests .EQ. and .NE. do not depend on the processor collating sequence and can be used on any processor.

Table 3-5 defines the Fortran logical operators.

All logical operators require at least two operands, except the logical negation operator .NOT. , which requires only one.

A logical expression containing two or more logical operators is evaluated based on precedence of the logical operators. This precedence, from highest to lowest, is

For example, in the following expression:

W .NEQV. X .OR. Y .AND. Z 

the operators are executed in the following sequence:

You can use parentheses to override the precedence of the operators.

Logical operands specify values with a logical data type. The forms of a logical operands are the following:

In general, logical expressions containing two or more logical operators are executed according to the hierarchy of operators described previously, unless the order has been overridden by the use of parentheses. Table 3-6 defines the form and interpretation of the logical expressions.

Certain Fortran operators have precedence over others when combined in an expression. The previous sections have listed the precedence among the arithmetic, logical, and expression operators. No precedence exists between the relational operators and the single character operator (//). On the highest level, the precedence among the types of expression operators, from highest to lowest, is

Use parentheses to specify the order in which operators are evaluated within an expression. Expressions within parentheses are treated as an entity.

In an expression containing more than one operation, the processor first evaluates any expressions within parentheses. Subexpressions within parentheses are evaluated beginning with the innermost subexpression and proceeding sequentially to the outermost. The processor then scans the expression from left to right and performs the operations according to the operator precedence described previously.