Fortran 77 Tutorial

Fortran is the dominant programming language used in engineering applications. It is therefore important for engineering graduates to be able to read and modify Fortran code. From time to time, so-called experts predict that Fortran will rapidly fade in popularity and soon become extinct. These predictions have always failed. Fortran is the most enduring computer programming language in history. One of the main reasons Fortran has survived and will survive is software inertia. Once a company has spent many man-years and perhaps millions of dollars on a software product, it is unlikely to try to translate the software to a different language. Reliable software translation is a very difficult task.

A major advantage Fortran has is that it is standardized by ANSI (American National Standards Institute) and ISO (International Standards Organization). Consequently, if your program is written in ANSI Fortran 77, using nothing outside the standard, then it will run on any computer that has a Fortran 77 compiler. Thus, Fortran programs are portable across machine platforms (for more details, check the Fortran Standards Documents).

A Fortran program generally consists of a main program (or driver) and possibly several subprograms (procedures or subroutines). For now we will place all the statements in the main program; subprograms will be treated later. The structure of a main program is:

The stop statement is optional and may seem superfluous since the program will stop when it reaches the end anyway, but it is recommended to always terminate a program with the stop statement to emphasize that the execution flow stops there.

You should note that you cannot have a variable with the same name as the program.

Fortran 77 is not a free-format language, but has a very strict set of rules for how the source code should be formatted. The most important rules are the column position rules:

Most lines in a Fortran 77 program start with 6 blanks and end before column 73, i.e. only the statement field is used.

A line that begins with the exclamation mark (!) in the first column is a comment. Comments may appear anywhere in the program. Well-written comments are crucial to program readability. Commercial Fortran codes often contain about 50% comments.

Sometimes, a statement does not fit into the 66 available columns of a single line. One can then break the statement into two or more lines, and use the continuation mark in position 6. Example:

The continuation character can be the plus sign (+) or an ampersand (&).

In the statement field, blank spaces are significant only as delimiters between identifiers and reserved words.

To install Fortran 77 on a computer running Ubuntu or any other Debian-based Linux distribution, type at the command line terminal:

A Fortran program consists of plain text that follows certain rules (syntax). This is called the source code. You need to use an editor to write (edit) the source code. The most common editors in Unix/Linux are emacs and vi, but these can be a bit tricky for novice users. You may want to use a simpler GUI editor, like gedit or pluma.

When you have written a Fortran program, you should save it in a file that has the .f extension. Before you can execute the program, you have to translate the program into machine readable form. This is done by a special program called a compiler. The Fortran 77 compiler is called f77. The output from the compilation is given the somewhat cryptic name a.out by default, but you can choose another name if you wish. To run the resulting program, simply type the name of the executable file prepending it with a dot slash (./), for example: ./a.out. (This explanation is a bit oversimplified. Really the compiler translates source code into object code and the linker/loader makes this into an executable.)

You can compile and run the circle.f source file by following these steps:

Note that there are several dots (periods) there which can be easy to miss! If you need to have several executables at the same time, it is a good idea to give the executables descriptive names. This can be accomplished using the -o option. For example,

will compile the file circle.f and save the executable in the file circle.out. Please note that object codes and executables take a lot of disk space, so you should delete them when you are not using them. (The remove command in Unix/Linux is rm.)

In the previous examples, we have not distinguished between compiling and linking. These are two different processes but the Fortran compiler performs them both, so the user usually does not need to know about it.

Variable names in Fortran consist of one ore more characters chosen from the letters a …​ z and the digits 0 …​ 9. The first character must be a letter. Fortran 77 does not distinguish between upper and lower case.

The words which make up the Fortran language are called reserved words and cannot be used as variable names. Some of the reserved words which we have seen so far are: program, real, stop and end.

Every variable should be defined in a declaration. This establishes the type of the variable. The valid declarations are:

The list of variables should consist of variable names separated by commas. Each variable should be declared exactly once. It’s an error to use an undeclared variable.

Fortran 77 has one type for integer variables. Integers are stored as 32 bits (4 bytes) variables. Therefore, all integer variables should take on values in the range [-m, m] where m is approximately 2×10⁹.

Fortran 77 has one type for floating point variables, called real. This type uses 4 bytes.

