III. STRUCTURED FORTRAN PROGRAMMING

A) Control Structures

A.1) Selection Structures

        IF (condition A) THEN
           statements A
        ELSE IF (condition B) then
           statements B
        ELSE
           statements C
        END IF

• Statements C are executed if neither condition A nor B are met
• You may omit the ELSE block
• You can have any number of ELSE IF blocks
• Statements A, B or C may themselves contain IF statements; i.e. IF statements can be properly nested (one is fully contained within another w/o overlapping)
• condition must be a logical value: a logical constant (.true. or .false.), a logical variable (just the variable name), or a logical expression (logical values combined using logical operators).

A.2) Repetition Structures

• The DO statement

          DO var = start, stop, increment
             statements
          END DO
  

  Notes:
  • The loop variable var must be numeric (integer or real)
  • start, stop and inc should be of the same type as var; they can be variables, constants or expressions.
  • The loop is repeated int((stop-start)/inc) times. If this number is not positive, the loop is skipped.
  • The values of start, stop and increment are computed once; i.e. changing them in the loop doesn't affect the loop.
  • You may not change the value of var within the loop
  • END DO performs var = var + increment and repeats if the resulting value of var is within the [start, stop] range.
  • You can abort the loop by using the EXIT statement.
  
  
• The DO WHILE statement

          DO WHILE (condition)
             statements
          END DO
  

  Notes:
  • If condition is false, the loop is skipped
  • The loop repeats as long as condition is true
  • The condition has to be properly set prior to entering the loop; i.e. its variables must have been initialized prior to the loop.
  • Because of the last point above, and to avoid using artificial starting values, we will in this course always set the condition to the constant: .true. Thus, our do while(.true.) loops will always be infinite, and we will use EXIT (in an IF statement in the loop body) to abort.

B) Program Structure

B.1) Subroutine Subprograms

• Formal parameters must agree with the passed values in number,position and type. Names need not be the same.
• Distinguish between parameters sent to the subroutine and those sent back by the subroutines. The former may be constants, variables or expressions while the latter must be variables.
• Don't perform any I/O in a subroutine unless it was designed specifically for I/O.
• All formal parameters need to be declared, even if their corresponding actual parameters were declared in the calling unit. To increase re-usability, however, you can use (*) for the size of a character parameter. And if the declared size of an array parameter is also passed, you can use it in the declaration.
• If one of the parameters is a name of a function or subroutine, then it must be declared EXTERNAL in the calling program.

B.2) Function Subprograms

• Formal parameters must agree with the passed values in number, position and type. Names need not be the same.
• Functions can receive any number of parameters but return only one value. Hence, the actual parameters can be constants, variables or expressions.
• A function returns the value through its name. Hence, its name must be declared (both in it and in the calling program) and it must have one assignment statement that sets its name to a value.
• Don't perform any I/O in a function unless it was designed specifically for I/O.
• All formal parameters need to be declared, even if their corresponding actual parameters were declared in the calling unit. To increase re-usability, however, you can use (*) for the size of a character parameter. And if the declared size of an array parameter is also passed, you can use it in the declaration.
• If one of the parameters is a name of a function or subroutine, then it must be declared EXTERNAL in the calling program.

C) Data Structures

Arrays

• When an array is first decalred, its size (dimensions) must be constant. Normally, you allocate the maximum number of elements you expect to store.
• Because of the above static allocation, arrays are often partially filled; i.e. not fully-populated. One must distiguish between the declared and the actual size of an array (the latter is the actual number of elements stored in the array).
• The first index of a 2-dimensional array denotes the row number.
• Arrays enjoy simplified I/O:

     read*, List                     ! reads all the declared elements of array List
     print*, (i, List(i), i=1,20,2)  ! prints selected elements using an implied DO LOOP