# Ran2 fortran 90 wo

## 1 SelfStudyF95

Department of Physics

Computational Physics

Self-study guide 2

Programming in Fortran 95

Dr. Rachael Padman

Michaelmas 2007

Contents

1. THE BASICS 3

1.1 A very simple program 3

1.2 Running the program 4

1.3 Variables and expressions 5

1.4 Other variable types: integer, complex and character 8

1.5 Intrinsic functions 11

1.6 Logical controls 13

1.7 Advanced use of if and logical comparisons 15

1.8 Repeating ourselves with loops: do 16

1.9 The stop statement 17

1.10 arrays 17

1.11 Array arithmetic 19

2 GOOD PROGRAMMING STYLE 21

2.1 Readability 21

2.2 Self-checking code 22

2.3 Write clear code that relates to the physics 22

3. INPUT TO AND OUTPUT FROM A F95 PROGRAM 24

3.1 F95 statements for I / O 24

4 GRAPHICS AND VISUALIZATION 27

4.1 Plotting a data file 27

4.2 Getting help 28

4.3 Further examples 28

4.4 Printing graphs into PostScript files 29

SUGGESTED EXERCISE 1 30

5. PROGRAM ORGANIZATION: FUNCTIONS AND SUBROUTINES 31

5.1 Functions 31

5.2 Formal definition 33

5.3 Subroutines 34

5.4 Local and global variables 34

5.5 Passing arrays to subroutines and functions 35

5.5.1 Size and shape of array known 35

5.5.2 Arrays of unknown shape and size 35

5.6 The intent and save attributes 36

6. USING MODULES 38

6.1 Modules 38

6.2 public and private attributes 41

7 NUMERICAL PRECISION AND MORE ABOUT VARIABLES 42

7.1 Entering numerical values 42

7.2 Numerical Accuracy 42

1

8 USE OF NUMERICAL LIBRARIES: NAG 44

8.1 A simple NAG example 44

8.2 A non-trivial NAG example: matrix determinant 44

9 SOME MORE TOPICS 47

9.1 The case statement and more about if 47

9.2 Other forms of do loops 48

SUGGESTED EXERCISE 2 49

Acknowledgments:

This handout was originally prepared by Dr. Paul Alexander, and has been updated

and maintained by Dr Peter Haynes of the TCM group.

2

1. The basics

In this section we will look at the basics of what a program is and how to make the

program run or execute.

The non-trivial example programs can be found in the directory:

$ PHYTEACH / par t _2 / exampl es

with the name of the file the same as that of the program discussed in this guide.

Some sections are more advanced and are clearly indicated by a thick black

line to the right of the text. These can be skipped certainly on a first reading and

Indeed you will be able to tackle the problems without using the material they discuss.

1.1 A very simple program

A program is a set of instructions for the computer to perform a series of operations.

Those operations will often be mathematical calculations, decisions based on

equalities and inequalities, or special instructions to say write output to the screen.

The program consists of source code which is stored in a text file. This code

contains the instructions in a highly structured form. Each computer language has a

different set of rules (or syntax) for specifying these operations. Here we will only

consider the Fortran 90/95 (F95 for short) programming language and syntax.

Using emacs enter the following text into a file called ex1. f 90, the. f 90 part

of the file name is the extension indicating that this is program source code written

in the Fortran 90/95 language

pr ogr amex1

!

! My f i r st pr ogr am

!

wr i t e (*, *) Hel l o t her e

end pr ogr amex1

This is a complete F95 program.

The first and last lines introduce the start of the program and show where it ends.

Between the first and last lines are the program statements. The lines beginning

with an exclamation mark are special statements called comments. They are not

Instructions to the computer, but instead are there to enable us (the programmer) to

improve the readability of the program and help explain what the program is doing.

The line beginning wr i t e is a statement giving a specific instruction to print to the

screen.

3

Note that except within quotes:

Upper and lower case are NOT significant

(different from Unix commands and files)

Blank lines and spaces are not significant.

1.2 Running the program

Before we can run the program we must get the computer to convert this symbolic

language (F95) into instructions it can understand directly. This process is called

compilation. At the same time the computer will check our program source for

errors in the syntax, but not for errors in our logic! In general programs, be

assembled from source in many files; bringing all of these instructions together is

called linking. We perform both of these tasks using the Unix command f 95.

Type the following, the - o is an option saying where to place the output which in