Some constants appear many times in a program. It is then often desirable to define them only once, in the beginning of the program. This is what the parameter statement is for. It also makes programs more readable. For example, the circle area program should rather have been written like this:

The syntax of the parameter statement is:

The rules for the parameter statement are:

Some good reasons to use the parameter statement are:

The simplest form of an expression is a constant. There are four types of constants, corresponding to the four data types. Here are some integer constants:

Then we have real constants:

The E-notation means that you should multiply the constant by 10 raised to the power following the E. Hence, 2.0E6 is two million, while 3.333E-1 is approximately one third.

The next type is logical constants. These can only have one of two values:

Note that the dots enclosing the letters are required.

The last type is character constants. These are most often used as an array of characters, called a string. These consist of an arbitrary sequence of characters enclosed in apostrophes (single quotes):

Strings and character constants are case sensitive. A problem arises if you want to have an apostrophe in the string itself. In this case, you should double the apostrophe:

The simplest non-constant expressions are of the form:

and an example is:

The result of an expression is itself an operand, hence we can nest expressions together like

This raises the question of precedence: Does the last expression mean x + (2 * y) or (x + 2) * y? The precedence of arithmetic operators in Fortran 77 are (from highest to lowest):

All these operators are calculated left-to-right, except the exponentiation operator **, which has right-to-left precedence. If you want to change the default evaluation order, you can use parentheses.

The above operators are all binary operators. There is also the unary operator - for negation, which takes precedence over the others. Hence an expression like -x+y means what you would expect.

Extreme caution must be taken when using the division operator, which has a quite different meaning for integers and reals. If the operands are both integers, an integer division is performed, otherwise a real arithmetic division is performed. For example, 3/2 equals 1, while 3.0/2.0 equals 1.5 (note the decimal points).

The assignment has the form:

The interpretation is as follows: Evaluate the right hand side and assign the resulting value to the variable on the left. The expression on the right may contain other variables, but these never change value! For example,

does not change the value of pi or r, only area.

When different data types occur in the same expression, type conversion has to take place, either explicitly or implicitly. Fortran will do some type conversion implicitly. For example:

will convert the integer one to the real number one, and has the desired effect of incrementing x by one. However, in more complicated expressions, it is good programming practice to force the necessary type conversions explicitly. For numbers, the following functions are available:

The first two have the obvious meaning. ichar takes a character and converts it to an integer, while char does exactly the opposite.

Truth values can be stored in logical variables. The assignment is analogous to the arithmetic assignment. Example:

The order of precedence is important, as the last example shows. The rule is that arithmetic expressions are evaluated first, then relational operators, and finally logical operators. Hence b will be assigned .false. in the example above. Among the logical operators the precedence (in the absence of parenthesis) is that .not. is done first, then .and., then .or. is done last.

Logical variables are seldom used in Fortran. But logical expressions are frequently used in conditional statements like the if statement.

if statements can be nested in several levels. To ensure readability, it is important to use proper indentation. Here is an example:

You should avoid nesting many levels of if statements since things get hard to follow.

The do-loop is used for simple counting. Here is a simple example that prints the cumulative sums of the integers from 1 through n (assume n has been assigned a value elsewhere):

The number 10 is a statement label. Typically, there will be many loops and other statements in a single program that require a statement label. The programmer is responsible for assigning a unique number to each label in the main program and in each subprogram (function or subroutine). Recall that column positions 1-5 are reserved for statement labels. The numerical value of statement labels have no significance, so any integers (from 0 to 99999) can be used, in any order. Typically, most programmers use consecutive multiples of 10.

The variable defined in the do-statement is incremented by 1 by default. However, you can define the step to be any number but zero. This program segment prints the even numbers between 1 and 10 in decreasing order:

The general form of the do-loop is as follows:

var is the loop variable (often called the loop index) which must be integer. expr1 specifies the initial value of var, expr2 is the terminating bound, and expr3 is the increment (step).

In the C-family languages a while-loop looks like this:

The program will alternate testing the condition and executing the statements in the body as long as the condition in the while statement is true. In Fortran 77 you must use if and goto to get the same behaviour:

Here is an example that calculates and prints all the powers of two that are less than or equal to 100:

If the termination criterion is at the end instead of the beginning, it is often called an do-while-loop. In the C-family languages it looks like this:

Again, this should be implemented in Fortran 77 by using if and goto:

The simplest array is the one-dimensional array, which is just a sequence of elements stored consecutively in memory. For example, the declaration

declares a as a real array of length 20. That is, a consists of 20 real numbers stored contiguously in memory. The size of the array has to be specified as a positive integer constant or a name defined using a parameter statement. Fortran arrays are indexed from 1 and up. Thus the first number in the array is denoted by a(1) and the last by a(20).

The type of an array element can be any of the basic data types. Examples:

Each element of an array can be thought of as a separate variable. You reference the i^th element of array a by a(i). Here is a code segment that stores the 10 first square numbers in the array sq:

A common bug in Fortran is that the program tries to access array elements that are out of bounds or undefined. This is the responsibility of the programmer, and the Fortran compiler will not detect any such bugs!

Matrices are very important in linear algebra. Matrices are usually represented by two-dimensional arrays. For example, the declaration

defines a two-dimensional array of 3 * 5 = 15 real numbers. It is useful to think of the first index as the row index, and the second as the column index. Hence we get the graphical picture:

It is quite common in Fortran to declare arrays that are larger than the matrix we want to store. (This is because Fortran does not have dynamic storage allocation.) This is perfectly legal. Example:

You may assume that the unused portion of the matrix will be initialized with zeros.

Fortran functions are quite similar to mathematical functions: They both take a set of input arguments (parameters) and return a value of some type. In the preceding discussion we talked about user defined subprograms. Fortran 77 also has some intrinsic (built-in) functions.

A simple example illustrates how to use a function:

Here cos is the cosine function, so x will be assigned the value 0.5 (if pi has been correctly defined; Fortran 77 has no built-in constants). These are the Fortran 77 intrinsic functions:

All these function take a real parameter and return a real result.

Now we turn to the user-written functions. Consider the following problem: A meteorologist has studied the precipitation levels in the Bay Area and has come up with a model r(m, t) where r is the amount of rain, m is the month, and t is a scalar parameter that depends on the location. Given the formula for r and the value of t, compute the annual rainfall.

The obvious way to solve the problem is to write a loop that runs over all the months and sums up the values of r. Since computing the value of r is an independent subproblem, it is convenient to implement it as a function. The following main program can be used:

Note that we have declared r to be real just as we would a variable. In addition, the function r has to be defined as a Fortran function that corresponds to what the meteorologist came up with:

We see that the structure of a function closely resembles that of the main program. The main differences are:

To sum up, the general syntax of a Fortran 77 function is:

The function has to be declared with the correct type in the calling program unit, it’s an error not to do so. The function is called by simply using the function name and listing the arguments in parenthesis.

Functions can be recursive.

A Fortran function can essentially only return one value. Often we want to return two or more values (or sometimes none!). For this purpose we use the subroutine construct. The syntax is as follows:

Note that subroutines have no type and consequently should not (cannot) be declared in the calling program unit. They are also invoked differently than functions, using the word call before their names and arguments.

Subroutines can also be recursive.

We give an example of a very simple subroutine. The purpose of the subroutine is to swap two integers.

Note that there are two blocks of variable declarations here. First, we declare the input/output parameters, i.e. the variables that are common to both the caller and the callee. Afterwards, we declare the local variables, i.e. the variables that can only be used within this subprogram. We can use the same variable names in different subprograms and the compiler will know that they are different variables that just happen to have the same names.

Fortran 77 uses the so-called call-by-reference paradigm. This means that instead of just passing the values of the function/subroutine arguments (call-by-value), the memory address of the arguments (pointers) are passed instead. A small example should show the difference:

The output from this program is "2 1", just as one would expect. However, if Fortran 77 had been using call-by-value then the output would have been "1 2", i.e. the variables m and n were unchanged! The reason for this is that only the values of m and n had been copied to the subroutine iswap, and even if a and b were swapped inside the subroutine the new values would not have been passed back to the main program.

In the above example, call-by-reference was exactly what we wanted. But you have to be careful about this when writing Fortran code, because it is easy to introduce undesired side effects. For example, sometimes it is tempting to use an input parameter in a subprogram as a local variable and change its value. Since the new value will then propagate back to the calling program with an unexpected value, you should never do this unless (like our iswap subroutine) the change is part of the purpose of the subroutine.

