programming in fortran

7/28/2019 Programming in FORTRAN

1/38

Programming in FORTRAN

FORTRAN as a Programming Language:

The FORTRAN programming language was conceived in the early 1950s the name produced from the

two words FORmula TRANslation. In 1966 the language was standardized and FORTRAN IV was

born.

Revision of the language led to FORTRAN 77, the language we use today. The standard for FORTRAN

90 is now available although not yet in widespread use. F77 is a subset of F90.

FORTRAN was designed for scientists and engineers, and has dominated this field. For the past 30

years FORTRAN has been used for such projects as the design of bridges and aeroplane structures, it

is used for factory automation control, for storm drainage design, analysis of scientific data and so

on.

Throughout the life of this language, groups of users have written libraries of useful standard

FORTRAN programs.

These programs can be borrowed and used by other people who wish to take advantage of the

expertise and experience of the authors, in a similar way in which a book is borrowed from a library.

The individual user may wish to build up their own library of routines they often use.

Course structure.

Work your way through the following

components attempting the exercises as

you come across them:

Programs

Variables

Arithmetic Operations

Input and Output

Looping in Programs

Arrays in Programs

Checking variables

Subprograms and functions

Formatting and File Handling


2/38

Programs and Problem Solving:

A program is a list of instructions or program statements composed in such a way as to enable a

computer to solve a problem. The problem to be solved is broken down into successively smaller

parts. These parts should form a well-defined structure, the large complex problem at the top the

small easy to handle problems at the bottom. Hence the term top down programming.

To get a programming language to help you solve a problem, follow the steps below.

1. State the problem in English2. Examine the problem and break down into several parts.3. Examine the parts and refine into smaller parts.4. Sketch a picture/structure plan5.

Write the main program with references to the subprograms.

6. Test the program.It is important to note that the actual writing of the program is almost the last step.

Program Format

The positions within a line are called columns and are numbered 1, 2, 3, . . ., 80. All FORTRAN

statements must be positioned in columns 7 through 72; characters that appear in columns 73 and

beyond are ignored. If a statement re quires a statement label, this label must appear in columns 1

through 5. Statement labels must be integers in the range 1 through 99999.

Occasionally it may not be possible to write a complete FORTRAN statement using only columns 7

through 72 of a line. In this case, the statement may be continued on another line or lines (up to a

maximum of 19), provided that a continuation indicator is placed in column 6 of the line(s) on which

the statement is continued. This continuation indicator may be any alphabetic or numeric character

other than a zero or a space. A zero or a space in column 6 indicates the first line of a statement.

Lines that contain only blanks or that have the letter C or an asterisk (*) in column 1 represent

comment lines. Comments are not executed but, rather, appear only in the listing of the program

unit. In standard FORTRAN, comments themselves may not be continued from one line to anotherby using a continuation indicator in column 6; instead, all comments must begin with a C or * in

column 1.


3/38

Program Layout:

The general form of a program in FORTRAN is

headingThis statement marks the beginning of the program and

gives it a name.

commented

documentation

This opening documentation contains info about the

program's input, output and purpose.

specification part

This includes the names and types of the constants and

variables used to store input and output values as well as

intermediate results are declared.

execution part

This contains the statements that carry out steps of the

algorithm.


4/38

Here is an example FORTRAN program:

PROGRAM PROJEC

************************************************************************

This program calculates the velocity and height of a projectile given its initial height,initial velocity, and constant Acceleration. Variables used are:

HGHT0 : initial height

HGHT : height at any time

VELOC0 : initial vertical velocity

VELOC : vertical velocity at any time

ACCEL : vertical acceleration

TIME : time elapsed since projectile was launched

Input: none

Output: VELOC, HGHT

************************************************************************

REAL HGHT0, HGHT, VELOC0, VELOC, ACCEL, TIME

ACCEL = -9.807

HGHT0 = 100.0

VELOC0 = 90.0

TIME = 4.3

HGHT = 0.5 * ACCEL * TIME ** 2 + VELOC0 * TIME + HGHT0

VELOC = ACCEL * TIME + VELOC0

PRINT *, 'AT TIME ', TIME, ' THE VERTICAL VELOCITY IS ', VELOC

PRINT *, 'AND THE HEIGHT IS ', HGHT

END


5/38

Variables and Constants:

Variables:

A variable is something that may change in value. A variable might be the number of words on

different pages of this booklet, the air temperature each day, or the exam marks given to a class of

school children.

A variable could be likened to a storage box whose contents may often change. The box or variable

must be given a name to distinguish it from others. According to FORTRAN rules, the variable name

must begin with a letter and may be followed by up to five characters (letters or numbers only).

Variables in FORTRAN are of different types. You specify the type and name of each variable you

intend to use at the top of your program, after the PROGRAM statement and before any other

executable lines. Commented lines are non-executable so they can appear anywhere in the program.

If the variable declarations are omitted, the compiler will make certain assumptions, for example,

that any variables beginning with the letters I, J, K, L, M, and N are INTEGER. The lack of specification

often leads to program errors and it is strongly recommended that variable types are always

declared. Numerical data may be separated into integer and real numbers.

Integers:

Integers are whole numbers, those without a decimal point, (for example 7, 4563, 99) and are stored

in integer variables.

The general form of the declaration of integer variables is:

INTEGER name1, name2

Example:

INTEGER WHOLE, AVERAGE, SUMReals:

Reals are fractional numbers, those including a decimal point, (for example, 0.2, 653.46, 1.0) and are

stored in real variables. Real numbers cannot be stored accurately. The accuracy of a real variable