This case is a program which is ready to run, we call this an executable. (The

default executable name is a. out).

f 95 - o ex1 ex1. f 90

If you haven't made any typing errors there should be no output to the screen

from this command, but the file ex1 should have been created. By

convention executable programs under Unix do not normally have a file

extension (i.e. no. xxx in the file name).

To run the program type:

. / ex1

Most Unix commands are files which are executed. The shell has a list of

directories to search for such files, but for security reasons this list does not

contain the current directory. The. / (dot slash) before ex1 tells the shell

explicitly to look in the current directory for this file.

The output should be the words Hel lo t her e.

What happens if you make an error in the program? To see this lets make a

deliberate error. Modify the line beginning wr i t e to read:

wr i t e (*, *) Hel l o t her e OK

Save the file, and compile again:

f 95 - o ex1 ex1. f 90

This time you get errors indicating that the syntax was wrong; i.e. you have

not followed the rules of the F95 language! Correct the error by changing the

source back to the original, recompile and make sure the program is working

again.

4

1.3 Variables and expressions

The most important concept in a program is the concept of a variable. Variables in a

program are much like variables in an algebraic expression, we can use them to hold

values and write mathematical expressions using them. As we will see later F95

allows us to have variables of different types, but for now we will consider only

variables of type real. Variables should be declared before they are used at the start

of the program. Let us use another example to illustrate the use of variables.

Enter the following program and save it to the file ex2. f 90

pr ogr amver t i cal

!

! Ver t i cal mot i on under gr avi t y

!

real:: g! accel er at i on due t o gr avi t y

real:: s! di spl acement

real:: t! t i me

r eal:: u! i ni t i al speed (m / s)

! set values of var i abl es

g = 9. 8

t = 6. 0

u = 60

! cal cul at e di spl acement

s = u * t - g * (t ** 2) / 2

! out put r esul t s

wr i t e (*, *) Ti me =, t, Di spl acement =, s

end pr ogr amver t i cal

Compile and run the program and check the output is what you expect

f 95 - o ex2 ex2. f 90

. / ex2

This program uses four variables and has many more statements than our first

example. The variables are declared at the start of the program before any

executable statements by the four lines:

real:: g! accel er at i on due t o gr avi t y

real:: s! di spl acement

real:: t! t i me

r eal:: u! i ni t i al speed (m / s)

After the declarations come the executable statements. Each statement is acted upon

sequentially by the computer. Note how values are assigned to three of the variables

and then an expression is used to calculate a value for the fourth (s).

5

Unlike in an algebraic expression, it would be an error if, when the statement

calculating the displacement was reached, the variables g, t and u had not already

been assigned values.

Some other things to note:

1. Comments are used after the declarations of the variables to explain what each

variable represents.

2. The * represents multiplication

3. The ** is the operator meaning raise to the power of, it is called technically

exponentiation.

4. In this program we have used single letters to represent variables. You may (and

should if it helps you to understand the program) use longer names. The variable

names should start with a character (A-Z) and may contain any character (A-Z),

digit (0-9), or the underscore (_) character.

5. Upper and lower case are not distinguished. For example therefore the variable T

and t, and the program names ver t i cal and Ver t i cal are identical.

The usefulness of variables is that we can change their value as the program runs.

All the standard operators are available in expressions. An important question is if we

have the expression

g * t ** 2

what gets evaluated first? Is it g * t raised to the power of 2 or t raised to the power

2 then multiplied by g? This is resolved by assigning to each operator a precedence;

the highest precedence operations are evaluated first and so on. A full table of

numeric operators is (in decreasing precedence)

Operator Precedence Meaning

** 1 raise to the power of

* 2 multiplication

/ 2 division

+ 3 addition or unary plus

- 3 Subtraction or unary minus

You can change the precedence by using brackets; sub-expressions within brackets

are evaluated first.

Let's look at ways of improving this program. An important idea behind writing a

good program is to do it in such a way so as to avoid errors that you may introduce

yourself! Programming languages have ways of helping you not make mistakes. So

lets identify some possible problems.

The acceleration due to gravity is a constant, not a variable. We do not wish its

value to change.

6

We want to avoid using a variable which is not given a value; this could happen if

we mistyped the name of a variable in one of the expressions.

Consider the following modified form of our program:

pr ogr amver t i cal

!

! Ver t i cal mot i on under gr avi t y

