II. PROGRAM DEVELOPMENT

A) The Development Cycle

A.1) The Six Phases

• Requirement Specification
• Analysis
• Design (algorithms)
• Implementation (programming)
• Testing and Verification
• Deployment, Maintenance, and Support

A.2) Classification of Errors

• Syntax Errors
• Run-time Errors
• Logical Errors

A.3) Control Structures & Structure Charts

• Sequence, Selection and Iteration Structures
• Divide & Conquer
• Parameter Passing
• Function versus Subroutine Subprograms

B) FORTRAN Basics

B.1) Program Layout

• Units The program (source) file is made up of units. Each unit must end with an END statement. The unit which contains the PROGRAM statement is the main program while the remaining ones represent subprograms - they begin with either a FUNCTION or a SUBROUTINE statement.
• Statements Each unit is made up of statements. Each statement occupies one line (i.e. is terminated by ENTER) of up to (about) 70 characters. A statement may be continued on the next line if the last character in it is an ampersand (&). Statements are classified as: comments, non-executables and executables:
  • Comments These lines are used for documentation purposes and are completely ignored by the compiler. They can occupy the entire line (full-line comments) or follow executable statements on the same line (in-line comments). To identify a comment, prefix it by !.
  • Non-Executables These lines require no action from the CPU. They describe the names (identifiers) we are using for: program units (PROGRAM, FUNCTION, and SUBROUTINE), variables (IMPLICIT and type declarations) and constants (PARAMETER).
  • Based on the above, our programs will always have the structure:

                    program somename
                    implicit none
                    !Variable / Constant Declarations
                    !executable statements
                    end
                    !--------------------------------
                    subroutine subname(parameters)
                    implicit none
                    ....
                    end
                    !--------------------------------
                    type function name (parameters)
                    implicit none
                    ....
                    end
            

• Identifiers Names we give to program units, variables and constants are known as identifiers. They can be up to 31 character long and must begin with a letter. The compiler is case-insensitive when it treats identifiers (as well as reserved words) but we follow a particular style in this course, and it dictates certain rules re capitalization.

B.2) Constants and Variables

• Literal Constants: Integer ( [sign][base][#]digits ), Real ( sign, integer, ., fraction, Eexp ), Logical (.true., .false.) and Character (surrounded by apostrophes or double-quotes). To include a double-quote within the string, precede the quote with a back-slash.
• Variables: Choose a meaningful name using upper/lower case to separate words. Variable names are actually pointers to memory addresses, not names of values or contents. You can initialize variables as you declare them by using the slash.
• Symbolic Constants: Declared as variables but made constants (for optimization / software engineering purposes) by using the PARAMETER statement. In our style convention, these are named using all-caps.

B.3) Operators and Expressions

• Arithmetic Operators (), **, *, /, +, - and their precedence
• Character Operators: // for concat. and (1:?) for extracting and/or setting substrings
• Relational Operators: .LT. .LE. .GT. .GE. .EQ. .NE.
• Logical Operators: .NOT. .OR. .AND. .XOR.
• Common pitfalls: Touching or missing operators
• Mixed-type Expressions and the onset of Real Conversion

B.4) Built-in Subprograms

• For Real's: ABS and IABS; EXP and ALOG; SIN/COS/TAN and ASIN/...; SQRT
• For Integers: FLOAT (integer to real) and MOD
• For Strings: LEN, INDEX, CHAR, ICHAR
• For Simulations: rand

B.5) Input & Output

• Unformatted (list-directed): print*, read*, write(*,*) and read(*,*)
• Formatted:
  • Replace the 2nd asterisk by the numeric label of the format statement to use.
  • The format statement must contain an edit descriptor for each written or read value.
  • Edit Descriptors:
    • 'any literal' (for a literal to be printed as-is)
    • nX (skip n columns), Tn (skip to tab position n),
    • In (integer with field width n)
    • An (string with an optional field width n)
    • Ln (logical with field width n)
    • Fn.m (real with field width n and m decimals)
    • En.m (real in scientific notation with field width n and m decimals).
  • We rarely use formatting on input (as it makes it unnecessarily restrictive) except in one situation where we almost always use it; namely, string input. Without an A edit descriptor, entered strings must be surrounded by single quotes.
• File-Oriented:
  • Replace the first asterisk by a unit number (10-99).
  • The unit number must be associated with a file name through the OPEN statement.
  • File I/O statements:
    • OPEN (file='filename', unit=n) to associate the filename with the unit number. You can either read or write to a file. Note that if you open a file intending to write on it and it already exists, it will be deleted and re-created; i.e. you'll loose its old data.
    • CLOSE (n) to remove the association created by open
    • REWIND (n) retuirn the file pointer to the beginning of the file. Useful for reading the fille more than once (faster than closing and re-openning it).
  • If the filename includes a path, use a forward slash as a separator (or two back-slashes) rather than a back-slash.
  • We normally use a sentinel (special value) to detect end of file and, hence, avoid reading past the end. If a file does not have a sentinel, you can use a variant of READ which detects EOF.