depends on the computer. The general form of the declaration of a real variable is:

REAL name1, name2


6/38

Example:

REAL FRACT, MEAN, STDDEVCharacters:

Character variables contain one or more characters, (for example G or OXFORD).

The general forms are:

CHARACTER name1, name2 where name1 and name2 are 1character each.

CHARACTER*n name1, name2 where name1 and name2 are n characters in length each.

CHARACTER name1*n1, name2*n2 where name1 is of length n1 and name2 is of length n2.

Constants:

Constants are quantities whose values do not change during program execution. In FORTRAN they

may be of numeric or character type.

Double Precision:

Real data values are commonly called single precision data because each real constant is stored in a

single memory location. This usually gives seven significant digits for each real value. In many

calculations, particularly those involving iteration or long sequences of calculations, single precision

is not adequate to express the precision required. To overcome this limitation, FORTRAN provides

the double precision data type. Each double precision is stored in two memory locations, thus

providing twice as many significant digits.

The general form of the declaration of a double precision variable is:

DOUBLE PRECISION name1, name2

Example: DOUBLE PRECISION ROOT, VELO


7/38

Arithmetic Operations and Functions:

Operations:

In FORTRAN, addition and subtraction are denoted by the usual plus (+) and minus (-) signs.

Multiplication is denoted by an asterisk (*). This symbol must be used to denote every

multiplication; thus to multiply N by 2, we must use2 * N or N * 2 not 2N. Division is denoted by a

slash (/), and exponentiation is denoted by a pair of asterisks (**).

Operator Operation

+ addition, unary plus

- subtraction, unary minus

* Multiplication

/ Division

** Exponentiation

Real Arithmetic:

Providing all variables and constants in the expression are real, real arithmetic will be carried out as

expected, with no decimal places being truncated.

Integer Arithmetic:

Providing the expression has all integers, subtraction, addition, multiplication and exponentiation

will prove no problem. However integer division is somewhat different than normal division with

real values. Integer division ignores the fractional part. Any decimal places are truncated.

Example: 5 / 2 give the result 2 instead of 2.53 / 4 gives the result 0 instead of 0.75

Mixed Mode Arithmetic:

Mixed mode arithmetic is when an expression contains both reals and integers. If ANY of the

operands are real then result of the operation will be real. However, mixed mode arithmetic should

be used with extreme care. You may think you have a real operand when in reality you have two

integer operands.

Example:

5 / 2 * 3.0 is 6.0 Incorrect because the order of operation is left to right. 5/2 = 2 then 2 * 3.0 = 6.0


8/38

3.0 * 5 / 2 is 7.5 Correct because of mixed mode arithmetic 3.0 * 5 = 15.0 then 15.0/2 = 7.5

Mixed Mode Variable Assignments:

If the variable to which an expression is assigned has been declared as a real variable, any decimalplaces resulting from the evaluation of the expression will be preserved.

Example:

Real variable 5 * 2.1 will have a value of 10.5.

However, if the variable to which an expression is assigned has been declared as an integer variable,

any decimal places resulting from the evaluation of the expression will be lost.

Example

Integer variable 5 * 2.1 will have a value of 10

Priority Rules:

Arithmetic expressions are evaluated in accordance with the following priority rules:

All exponentiations are performed first; consecutive exponentiations are performed fromright to left.

All multiplication and divisions are performed next, in the order in which they appear fromleft to right.

The additions and subtractions are performed last, in the order in which they appear fromleft to right.

Functions:

FORTRAN provides several intrinsic functions to carry out calculations on am number of values or

arguments and return as result. Commonly used functions are shown in the table below. To use a

function we simply give the function name followed by the argument(s) enclosed in parenthesis.

Funtionname (name1, name2 ...)


9/38

Some FORTRAN Functions

Function Description Type of Argument(s)* Type of Value

ABS (x) Absolute value of x I, R, DP Same as argument

COS (x) Cosine of x radians R, DP Same as argument

DBLE(x) Conversion of x to double precision form I, R DP

DPROD(x,y) Double precision product of x and y R DP

EXP(x) Exponential function R, DP Same as argument

INT(x) Integer part of x R, DP I

LOG(x) Natural logarithm of x R, DP Same as argument

MAX(x1, . . ,Xn) Maximum of x1, . . .,xn I, R, DP Same as argument

MIN(x1, . .. ,xn) Minimum of x1, . . ., xn I, R, DP Same as argument

MOD(x,y) x (mod y); x - INT(x/y) * y I, R, DP Same as argument

NINT(x) x rounded to nearest integer R, DP I

REAL(x) Conversion of x to real type I, DP R

SIN(x) Sine of x radians R, DP Same as argument

SQRT(x) Square root of x R, DP Same as argument

* I = integer, R = real, DP = double precision.

Assignment Statement

The assignment statement is used to assign values to variables and has the form:

variable = expression

For Example:

x = 2356.0 y = SQRT (25.0) direction = x * y


10/38

Input and Output:

In the preceding section, we considered the assignment statement, which enables us to calculate the

values of expressions and store the results of these computations by assigning them to variables. An

assignment statement does not, however, display these results on an output device, nor does it

allow the user to enter new values during execution. For example, if a projectile is launched from an

initial height of HGHT0 with an initial vertical velocity of VELOC0 and a vertical acceleration of ACCEL,

then the equations

HGHT = 0.5 * ACCEL * TIME ** 2 + VELOCO * TIME + HGHT0

And


Give the height (HGHT) and the vertical velocity (VELOC) at any TIME after launch. The program