We will come back to this issue in a later section on passing arrays as arguments.

Fortran subprogram calls are based on call-by-reference. This means that the calling parameters are not copied to the called subprogram, but rather that the addresses of the parameters are passed. This saves a lot of memory space when dealing with arrays. No extra storage is needed as the subroutine operates on the same memory locations as the calling (sub-)program. However, you as a programmer have to know about this and take it into account.

It is possible to declare local arrays in Fortran subprograms, but this feature is rarely used. Typically, all arrays are declared in the main program and then passed on to the subprograms as needed.

For example, a basic vector operation is the saxpy operation (single-precision alpha times x plus y). This calculates the expression:

where alpha is a scalar but x and y are vectors. Here is a simple subroutine for this:

Suppose you have two parameters alpha and beta that many of your subroutines need. The following example shows how it can be done using common blocks.

Here we define a common block with the name coeff. The contents of the common block are the two variables alpha and beta. A common block can contain as many variables as you like. They do not need to all have the same type. Every subroutine that wants to use any of the variables in the common block has to declare the whole block.

Note that in this example we could easily have avoided common blocks by passing alpha and beta as arguments. A good rule is to try to avoid common blocks if possible. However, there are a few cases where there is no other solution.

You should know that

To illustrate this, look at the following continuation of our example:

This declaration is equivalent to the previous version that used alpha and beta. It is recommended that you always use the same variable names for the same common block to avoid confusion. Here is a dreadful example:

Now alpha is the beta from the main program and vice versa. If you see something like this, it is probably a mistake. Such bugs are very hard to find.

Common blocks can include arrays, too. But again, this is not recommended. The major reason is flexibility. An example shows why this is such a bad idea. Suppose we have the following declarations in the main program:

This common block contains first all the elements of A, then the integer n. Now assume you want to use the matrix A in some subroutines. Then you have to include the same declarations in all these subroutines, e.g.

The value of nmax has to be exactly the same as in the main program. Recall that the size of a matrix has to be known at compile time, hence nmax has to be defined in a parameter statement.

This example shows there is usually nothing to gain by putting arrays in common blocks. Hence the preferred method in Fortran 77 is to pass arrays as arguments to subroutines (along with its size).

The read statement is used for input, while the write statement is used for output. To simplify these statements we use asterisks (*) for the arguments, like we have done in most of our examples so far. This is sometimes called list directed read/write.

The first statement will read values from the standard input and assign the values to the variables in the variable list, while the second one writes to the standard output.

Here is a code segment from a Fortran program:

We give the input through standard input (possibly through a data file redirected to the standard input). A data file consists of records according to traditional Fortran terminology. In our example, each record contains a number (either integer or real). Records are separated by blanks. Hence a legal input to the program above would be:

Note that Fortran 77 input is line sensitive, so it is important not to have extra input elements (fields) on a line (record). For example, if we gave the first four inputs all on one line as:

this produces a runtime error.

If there are too few inputs on a line then the next line will be read. For example:

This would produce the same results as the first two examples.

Just like with the data statement, the values for two-dimensional arrays will be read in column-first order. So if we have the following code that declares and reads an array with two rows and four columns:

and the input is:

then, the contents of the array A would be:

In a similar vein, column-first order is also used when printing the contents of two-dimensional arrays using the write statement. So, following the previous example, this statement:

displays this in the standard output:

Notice the consistency between how the input is read and how the output is written.

To ensure portability, use only standard Fortran 77. The only exception we have allowed in this tutorial is to use lower case letters.

The overall program structure should be modular. Each subprogram should solve a well-defined task.

Write legible code, but also add comments in the source explaining what is happening! It is especially important to have a good header for each subprogram that explains each input/output argument and what the subprogram does.

Always use proper indentation for loops and if blocks as demonstrated in this tutorial.

Never let functions have “side effects”, i.e. do not change the value of the input parameters. Use subroutines in such cases.

In the declarations, separate parameters, common blocks, and local variables.

Minimize the use of common blocks.

Minimize the use of goto. Unfortunately it is necessary to use goto in some types of loops.

In many cases it is best to declare all large arrays in the main program and then pass them as arguments to the various subroutines. This way all the space allocation is done in one place. Remember to pass the size of the array.

When you have if-then-elseif statements with multiple conditions, try to place the most likely conditions first.