!

i mpl i ci t none

! accel er at i on due t o gr avi t y

r eal, par amet er:: g = 9. 8

! var i abl it

real:: s! di spl acement

real:: t! t i me

r eal:: u! i ni t i al speed (m / s)

! set values of var i abl es

t = 6. 0

u = 60

! cal cul at e di spl acement

s = u * t - g * (t ** 2) / 2

! out put r esul t s

wr i t e (*, *) Ti me =, t, Di spl acement =, s

end pr ogr amver t i cal

We have changed three lines and some of the comments. The line:

i mpl i ci t none

is an important statement which says that all variables must be defined before use.

You should always include this line in all programs.

1

The second change is to the line:

r eal, par amet er:: g = 9. 8

This in fact defines g to be a constant equal to the value 9.8; an attempt to reassign g

via a statement like the one in the original version (g = 9. 8 on a line by itself) will

now lead to an error. The syntax of this statement is as follows:

After the definition of the variable type real we give a series of options

separated by commas up until the:: after which we give the variable name with

an optional assignment.

1

It is an unfortunate legacy of older versions of Fortran that you could use variables without defining

them, and in that case Fortran supplied rules to determine what the variable type was.

7

We will meet more options later.

Try out these new ideas:

Make these changes and make sure the program compiles.

Now make some deliberate errors and see what happens. Firstly add back in the

line g = 9. 8 but retain the line containing the par amet er statement.

Compile and observe the error message.

Now change one of the variables in the expression calculating s, say change u

to v. Try compiling again.

Fix the program.

1.4 Other variable types: integer, complex and character

As we have hinted at, there are other sorts of variables as well as real variables.

Important other types are i nt eger, compl ex and char act er.

Lets first consider i nt eger variables; Such variables can only hold integer values.

This is important (and very useful) when we perform calculations. It is also worth

pointing out now that F95 also distinguishes the type of values you include in your

program. For example a values of 3.0 is a real value, whereas a value of 3

without the. 0 is an other value. Some examples will illustrate this.

Enter the following program:

pr ogr amar i t hmet i c

i mpl i ci t none

! Def i ne r eal and i nt eger var i abl es

r eal:: d, r, r r es

i nt eger:: i, j, i r es

! Assi gn some values

d = 2.0; r = 3. 0

i = 2; j = 3

! Now t he exampl it

r r es = r / d

! Pri nt t he r esul t, bot h t ext and a value.

! Not e how t he t ext and value ar e separ at ed by

! a comma

wr i t e (*, *) r r es = r / d:, r r es

! now some mor e exampl it

i r es = j / i; wr i t e (*, *) i r es = j / i:, i r es

i r es = r / i; wr i t e (*, *) i r es = r / i:, i r es

r r es = r / i; wr i t e (*, *) r r es = r / i:, r r es

end pr ogr amar i t hmet i c

8

First some things to note about the program:

1. We can declare more than one variable of the same type at a time by

separating the variable names with commas:

r eal:: d, r, r r es

2. We can place more than one statement on a line if we separate them with a

semicolon:

d = 2.0; r = 3. 0

Compile and run the program. Note the different output. The rule is that for

integer division the result is truncated towards zero. Note that the same rules

apply to expressions containing a constant. Hence:

i r es = 10. 0/3! value of i r es i s 3

r r es = 10/3! value of r r es i s 3. 0

r r es = 10. 0 / 3. 0! value of r r es i s 3. 333333

Make sure you are happy with these rules; Alter the program and try other types of

expression.

Some expressions look a little odd at first. Consider the following expression:

n = n + 1

where n is an integer. The equivalent algebraic expression is meaningless, but in a

program this is a perfectly sensitive expression. We should interpret as:

Evaluate the right hand side of the expression and set the variable on the left hand

side to the value evaluated for the right hand side.

The effect of the above expression is therefore to increment the value of n by 1st note

the role played by the = sign here: it should be thought of not as an equality but

instead as an assignment.

The compl ex type represents complex numbers. You can do all the basic numerical

expressions discussed above with complex numbers and mix compl ex and other

data types in the same expression. The following program illustrates their use.

Enter the program, compile and run it. Make sure you understand the output.

pr ogr amcompl ex1

i mpl i ci t none

! Def i ne var i abl es and const ant s

compl ex, par amet er:: i = (0, 1)! sqr t (- 1)