below assigns the value9.807 (m/sec2) to ACCEL, 150.0 (m) to HGHT0, 100.0 (m/sec) to VELOCO,

and 5.0 (sec) to TIME and then computes the corresponding values of HGHT and VELOC.

PROGRAM PROJEC

************************************************************************

This program calculates the velocity and height of a projectile given its initial height,

initial velocity, and constant acceleration. Variables used are: *







Input: none

Output: none

************************************************************************


ACCEL = -9.807

HGHT0 = 150.0

VELOC0 = 100.0

TIME = 5.0


11/38



END

The values of HGHT and VELOC are calculated as desired, but they are stored internally and are not

displayed to the user. Moreover, if the same calculation is to be done for the same acceleration but

with values 100.0 for HGHT0, 90.0 for VELOC0, and 4.3 for TIME, then several statements must be

modified, as shown in below, and the program executed again.

PROGRAM PROJEC

************************************************************************


initial velocity, and constant acceleration. Variables used are:







Input: none

Output: none

************************************************************************


ACCEL = -9.807

HGHT0 = 100.0

VELOC0 = 90.0

TIME = 4.3



END


12/38

The output statement that we consider in this section provides a method for easily displaying

information. We also consider an input statement that provides a convenient way to assign values

from an external source during execution of the program.

FORTRAN provides two types of input/output statements. In the first type, the programmer must

explicitly specify the format in which the data is presented for input or, in the case of output, the

precise format in which it is to be displayed. In the second type of input/output, certain

predetermined standard formats that match the types of items in the input/output list are

automatically provided by the compiler. It is this second type, known as list-directed input/output

that we consider in this section.

List-Directed Output:

The simplest list-directed output statement has the following form:

List-Directed Output Statement

Form:

PRINT *, output-list

where:

Output-list is a single expression or a list of expressions separated by commas. Each of these

expressions is a constant, a variable, or a formula.

The statement may also be used in the form

PRINT *

Where no output list is used.

Purpose:

Displays the values of the items in the output list. Each PRINT statement produces a new line of

output. If the output list is omitted, a blank line is displayed.

For example, to display some of the relevant information from the preceding example, we might addtwo PRINT statements, as shown below. Execution of the program produces output similar to that

shown. The exact format and spacing used to display these values are compiler dependent; for

example, in some systems, real values might be displayed in scientific notation, and the number of

spaces in an output line might be different from that shown.

PROGRAM PROJEC

************************************************************************

This program calculates the velocity and height of a projectile given its initial height,initial velocity, and constant acceleration. Variables used are:


13/38







Input: HGHT0, VELOC0, TIME

Output: VELOC, HGHT

************************************************************************


ACCEL = -9.807

READ *, HGHT0, VELOC0, TIME





END

In some situations, one or more blank lines in the output improve readability. A blank line can be

displayed by a PRINT statement of the form

PRINT *

In which the output list is empty. Note that the comma that normally follows the * is also omitted.

Execution of each statement of this form causes a single blank line to be displayed.

List-Directed Input

The simplest form of the list-directed input statement is


14/38

List-Directed Input Statement

READ *, input-list

where

Input-list is a single variable or variables separated by commas.

Purpose:

Causes the transfer of values from some external source (usually the keyboard or a file) and the

assignment of these values to the variables in the input list. The following rules apply:

i. A new line of data is processed each time a READ statement is executed.ii. If there are fewer entries in a line of input data than there are variables in the input list,

successive lines of input are processed until values for all variables in the list have been

obtained.

iii. If there are more entries in a line of input data than there are variables in the input list, thefirst data values are used, and all remaining values are ignored.

iv. The entries in each line of input data must be constants and of the same type as thevariables to which they are assigned. (However, an integer value may be assigned to a real

or a double precision variable, and a real value may be assigned to a double precision

variable, with automatic conversion taking place.)

v. Consecutive entries in a line of input data must be separated by a comma or by one or morespaces

For example, the statement

READ *, HGHTO, VELOCO, TIME

assigns values to the variables HGHTO, VELOCO, and TIME. Therefore, this single READ statement

replaces the three assignment statements used to assign values to these variables in the preceding

examples. The modified program is shown below.

PROGRAM PROJEC

************************************************************************








15/38




Output: VELOC, HGHT

************************************************************************


ACCEL = -9.807

READ *, HGHT0, VELOC0, TIME





END

In an interactive mode of operation, the values assigned to variables in an input list are entered

during program execution. In this case, when a READ statement is encountered, program execution

is suspended while the user enters values for all the variables in the input list.

Program execution then automatically resumes. Because execution is interrupted by a READ

statement and because the correct number and types of values must be entered before execution

can resume, it is good practice to provide some message to prompt the user when it is necessary to

enter data values. This is accomplished by preceding each READ statement with a PRINT statement

that displays the appropriate prompts. The program below illustrates this by prompting the user

when values for HGHT0, VELOC0, and TIME are to be entered; it is a modification of the program in

above.

PROGRAM PROJEC

************************************************************************




16/38








Output: VELOC, HGHT

************************************************************************


ACCEL = -9.807

PRINT *, 'ENTER THE INITIAL HEIGHT AND VELOCITY:'

READ *, HGHT0, VELOC0

PRINT *, 'ENTER TIME AT WHICH TO CALCULATE HEIGHT AND VELOCITY:'

READ *, TIME





END

Now go to the exercises and work your way through the input/output and arithmetic problems.


17/38

Iteration (or Looping):

DO Loops:

A DO loop allows repetition of a section of program a set number of times. In DO loops the section