compl ex:: x, y

x = (1, 1); y = (1, - 1)

wr i t e (*, *) i * x * y

end pr ogr amcompl ex1

9

The char act er data type is used to store strings of characters. To hold a string of

characters we need to know how many characters in the string. The form of the

definition of char act er s is as follows:

char act er (l en = 10):: wor d

! wor d can hol d 10 char act er s

We will meet character variables again later.

Rules for evaluating expressions

The type of the result of evaluating an expression depends on the types of the

variables. If an expression of the form a operator b is evaluated, where operator is

one of the arithmetic operations above (+, -, *, /, **) the type of the result is

given as follows with the obvious symmetric completion:

Type of a Type of b Type of result

i nt e nt e nt e nt e nt eger

i nt eger r eal r eal

i nt eger compl ex compl ex

r eal r eal r eal

r eal compl ex compl ex

compl ex compl ex compl ex

N.B. The result of evaluating an i nt eger expression is an i nt eger, truncating as

necessary. It is worth emphasizing this again, although we met it above, since a very

common error is to write 1/2 for example, which evaluates by the above rules to

zero. This can lead to non-obvious errors if hidden in the middle of a calculation.

When a complex value is raised to a complex power, the principal value (argument in

the range -,) is taken.

Assignments take the form variable = expression, where variable has been declared

and therefore has a type. If the type of the two do not agree, the following table

determines the result

Variable Expression Value assigned

i nt eger real truncated value

i nt eger compl ex truncated real part

r eal i nt eger convert to real

r eal compl ex real part

compl ex i nt eger real part assigned value, imaginary part zero

compl ex r eal real part assigned value, imaginary part zero

10

1.5 Intrinsic functions

So far we have seen how to perform simple arithmetic expressions on variables. real

problems will involve more complicated mathematical expressions. As we shall see

later, F95 enables you to define your own functions which return values. However,

Some functions are so common and important that they are provided for us as part of

the language; these are called intrinsic functions.

Let us consider a program to compute projectile motion. The program computes the

horizontal, x, and vertical, y, position of the projectile after a time, t:

x = u t cos a y = u t sin a - g t

2

/ 2

pr ogr ampr oj ect i l e

i mpl i ci t none

! def i ne const ant s

r eal, par amet er:: g = 9. 8

r eal, par amet er:: pi = 3. 1415927

r eal:: a, t, u, x, y

r eal:: t het a, v, vx, vy

! Read values for a, t, and u f r omt er mi nal

read (*, *) a, t, u

! conver t angl e t o r adi ans

a = a * pi / 180.0

x = u * cos (a) * t

y = u * si n (a) * t 0. 5 * g * t * t

vx = u * cos (a)

vy = u * si n (a) - g * t

v = sqr t (vx * vx + vy * vy)

t het a = at an (vy / vx) * 180. 0 / pi

wr i t e (*, *) x:, x, y:, y

wr i t e (*, *) v:, v, t het a:, t het a

end pr ogr ampr oj ect i l e

Compile and run the program. It will wait. The statement read (*, *) is

requesting input from you. Enter three values for a, t and u. You should now get

some output.

Examine this program carefully and make sure you understand how it works.

Note especially how we use the functions cos, si n, at an and sqr t much as

you would use them in algebraic expressions. As always upper and lower case are

equivalent.

11

Common intrinsic functions

Name action

ABS (A) absolute value of any A

ACOS (X) inverse cosine in the range (0,) in radians

AI MAG (Z) imaginary part of Z

AI NT (X [, KI ND]) truncates fractional part towards zero, returning real

ANI NT (X [, KI ND]) nearest integer, returning r eal

ASI N (X) inverse sine in the range (- / 2, / 2) in radians

ATAN (X) inverse tangent in the range (- / 2, / 2) in radians

ATAN2 (Y, X) inverse tangent of Y / X in the range (-,) in radians

CMPLX (X [, Y] [, KI ND] converts to compl ex X + iY; if Y is absent, 0 is used

CONJ G (Z) complex conjugate of Z

COS (W) cosine of argument in radians

COSH (X) hyperbolic cosine

EXP (W) exponential function

FLOOR (X) greatest i nt eger less than X

I NT (A [, KI ND]) converts to integer, truncating (real part) towards zero

KI ND (A) in its own function, returns the KI ND of the argument

LOG (W) natural logarithm: if Wis r eal it must be positive,

if Wis compl ex, imaginary part of result lies in (-,)

LOG10 (X) logarithm to base 10

MAX (R1, R2...) Maximum of arguments, all of the same type

MI N (R1, R2...) Minimum of arguments, all of the same type

MOD (R1, R2) remainder of R1 on division by R2, both arguments

being of the same type (R1- I NT (R1 / R2) * R2)

MODULO (R1, R2) R1 modulo R2: (R1- FLOOR (R1 / R2) * R2)

NI NT (X [, KI ND]) nearest i nt eger

REAL (A [, KI ND]) converts to real

SI GN (R1, R2) absolute value of R1 multiplied by the sign of R2

SI N (W) sine of argument in radians

SI NH (X) hyperbolic sine

SQRT (W) square root function; for complex argument the result

is in the right half-plane; a real argument must be

positive

TAN (X) tangent of argument in radians

TANH (X) hyperbolic tangent

F95 has a set of over a hundred intrinsic functions, those in the list above are the

most useful for scientific applications.

In this list A represents any type of numeric variable, R a r eal or i nt eger

variable, X and Y r eal variables, Z a compl ex variable, and Wa r eal or

compl ex variable.

Arguments in square brackets are optional. For an explanation of child see

section 7.

12

1.6 Logical controls

So far all the programming statements we have met will simply enable us to produce

efficient calculators. That is useful, but there is a lot more to programming. In this

and Section 1.8 we introduce two crucial ideas. The first is the idea of taking an

action conditional upon a certain criteria being met. An example will help to

introduce this idea. For many years it was the case in Part IA of the Tripos that your

maths mark was only included if it improved your overall result. Let us write a

program to perform that simple sum. We read in four marks and output a final

average.

pr ogr amt r i pos1

i mpl i ci t none

r eal:: p1, p2, p3, mat hs

real:: av1, av2

! r ead i n t the mar ks

read (*, *) p1, p2, p3, mat hs

! wor k out t wo aver ages

av1 = p1 + p2 + p3

av2 = av1 + mat hs

av1 = av1 / 3.0; av2 = av2 / 4.0

! use an i f st at ement

i f (av2> av1) t hen

wr i t e (*, *) Fi nal aver age =, av2

el se

wr i t e (*, *) Fi nal aver age =, av1

end i f

end pr ogr amt r i pos1

Compile and run this program and make sure you understand how it works.

Note how the statements are indented. We use indenting to help show the logical

structure of the program; indented statements are executed depending on the

output of the test done by the i f statement. The indenting is not essential, but it

leads to a program which is much easier to follow. If you choose this style you

can indent each level by any number of spaces as you wish.

The i f statement is the simplest, but most important, of a number of ways of

changing what happens in a program depending on what has gone before. It has the

general form:

i f (logical expression) action

As another example we can use it to check for negative values:

i f (x <0) x = 0! r epl ace negat i ve x wi t h zer o

13

The i f construct may also be used in more extended contexts (as above), such as:

i f (logical expression) t hen

xxx

el se

xxx

end i f

Here if the condition is false the statements following the el se are executed. We

can also include additional tests which are treated sequentially; the statements

following the first logical test to be reached which is true are executed:

i f (logical expression) t hen

xxx

el se i f (logical expression) t hen

xxx

el se

xxx

end i f

Operators which may occur in logical expression are as follows:

. l t. or

. eq. or == equal

. ge. or> = greater than or equal

. gt. or> greater than

. no. or / = not equal

. not. not

. and. and

. or. inclusive or

and of course, brackets. Using brackets and the. not. ,. and. and. or. forms we

can build up complicated logical expressions.

As an exercise consider the following. Suppose the rules for Part IA of the Tripos

were changed so that:

1. The full maths course is always counted in the average

2. Quantitative biology mark is only counted if it improves the average

3. Elementary maths for biology is never counted.

Modify the program t r i pos1 to compute the average mark. One further piece

of information is required which is an i nt eger code indicating the type of

maths paper taken. This integer code can be assumed to take the values:

Full maths 1

Quantitative biology 2

Elementary maths 3

One possible solution is available in the examples directory as t r i pos2. f 90

14

i f clauses may appear nested, that is one inside another. Suppose we wish to

compute the expression

() a d b x / =

which fails if d <0 or a is zero. If these were

entered by a user then they could (incorrectly) take on these values. A good program

should check this. Here is some code to do this which illustrates nested i f clauses

i f (a / = 0. 0) t hen

i f (d <0. 0) t hen

wr i t e (*, *) I nval i d i nput dat a d negat i ve

el se

x = b * sqr t (d) / a

end i f

el se

wr i t e (*, *) I nval i d i nput dat a a zer o

end i f

1.7 Advanced use of if and logical comparisons

In a large program it is likely that i f clauses will be nested, i.e. appear one within

another. This us no problems, but might make it less clear which end i f

goes with which i f. To overcome this we can name the i f clauses. An example

illustrates the syntax. Lets use the example we have just met:

out er: i f (a / = 0. 0) t hen

i nner: i f (d <0. 0) t hen

wr i t e (*, *) I nval i d i nput dat a d negat i ve

el se i nner

x = b * sqr t (d) / a

end i finner

el se out he

wr i t e (*, *) I nval i d i nput dat a a zer o

end i f out er

The names are out he and inner; note the syntax, especially the colon. Named i f

clauses are useful when you want to make your intention clear, but are not essential.

The logical expressions we have met in i f clauses can be used more generally with a

logical variable. Logical variables take on the value of. t r ue. or. f al se.. Here

is a simple example which illustrates their use.

l ogi cal:: l 1, l 2

l 1 = x> 0. 0

l 2 = y / = 1. 0

i f (l 1. and. l 2) t hen

This program fragment could equally well have been written

i f ((x> 0. 0). and. (y / = 1. 0)) t hen

Using logical variables may make some things easier to understand.

15

1.8 Repeating ourselves with loops: do

Loops are the second very important concept needed in a program. If a set of

Instructions needs to be repeated, a loop can be used to do this repetition. As we shall

see we have a lot of control over the loop and this makes them extremely powerful;

this is especially true when combined with the i f clauses we have just met.

The general form of the do loop is:

do var = start, stop [, step]

xxx

end do

where as before the parts in square brackets are optional.

var is another variable

start is the initial value var is given

stop is the final value

step is the increment by which var is changed. If it is omitted, unity is

assumed

The loop works by setting var to start. If var stop the statements up to the end do

are executed. Then var is incremented by step. The process then repeats testing var

against stop each time around the loop.

It is possible for the included statements never to be executed, for instance if

start> stop and step is 1.

This program is an example which computes factorials:

pr ogr amf act or i al

i mpl i ci t none

! def i ne var i abl es, some wi t h i ni t i al values

in t eger:: nf act = 1

i nt eger:: n

! comput e f act or i al s

do n = 1, 10

nf act = nf act * n

wr i t e (*, *) n, nf act

end do

end pr ogr amf act or i al

Modify the fact or i al program as follows. Change 10 to 100 and insert the

following line before the end do.

i f (n> 10) exi t

What output do you get? Why? The exit command terminates the loop.

Write a program to calculate the binomial coefficient

n

C.

r

. The program should

read in values from the user for n and r and write out the answer.

16

1.9 The stop statement

We have just seen how the exi t command can be used to terminate a do loop. If

you wish execution of your program to cease, you can insert a st op statement; this

can incorporate some text, which is output when your program halts and identifies

where this happened, e.g.

st op t hi s i s wher e i t al l ends up

1.10 arrays

A great deal of scientific computation involves the manipulation of vectors, matrices

and more general arrays of numbers. In F95 we can have an array of variables set up

in the declarations statements.

How do we specify arrays? The simplest way is to give the dimension in parentheses.

real:: a (3)! a i s an ar r ay of 3 values: a vect or

real:: m (3, 3)! mi s a r ank 2 ar r ay: a mat r i x

We call the part in parentheses a shape. Each element of the array can be addressed

in the program using a similar notation. Here is a simple example:

pr ogr amvect or

i mpl i ci t none

real:: v (3)

real:: x

i nt eger:: i

v (1) = 0.25

v (2) = 1. 2

v (3) = 0.2

! comput e t he module us squar ed of t he vect or

x = 0. 0

do i = 1, 3

x = x + v (i) * v (i)

end do

wr i t e (*, *) module us squar ed =, x

end pr ogr amvect or

Notice how we use a loop to compute the sum over all elements of the vector.

A second example will show us how we can implement simple vector and matrix

operations:

17

pr ogr aml i nal g

i mpl i ci t none

r eal:: v1 (3), v2 (3), m (3, 3)

i nt eger:: i, j

v1 (1) = 0.25

v1 (2) = 1. 2

v1 (3) = 0.2

! use nest ed do l oops t o i ni t i al i se t he mat r i x

! t o t he uni t mat r i x

do i = 1, 3

do j = 1, 3

m (j, i) = 0. 0

end do

m (i, i) = 1. 0

end do

! do a mat r i x mul t i pl i cat i on of a vect or

! equi val ent t o v2

i

= m

i j

v1

j

do i = 1, 3

v2 (i) = 0. 0

do j = 1, 3

v2 (i) = v2 (i) + m (i, j) * v1 (j)

end do

end do

wr i t e (*, *) v2 =, v2

end pr ogr aml i nal g

Enter this program, compile and run it. Make sure you understand the output.

Try modifying the program to multiply two matrices.

We can also have arrays of i nt eger, compl ex or any other data types declared in

analogous ways.

Arrays may be declared using other forms than those given above which can be useful

for different situations. The di mensi on option to the declaration may be used to set

a shape for all declared variables which do not have a particular shape specified for

them. The di mensi on statement serves several purposes in a F95 declaration. In

the following, note the critical nature of the punctuation, particularly,,: and

: : .

An example of the simplest form of an array declaration for a matrix might be:

r eal, di mensi on (10, 11):: a! a i s a r ank 2 ar r ay

18

The array subscripts are assumed to start at unity, but this can be altered by using the

explicit form of the declaration in which the range of the array subscripts is given

separated by a colon:

r eal, di mensi on (0: 9):: a! vector or of 10 elements s

! start at 0

We can also declare a variable to be an array of unknown size. We do this as follows

r eal, di mensi on (:), al locat abl e:: a

and at an appropriate time, when it is known how big this array needs to be, we use

the following (say to create an array of 10 elements):

m = 10

al locat e (a (m))

where mis an i nt eger variable. When the use of the array in the program is

finished, the space can be released by using

deal locat e (a)

1.11 Array arithmetic

One very useful feature of F95 is the ability to work with whole arrays. In must

programming languages one can, say, add two arrays using a loop. For example

r eal:: a (10), b (10), c (10)

i nt eger:: i

[some statements to setup the arrays]

do i = 1, 10

c (i) = a (i) + b (i)

end do

F95 allows you to perform whole array operations in a natural way. Most of the

normal arithmetic operations can be carried out on arrays, where they apply in an

element by element fashion. The above example can be written as:

r eal:: a (10), b (10), c (10)

[some statements to setup the arrays]

c = a + b

19

Here are some more examples which illustrate array arithmetic:

r eal, di mensi on (3, 3):: a, b

r eal, di mensi on (3):: x, y, z

i nt eger, di mensi on (10):: i dx

idx = 1! set all elements of idx to 1

a = b! copi es t he ar r ay b i nt o a

x = y + 1! x (i) = y (i) +1 f or i = 1, 2, 3

z = at an2 (y, x)! z (i) = at an2 (y (i), x (i)) f or i = 1, 2, 3

You can refer to a subset of an array and treat it as another array:

z ((/ 1, 3, 6 /)) a length 3 array with elements set toz (1), z (3), z (6)

z (m: n) is an array of length (n- m + 1) formed from the elements of z

starting at mand ending at n

z (m: n: c) is an array of length (n- m + 1) / c formed from the elements of

z starting at mand ending at n incremented by c

x (1: 5) = y (2: 6) copies elements 2 to 6 of y into elements 1 to 5 of x

z (1: 3) = y (1: 5: 2) copies elements 1,3,5 of y into elements 1,2,3 of z

a (2, :) = z copies the vector z into the second row of a

There is a conditional, wher e, which operates on an array for simple function

forms e.g. to replace negative elements of an array z with their absolute values:

wher e (z <0. 0) z = - z

More generally it has the form:

wher e (logical array test)

[statements if test true]

el sewher e

[statements if test false]

end wher e

For example to take the logarithm of the positive elements of an array:

r eal, di mensi on (1000):: a

wher e (a> 0. 0)

a = l og (a)

el sewher e

a = 0. 0

end wher e

There are a number of intrinsic procedures taking array arguments e.g.

dot _product takes 2 arguments of rank 1 and the same size

and returns their inner product

mat mul performs matrix multiplication on 2

array arguments with compatible size and rank

maxval returns maximum element of an integer or real array

mi nval returns minimum element of an integer or real array

product returns the product of the elements of an array

sum returns the sum of the elements of an array

20

2 Good programming style

In section 1 we have covered some of the basics of programming. We will return to

programming later when we look in even more detail at F95.

In this section we will briefly consider some rules for good practice in developing

programs. When you come to tackle the computing exercise we will be looking for

how you have tackled some of the issues we shall now discuss.

2.1 Readability

Your program should be as easy to follow in terms of its logical structure as possible.

There are a number of ways we have already met that help us do this. Let us recap

some of them.

First use comments. A general rule for comments is that you should use a comment

when the F95 statements you write are not self explanatory. There is no need for

example, to add comments to obvious computational expressions. However you may

want to add comments to the top of a block of expressions explaining how the

following code relates to the physical problem.

Similarly, if you have a loop, a comment of the form below is of no help:

! l oop f r om1 t o 10

do i = 1, 10

But a comment of the following form, say in a program calculating a binomial

might be very useful:

! l oop t o cal cul at e nCr

do k = 1, r

So use comments sensibly to make the code understandable.

What we dont want to hear is:

I have written my program, now I just need to comment it before handing it in

This is bad practice because comments are part of the program and should be there

as much to help you follow your own intentions in programming as for the head of

class to follow it.

Another aspect of readability is indenting code blocks between do loops and in

i f clauses. This is very good practice. It uses the layout of the program to show

at a glance the logical structure. Our strong advice is to make good use of

indenting. Again it helps as much in program development as it does in

presenting the final program.

21

2.2 Self-checking code

We have already seen in some of the examples how we can use checks to avoid

numerical errors. There are a number of numerical operations which are poorly

defined. These include, among many others:

a) division by zero