to be repeated is started with the statement DO and ended with a labelled CONTINUE statement.

The repeated part of the program is called the loop body, and the number of times this is repeated isset by the START, STOP and STEP values.

DO n X = START, STOP, STEP

.

.

loop body

.

.

.

n CONTINUE

Where

n is a statement line number containing the region for the repetitive loop. It can be a positive integer

of up to five digits. X will be incremented each time round the loop by the value of STEP. Its initial

value is START and looping will end when x exceeds the value STOP at which point the program will

carry on after the CONTINUE statement. X is called the loop index and must be an integer variable.

The name is not restricted to X. It is also possible to have implied DO loops.

Example

DO 12 J = 1, 10

12 CONTINUE

When the STEP value is omitted from the expression, its default value is set to 1. The loop body is

normally indented to support readability of programs.

Example

DO 20 I = 10, 0,-1

Print *, I

20 CONTINUE

In the above example the value of I is printed. Initially it is 10 and reduces by one each time round

the loop until I has a value of -1.

Now go to the exercises and work your way through the looping problems.


18/38

One Dimensional Arrays:

An array is a set of related variables that have the same name and are of the same type (REAL,

INTEGER, CHARACTER). For example, a group of 10 students are given marks for a particular essay.

The marks could be assigned to 10 individual variables each of a different name, MARK1, MARK2 ...

MARK10.

Or this set of values could be given a group or array name of MARK and each individual value, called

an array element, can be referred to by a subscript number from 1 to 10. The first student's mark is

referred to as MARK (1), the second as MARK (2) and so on. A note on pronunciation: MARK (1)

would be said as mark sub

Because accessing the values in the various elements of an array is done by just referring to the

subscript, working with groups of values becomes relatively easy. For example, finding the total of

the marks given could be found using a DO loop index to refer to successive addresses as follows:

SUM = 0

DO 25 I = 1, 10

SUM = SUM + MARK (1)

25 CONTINUE

To do a similar calculation without an array, you would have to write one huge assignment

statement:

SUM = MARKl+MARK2+MARK3+...+MARK9+MARK10

Imagine how long that assignment statement be if you wanted to sum 100 or even 1000 numbers!

Array Declarations

Arrays must be declared at the beginning of the program. The easiest way to do this is to state what

type of values the array will contain (REAL, INTEGER, CHARACTER) followed by the name of the array

followed by the number of elements in the array enclosed in brackets.

INTEGER NAME1(n)

REAL NAME2(n)

where:

NAME1 and NAME2 are array names and n is the number of array elements

Example:

INTEGER MARK (10)

REAL TABLE (25), TIME (50)

In the above example, MARK will hold 10 integer values with addresses (subscripts) beginning at 1.

TABLE will hold 25 real values with addresses beginning at l and TIME will hold 50 real values with


19/38

addresses beginning at 1. It is important to differentiate between an address of an array element

and the contents of an array element. The contents of an array element can change, the address

cannot.

Sometimes you may want the addresses of an array to begin at a different number than 1. In these

instances, you can use an extended form of the declaration, stating the minimum and maximum

values of the subscript.

INTEGER NAME1(L:U)

REAL NAME2(L:U)

where:

NAME1 and NAME2 are array names of 6 alphanumeric characters. L is the lower subscript value. U is the

upper subscript value.

Example

INTEGER ERROR (-10:10)

REAL SECNDS (0:50)

Initial Values for Arrays

You can use an assignment statement to fill up arrays:

MARK (1) = 23.5

MARK (2) = 45

MARK (10) = 85

Values for array elements can also be read from the keyboard within a loop:

DO 10 I = l, N

READ *, AGE (I)

10 CONTINUE

However, for arrays of any significant size, reading from a file is more efficient:

COUNT = 15

DO 20 J = 1, COUNT

READ (1,*) NAME (J), NUMBER (J)

20 CONTINUE

The program segment above will repeat the following sequence 15 times: read two values from the

file opened with unit number 1, put the first value into the Jth address for NAME and the second

value into the Jth address for NUMBER.


20/38

This works fine if you have two columns in the data file, the first column goes into the array NAME

and the second column goes into the array NUMBER. What if you know the first 15 values in the file

will go into one array? A statement referring to the array without subscripts like the one below will

do the trick.

REAL NUMBER (15)

READ (1,*) NUMBER

Printing of Arrays

All the elements of an array will be printed if the array name is used without a subscript:

Now go to the exercises and work your way through the array problems.


21/38

Decisions:

The IF ... THEN Statement

Decisions in FORTRAN are accomplished with an IF-THEN program structure. Usually the block of

code affected by the decision is indented to make it stand out from the rest of the program. The

logical expression is something that is true or false. If it is true, the block of FORTRAN statements is

carried out. If it is false, the program continues from the statement after the END IF.

IF (logical expression) THEN

block

END IF

The most common form of logical expression takes the form:

(Arithmetic Expression Relational Operator Arithmetic Expression)

Example

(A .GT. 0)

The relational operators are: (note that the full stops must be on either side)

.GT. Greater than

.LT. Less than

.EQ. Equal to

.GE. Greater than or equal to

.LE. Less than or equal to

.NE. Not equal to

Logical expressions may be linked with the logical operators:

.AND. and. OR.Note: When using .AND. or .OR. Each logical expression must be bracketed and the entire logical

expression must also be bracketed, as in the example below.

Example

IF ((A.GT.B).AND. (B.LT.C)) THEN

END IF

IF ((C.GT.D).OR. (B.EQ.C)) THEN