b) taking the square root or logarithm of a negative real number

Alternatively we may know the range of possible allowed values for a variable and

can include checks to make sure this is not violated.

Sometimes we can be sure that variables cannot take on illegal values, other times we

cannot. For example values may be supplied to the program by a user and the values

may be wrong. Alternatively we may know that under certain conditions a variable

may, for example, become negative and all this really means is that it should be set

equal to zero; in fact the formula we are computing may explicitly state something

Like:

>

=

otherwise 0

0 ... x

z

.

In either case you must be careful to check arguments to make sure they are in

range. We have seen examples of this already and you should go back now and

revise these methods.

Once again it is essential in program design to be sensitive. Do not check a variable if

it cannot be out of range; this just slows your code down. For example the following

would be bad programming style:

real:: x

[some statements]

x = si n (y) + 1. 0

i f (x> = 0. 0) z = sqr t (x)

Here x can never be less than zero; the test is not wrong, but clearly unnecessary and

indicates a poor appreciation of the logic of the program.

2.3 Write clear code that relates to the physics

We are not aiming in this course to develop ultra-efficient programs or the shortest

possible program etc. Our aim is for you to learn the basics of computational physics.

Therefore you should aim to write your code so that it relates as clearly as possible to

the physics and computational physics algorithms you are using as possible. You can

split long expressions over many lines, for example, by using the continuation marker.

22

If the last character of a line is an ampersand &, then it is as if the next line was

joined onto the current one (with the & removed). Use this to lay out long

expressions as clearly as possible.

Another technique is to split long expressions using intermediate calculations. A.

- How to import a DSX file into Datastage
- Where's my monkey Parker lyrics
- How big is six feet eight inches
- How to check the account limits of skrill
- Where did Andre Segovia live
- WhatsApp Para Tablet Acer 10
- Road glide radio switches off with headlights
- Who owns the best conversation partner from dawg
- How do crane brakes work
- Big Nango Inexplicable Remix Descargar WhatsApp
- Ben newhouse naomi sabel
- Resetting the properties of the Epson printer l110
- How to make cyber newspaper archives
- How To Draw Yin Yang Woelfe Pictures
- What does end of month mean s c
- How to remove silicone lubricant from the skin
- Mutant genetic gladiators how to get designers
- Khivraj Motors Bangalore Yeshwanthpur Howrah
- Maas ubuntu how to
- How to be a bush pilot
- Looped Whatsapp Echters Garten
- Pizzeria mario miechowice menu
- Who built Chateau de Reduit
- How big is a magnum wine bottle