IF ((C.GT.D).OR. (B.EQ.C)) THEN


22/38

END IF

Logical expressions may be preceded by .NOT. This reverses the expressions truth.

Example

IF (.NOT. (A.GT.B)) THEN

END IF

In English the above expression reads: if A is not greater than B.

IF ... THEN ... ELSE...

This decision structure is used if code is to be executed whether the logical expression is true or

false. In the example below, Block A is executed if the expression is true and Block B is executed if

the expression is false.

IF (logical expression) THEN

Block A

ELSE

Block B

END IF

IF ... THEN ... ELSE IF ... THEN...

This structure is used when more than one block of code can be executed if the initial logical

expression is false or if you need to make additional decisions. Because there are more blocks with

the potential for execution, there need to be additional decisions to determine if the block can be

executed or not. If none of the decisions are true, then none of the blocks are executed.

IF (decision 1) THEN

Block A

ELSE IF (decision 2) THEN

Block B


Block C

END IF


23/38

IF ... THEN ELSE IF ... THEN ELSE

This is a third possible decision structure which can be used to make multiple decisions. If none of

those decisions are true then Block D is executed.

IF (decision1) THEN

Block A

ELSE IF (decision2) THEN

Block B


Block C

ELSE

Block D

END IF

IF without THEN and END IF

There is an additional decision structure which may be useful. If the block of code you wish to

execute is only one line and there are no additional decisions to be made, you can eliminate the

THEN and the END IF statements. You cannot do something like this with ELSE and ELSE IF decision

structures.

Example

IF (A .GT. B) PRINT*, 'B is greater than A'

IF (NUMBER .LT. MIN) MIN = NUMBER

Now go to the exercises and work your way through the checking variables exercise.


24/38

Functions and Subroutines:

Functions and subroutines are FORTRAN's subprograms. Most problems that require a computer

program to solve them are too complex to sit down and work all the way through them in one go.

Using subprograms allows you to tackle bite size pieces of a problem individually. Once each piece is

working correctly you then put the pieces together to create the whole solution. To implement

functions and subroutines, first write a main program that references all of the subprograms in the

desired order and then start writing the subprograms. This is similar to composing an outline for an

essay before writing the essay and will help keep you on track.

Functions:

The purpose of a function is to take in a number of values or arguments, do some calculations with

those arguments and then return a single result. There are some functions which are written into

FORTRAN and can be used without any special effort by you, the programmer. They are called

intrinsic functions. There are over 40 intrinsic functions in FORTRAN and they are mainly concerned

with mathematical functions.

The general way to activate a function is to use the function name in an expression. The function

name is followed by a list of inputs, also called arguments, enclosed in parenthesis:

answer = functionname (argument1, argument2, . . .

Example:

PRINT*, ABS (T)The compiler evaluates the absolute value of T and prints it

out

Y = SIN (X) + 45The compiler calculates the value of sin x, adds 45 then puts

the result into the variable Y, where x is in radians.

M=MAX(a,b,c,d)

The compiler puts the maximum value of a, b, c and d into

the variable M. If a=2, b=4, c=1 and d=7, then M would

have a value of 7.

C=SQRT ( a* * 2

+b* * 2 )

The compiler evaluates the expression, a**2+b**2, sends

that value to the SQRT function, and places the answer in

the variable

As shown by the MAX function example above, a function may have one or more arguments but will

only give one result. Also, as shown by the SQRT function example above, the argument for a

function does not have to be a variable. It can be an expression or even a constant if you want to

reference it again. One last item to remember, you must use result of a function call in an

assignment statement or a PRINT statement, as shown in the examples above.


25/38

External Functions:

The intrinsic functions in FORTRAN are useful but there will be a time when there is no intrinsic

function to meet your needs. When this occurs you may write your own function subprogram.

You have to do one thing in the main program to use an external function. You need to declare the

function name in the variable declaration section. Function names follow the same rules as forvariable names: less than six letters or numbers and beginning with a letter. Because of this, function

names should not be used as variable names. Once that is done and the function is written,

activating it is just like activating an intrinsic function.

Now you are ready to write your function. There are a few rules for writing external functions:

Function subprograms and any other subprograms are placed after the END statement ofthe main program.

They are started with a line that includes the type of value the function will return, thefunction name, and the list of arguments the function takes as inputs.

Any variables the function uses, including the arguments, must be declared in the functionright after the first line. The function name is not declared within the function.

You must use the function name in an assignment statement within the function. This is howthe compiler knows which value to pass back to the main program.

A function must finish with RETURN and END statements.The example program below shows how to write an external function which calculates the average

of three numbers. Note the argument list in the main program does not use the same variable

names as the argument list in the function. This is not a problem because a function is a self-

contained entity whose only tie with the main program is the order of the values in the argument

list. So in the first reference to the function, the value in A (5.0) gets transferred to x, the value in B

(2.0) to Y and the value in c (3.0) to z. However, in the third reference to the function, it is the

squared values (25.0, 4.0, 9.0) that are transferred to x, Y and z respectively in the function. Note

also that the variable SUM is used only in the function and therefore is declared only in the function.

Example Program

PROGRAM FUNDEM

C Declarations for main program

REAL A,B,C

REAL AV, AVSQ1, AVSQ2

REAL AVRAGE

C Enter the data

DATA A,B,C/5.0,2.0,3.0/


26/38

C Calculate the average of the numbers

AV = AVRAGE(A,B,C)

AVSQ1 = AVRAGE(A,B,C) **2

AVSQ2 = AVRAGE(A**2,B**2,C**2)

PRINT *,'Statistical Analysis'

PRINT *,'The average of the numbers is: ',AV

PRINT *,'The average squared of the numbers: ',AVSQ1

PRINT *,'The average of the squares is: ', AVSQ2

END

REAL FUNCTION AVRAGE(X,Y,Z)

REAL X,Y,Z,SUM

SUM = X + Y + Z

AVRAGE = SUM /3.0

RETURN

END

Subroutines:

You will want to use a function if you need to do a complicated calculation that has only one result

which you may or may not want to subsequently use in an expression. Recall the external function

example program where the average was called and then squared in one line. Subroutines, on the

other hand, can return several results. However, calls to subroutines cannot be placed in an

expression.

In the main program, a subroutine is activated by using a CALL statement which include the

subroutine name followed by the list of inputs to and outputs from the subroutine surrounded by

parenthesis. The inputs and outputs are collectively called the arguments.

A subroutine name follows the same rules as for function names and variable names: less than six

letters and numbers and beginning with a letter. Because of this, subroutine names should be

different than those used for variables or functions.

As with functions, there are some rules for using subroutines. Keep these in mind when writing your

subroutines:


27/38

You do not need to declare the subroutine name in the main program as you do with afunction name.

They begin with a line that includes the word SUBROUTINE, the name of the subroutine, andthe arguments for the subroutine.

One way of indicating which variables are inputs and which are outputs is to put the inputs on thefirst line, use a continuation marker and put the outputs on the second line. See the example

program for an application of this programming style.

All variables used by the subroutine, including the arguments, must be declared in the subroutine.

The subroutine name is not declared anywhere in the program.A subroutine is finished off with a

RETURN and an END statement.

Exercise 4: Subroutines

In larger programs it is good programming style to include after the FUNCTION or SUBROUTINE

statements comments explaining the meanings of the arguments and what the subprogram does.

A hint when you are debugging your programs: When extraordinary, incorrect numbers start

appearing from nowhere as your program runs, you probably have not got your subroutine

arguments in the right order in either the main program or in the subroutine. The same trick applies

to functions. Example Program

PROGRAM SUBDEM

REAL A,B,C,SUM,SUMSQ

CALL INPUT( + A,B,C)

CALL CALC(A,B,C,SUM,SUMSQ)

CALL OUTPUT(SUM,SUMSQ)

END

SUBROUTINE INPUT(X, Y, Z)

REAL X,Y,Z

PRINT *,'ENTER THREE NUMBERS => '

READ *,X,Y,Z

RETURN

END

SUBROUTINE CALC(A,B,C, SUM,SUMSQ)


28/38

REAL A,B,C,SUM,SUMSQ

SUM = A + B + C

SUMSQ = SUM **2

RETURN

END

SUBROUTINE OUTPUT(SUM,SUMSQ)

REAL SUM, SUMSQ

PRINT *,'The sum of the numbers you entered are: ',SUM

PRINT *,'And the square of the sum is:',SUMSQ

RETURN

END

Now go to the exercises and work your way through the subprograms and functions.


29/38

Formatting and File Handling:

Formatted Input and Output

Input from the keyboard and output to the screen are possible using the READ and PRINT

statements. So far only list-directed input and output has been encountered, READ * and PRINT *.

The programmer has had little control over the way in which data can be input and the layout ofprinted results. Input and output statements can contain information on how input data should be

interpreted and how output data should be laid out. The information is placed in a FORMAT

statement.

Edit Descriptors

FORMAT statements contain edit descriptors that provide layout information.

Exponentials are numbers adjusted so they are expressed as: 0.dddd x 10X. In FORTRAN notation

such a number is written:

s0.dddd x 10X.

The italicised letters represent the mantissa and the underlined letters, the exponent.

Where:

s is sign of the mantissa and sign of the exponent d is significant figures of mantissa x is number of digits in exponent

Variable Type Edit Descriptor Specifications

Integer I w w is width of value

Reals Fw. d w is width of value

(including negative

sign, decimal point

and decimal places) of

value, d decimalplaces displayed

Character Aw w characters in width

Blanks nX n blanks

Exponential Ew. d d significant figures in

the mantissa, w total

width (d + 7 )

The table below shows the edit descriptor you would use to display each value.


30/38

Value Edit Descriptor

2099 i4

-72.81 f6.2

1.86x105 (+0.186E+06) e10.3

Cup of Tea a10

The Format Statement

The general form of the FORMAT statement is:

label FORMAT(c, ed1, ed2,'Text message to the screen', ed3...)

Where

label is an identifying number for PRINT or READ.

edl,ed2 are edit descriptors separated by commas

text messages are surrounded by single quotes

c is carriage control for OUTPUT only and can be:

lx moving the output to the next line

O double spacing the output

+move to beginning of line, overwriting anything

already there

l start a new page

The single quotes around the carriage control codes must be there. A comma (, ) is usually used to

separate edit descriptors and text messages but if a slash / is used, instead of a comma, subsequent

output will be on a new line. You have to put a carriage control code after a slash to indicate what

kind of spacing you want.

The label on a FORMAT statement replaces the * in a PRINT or READ statement. Up to this point, anytext messages you wanted printed out were included in the PRINT * statement. With formatted

output you must put the text message in the format statement. Only variable names may be

included on a formatted PRINT or READ statement.


31/38

Formatted Input

Getting a formatted READ to work correctly is very tricky to do. Every blank specified in the FORMAT

statement must be present and the values have to appear exactly as specified in the FORMAT

statement. The only real advantage of doing a formatted READ iS that character variables do not

need single quotes around them to be read in properly.

There are no rules governing the location of FORMAT statements in programs except that they must

be in the same local or sub program unit that refers to them. So any format statements used by the

main program must appear in the main program and any format statements used by a subroutine or

function must appear within that subroutine or function. Format statements can be placed directly

after PRINT and READ statements but some programmers prefer to keep them together near the

end of a program.

File Handling

So far the programs written have taken input data from the keyboard and the results have been

displayed on the computer screen. Data is often input from a file, acted on by a FORTRAN program

and output to a file. This is advantageous when the amount of data is large and may be manipulated

several times or when the results need to be kept for further calculations.

The statements for input and output must include details of how and where to input data from and

output to. READ * may be expanded to include these controls, however WRITE iS used for output

rather than PRINT. Example Program 5 exemplifies common ways of dealing with files: opening,

closing, reading from and writing to.

Input/output Statements

READ (control list) variable list

WRITE (control list) variable list

Where the control list items can be a number of the following and are described later on:

UNIT = unit identifier

FMT = format identifier

END = label ERR = label

Example:

READ (UNIT = 1, FMT = 10) A, B, C

READ (1, 10) A, B, C

WRITE (UNIT = 2, FMT = 20) X, Y, Z

WRITE (2, 20) X, Y, Z


32/38

Unit identifier

Every control list must contain a unit identifier. It is this that identifies the location of the file or

device to be accessed. If the unit identifier is first in the control list the UNIT = may be omitted. For

example:

WRITE (2, FMT=20) X, Y, Z

You may choose any number for a unit identifier except for two reserved values that generally have

predefined meanings. The number 5 represents keyboard input and 6 represents screen output. So

READ(5,*) A,B,C is another way of writing READ*, A,B,C. Likewise, WRITE(6,*) A,B,C is another way of

writing PRINT*, A,B,C.

Format identifier

This identifies how the data is organised either by reference to a FORMAT statement or an asterisk

indicating list-directed format.

Example:

READ (UNIT=l, FMT = 10) A, B, C the FORMAT statement it is at label 10

READ (UNIT=1, FMT = *) A, B, C Asterisk (*) means list-directed formatting. In other words, no

formatting

If the format identifier is second in the control list the FMT = may be omitted.

Example:

READ (1, 10) A, B, C The more usual concise form.

End-of-file condition

Only one end-of-file condition may appear in the control list. When the READ statement reaches the

end of the data file without an error occurring, no more data is transferred and the control of the

program jumps to the label specified in the READ statement. In the example below, a GO TO

statement is used to continue reading from the file until the file is completely read. GO TO

statements can be dangerous because they tend to create jumps in control which are hard to follow.

It is wise to keep use of GO TO statements to a minimum.

Example:

80 READ(l,*,END=99)A,B,C

c do something with A, B, and C

GO TO 80

99 PRINT *, ALL DATA READ'


33/38

Error condition

If some error occurs on input/output and there is an error specifier, the input/output is stopped and

the program jumps to the label given in the error specifier.

Example

READ(l,*,ERR=100,END=200)A,B,C

100 PRINT *, ERROR ON READING, STOPPING PROGRAM RUN'

STOP

c or else continue with the rest of the program

200 CONTINUE

END

A common cause of error in file reading is running out of numbers in the file before the compiler has

filled up the requested variables. For example, say that the file accessed by the READ statement

above, looked like this:

12, 13, 14

15

16

17

18 19 20 21

22 23

When the file is initially opened, a pointer is placed at the top of the file. As the file is read, the

pointer moves through the file, keeping track of what line has been read and what line has not. The

pointer will move for two reasons: l) after a line has been looked at or 2) if the compiler needs more

values.

So after the first read statement, the pointer gets positioned on the line with 15 in it because it was

told to look for three values to fill A, B and c and it found all it needed on the first line. The pointer

moved on because the line had been examined.

The second time the READ statement is executed; the pointer is on the line with 18 in it. Again, the

compiler was told to look for three values, but they were not on the same line so the pointer moved

on to find enough values. When it found all the values it needed the pointer got positioned on the

next fresh line, in this case the one beginning with 18.

The third time the READ statement is executed; the pointer is left on the line beginning with 22. The

compiler found the three values it needed on a single line, did not need the fourth value, 21, butmoved on anyway.


34/38

During the fourth time the READ statement is executed, the program will have an error. The

compiler was told to look for three values in the file. It only found two before it got to the end of the

file. So 22 is put into A and 23 is put into B but c does not get a value and the control of the program

jumps to line 10 o because that is where it was told to go if there were problems. , Implied DO loops

describe a method of reading all the data.

If later on in the program you want to move the pointer back to the top of the file, the REWIND

statement can be used. Example REWIND (UNIT=1)

Opening and Closing Files

The OPEN statement

The OPEN statement connects the file and defines the specifications

according to the file specifications list.

OPEN(UNIT = number, filespec list)

where the file specifications list can be some of the following:

ERR = label

FILE = character, therefore enclosed in quotes

STATUS = character, therefore enclosed in quotes

There are more file specifications which can be looked up in one of the

recommended texts.

ERR - If an error condition occurs while the file is being opened, the program jumps to the label.

FILE - This specifies the name of the file to be opened. The filename is considered a character entity

so it must be enclosed in quotes.

STATUS - This is also a character entity which must be enclosed in quotes

OLD the file to be opened already exists.

NEW the named file must not already exist. A file is created and opened.

UNKNOWN The file may or may not exist.

The CLOSE statement:

The CLOSE statement disconnects a file:

CLOSE([UNIT=] number)


35/38

Glossary of FORTRAN 77 Statements

STATEMENT Description Example of Usage

Arithmetic IFTransfers control, depending on whether value of an

arithmetic expression is negative, zero, or positiveIF (X-Y) 30, 40 , 50

ASSIGN Assigns a statement number to a variable ASSIGN 50 TO N

Assigned GO TOTransfers control to a statement specified by a variable; in

conjunction with ASSIGN statementGO TO N

Assignment Assigns a value to a variable

PI = 3.1416

NUMBER = 0

MAJOR = ' CPSC '

Z FLAG =. TRUE.

BACKSPACE Backspace a file BACKSPACE 12

BLOCK DATA

Heading of a block data subprogram used to initialize variables

in named common blocks

INTEGER MONTH, YEAR

COMMON / INFO / MONTH, YEAR

DATA MONTH, YEAR /12, 1995/

END

BLOCK IF

Executes or bypasses a block of statements, depending on

truth or falsity of a logical expression; must be paired with

END IF and may have ELSE or ELSE IF blocks

IF (X.GT. O) THEN

RESULT = SQRT(X)

ELSE

IF (X .EQ. 0) THEN

PRINT *, 'NUMBER IS 0'

ELSE

PRINT *, 'NEGATIVE NUMBER'END IF

CALL Calls a subroutine CALL CONVER (A, T, X, Y)

CHARACTER Specifies character typeCHARACTER*10 NAME, INIT*1,

LIST(20)

CLOSE Closes a file CLOSE (12)


36/38

COMMON Establishes blank or named common areas

COMMON ALPHA, BETA, MAT

(5,5)

COMMON / INFO / MONTH, YEAR

COMPLEX Specifies complex type COMPLEX Z, W, MAT (5,5)

Computed GO TOTransfers control to one of several statements, depending on

the value of an integer expressionGO TO (10, 20, 30, 40) CLASS

CONTINUE Used to close a DO-loop 5 CONTINUE

DATA Initializes variables at compile time DATA PI, (X(I),I=1,5) /3.14,5*0/

DIMENSION Declares dimensions of arrays DIMENSION MAT(5,5), LIST(20)

DO First statement of a DO-loop DO 5 I=1, N

DOUBLE PRECISION Specifies double precision typeDOUBLE PRECISION A, B,

ROOTS(20)

ELSE Defines ELSE-block in a block IF statement See block IF statement

ELSE IFDefines ELSE-IF block within a block IF used for multi

alternative selectionSee block IF statement

END Last statement of each program unit END

END IF Last statement of a block IF See block IF statement

ENDFILE Places end-of-file record in a file ENDFILE 12

END WHILE, END DO Terminates a WHILE loop; not in standard FORTRAN 77 See WHILE statement

ENTRY Specifies entry point in a subprogram ENTRY POLY (X)

EQUIVALENCEEstablishes sharing of memory locations by different variables

in same program unit

EQUIVALENCE(X,Y),

(ALPHA,A,T(3))

EXTERNALSpecifies externally defined subprograms that may be used as

argumentsEXTERNAL F, QUAD


37/38

FORMAT Defines a list of descriptors20 FORMAT (1X, 'ROOTS ARE',

2F8.3)

FUNCTION Heading for a function subprogram FUNCTION AVE(X, N)

GO TO Unconditionally transfers control to a specified statement GO TO 100

IMPLICIT Used to establish a naming conventionIMPLICIT REAL (L,N-Z), INTEGER

(A-K)

INQUIREDetermines properties of a file or of its connection to a unit

number

INQUIRE (EXIST = FLAG, NAME

=FNAME)

INTEGER Specifies integer type INTEGER X, CLASS, TABLE(10,20)

INTRINSIC Specifies intrinsic functions that may be used as arguments INTRINSIC SIN, DSQRT

LOGICAL Specifies logical type LOGICAL P, Q, TABLE(4,6)

Logical IFExecutes or bypasses a statement depending on the truth or

falsity of a logical expressionIF (DISC .GT. 0) DISC = SQRT(DISC)

OPEN Opens a fileOPEN(UNIT = 12, FILE = FNAME,

STATUS = 'OLD')

PARAMETER Defines parametersPARAMETER (LIM = 100, RATE

=1.5

PAUSE Interrupts program execution, program may be restartedPAUSE

PAUSE 'PROGRAM PAUSE'

PRINT Output statement

PRINT *, 'X = ', X

PRINT *

PRINT '(1X, 317)', M, N, M + N-e

PROGRAM Program heading PROGRAM WAGES

READ Input statement

READ *, ALPHA, BETA

READ '(15, F7.2)', NUM, Z

READ (12, *, END = 20) HOURS,

RATE


38/38

REAL Specifies real type REAL NUM, GAMMA, MAT(10,10)

RETURN Returns control from subprogram to calling program unitRETURN

RETURN 2

REWIND Positions file at initial point REWIND 12

SAVESaves values of local variables in a subprogram for later

references

SAVE X, Y, NUM

SAVE

Statement function Function defined within a program unit by a single statement F(X,Y) = X**2 + Y**2

STOP Terminates executionSTOP

STOP 'PROGRAM HALTS'

SUBROUTINE Heading for subroutine subprogramSUBROUTINE CONVER (U, V, RHO,

PHI)

WRITE Output statementWRITE (*,*) A, B, C

WRITE (12,'(1X, 316)') N1, N2, N3

programming in fortran

Documents