AN INTRODUCTION TO FORTRAN 90 LECTURE 2. Consider the following system of linear equations: a x + a x + a x = b

Size: px

Start display at page:

Download "AN INTRODUCTION TO FORTRAN 90 LECTURE 2. Consider the following system of linear equations: a x + a x + a x = b"

Ashlynn Dorsey
5 years ago
Views:

1 AN INTRODUCTION TO FORTRAN 90 LECTURE 2 1. Fortran 90. Arrays, functions and subroutines. 2. Scientific plotting. Gnuplot 1 Each coefficient and variable is a scalar. Lengthy and cumbersome! Program Scalar Implicit None real a11,a12,a13,b1 real a21,a22,a23,b2 real a31,a32,a33,b3 real x1,x2,x3 Execution part Arrays. Introduction Consider the following system of linear equations: a x + a x + a x = b a x + a x + a x = b a x + a x + a x = b Coefficients and variables defined as matrices and vectors. Short and clear! Program Array Implicit None real, dimension(1:3,1:3) :: A real, dimension(1:3) :: B real, dimension(1:3) :: X Execution part Rank-two array A has nine components: A(1,1) A(1,2) A(1,3) A(2,1) A(2,2) A(3,2) A(3,1) A(3,2) A(3,3) Rank-one array B has three components: B(1) B(2) B(3) In Fortran 90 all elements of an array are of the same type and have the same name. They are distinguished by array indices, which are consecutive integers. Commas separate the array dimensions, colons define the array extent. 2

2 Arrays. General information The first array element is 1, i.e. A(15) A(1) to A(15). Array sizes must be specified by INTEGER constants. The maximum number of dimensions (rank) is 7, i.e. B(4,5,3,6,8,5,10) The shape function returns the number of elements in each dimension. Try PRINT *, SHAPE(B). Empty for a scalar. more useful definition of arrays integer, parameter :: N=1, M=10, P=20 real, dimension(n:m) :: A real, dimension(m:p,n:p) :: B! Declares the extent of the array Integer constants N, M and P define the extent of the array along each dimension. Assigning values to arrays real, dimension(5), parameter :: B=/1.,-3.,-4., 3.,-3.5/ integer, dimension(5,10) :: A integer i,j do j=1,10 do i=1,5 A(i,j)=i+j do do! Assigns constant values to array B The reverse order of the do loops would produce the so-called bad cache locality and significant worsening in the code performance! 3 Each array element is a variable just like any scalar variable. Array elements may be used anywhere in executable statements where a scalar variable of the same type would be used. = 3 Program Summation S X i real, dimension(3) :: X i= 1 real S Integer i S=0. Do i=1,3! The array index must not exceed S = S + X(i)! the array extent, i.e. 3 End do End Program Multiplication Real*8, dimension(1:3) :: A Real*8, dimension(1:2) :: B,C Integer i, j, k do i=1,3 do j=1,2 do k=1,3 C(i,j) = C(i,j) + A(i,k)*B(k,j) do do do C 3 ij = Aik Bkj k = 1 do i=1,n do j=1,n C(i,j)=DOT_PRODUCT(A(i,1:n),B(1:n,j)) do do Array operations in Fortran 90 S=sum(X)! returns the sum of array X A=maxval(X)! returns the maximum value of array X B=minval(X)! returns the minimum value of array X Indexed summation do i=1,n do j=1,n C(j,i) = A(j,i) + B(j,i) do do Matrix summation C = A + B operation on the rows, columns, or a sub-matrix of a matrix real*8, dimension(3,3) :: A real*8, dimension(2,2) :: B real*8, dimension(3) :: v(3) v(:) = A(:,1)! set v equal to the first column of A v(:) = A(1,:)! set v equal to the first row of A B(:,:) = A(1:2,1:2)! B is the upper 2x2 part of A 4

3 Input / output operations read( UNIT, FORMAT ) write( UNIT, FORMAT ) item1, item2, item1, item2, The UNIT is a number which has an association with a particular device. The device can be the TERMINAL or a FILE. The UNIT is an INTEGER, generally between 1 and 99. Standard FORTRAN reserves two UNIT numbers for I/O to user. They are: UNIT = 5 for INPUT from the keyboard with the READ statement, i.e., read(5,*) x reads from the keyboard the value of x UNIT = 6 for OUTPUT to the screen with the WRITE statement, i.e., write(6,*) x writes the value of x to the terminal. The FORMAT identifier is used to control the appearance of the I/O statements and it generally has one of two forms 1) An asterisk (*) indicates free format. 2) A character string containing the format descriptors Program output real x real*8 y x=1.2 y=1.3d-2 write(6,*) x, y The general I/O statement (spaces added for clarity) Program output real x real*8 y x=1.2 y=1.3d-2 write(6, (2F10.3) ) x, y Program output real x real*8 y logical a x=1.2 y=1.3d-8 write(6, (2E10.3,L4) ) x, y, a D E E-7 F Other descriptors: I for the output of integer variables: I5 five digit integer A for the output of a character string: A10 a character string with 10 characters L for the output of logical variables and many other variants and combinations. 5 Input from and output to external files The open command is used to open files - that is, it makes files available so that Fortran can read or write to them. The simplest form of the command is open (unit = number, file = "name, specifications) open (unit=10, file = /scratch/student1/work/scores.txt, status= old )! Opens an existing file scores.txt open (11, file = ~/test.txt,status= unknown, position= app )! Opens a new file (if not existed) or existed file and apps new data to the of the file. Communication with the opened file is done via the write statement write(unit=10, (2F10.3) ) x, y! Unit numbers must agree, unit=10, not 12 or 14! write(11,*) z when the I/O operations with the file are finished, the close statement must follow to close the file Close(10,11)! Closes both files altogether 6

4 Allocatable arrays Sometimes the extent of the array may not be known a priori. Example: reading data from a file. Program data1 integer, parameter :: Nmax=1000 real, dimension(nmax) :: X integer i, N open(10,file= data.dat,status= old ) read(10,*) N! reads the file dimension do i=1, N read(10,*) X(i) do close(10) print,* N! reads data! If N<<Nmax waste of memory Program data2 real, dimension(:), allocatable :: X integer i, N, test open(10,file= data.dat,status= old ) read(10,*) N! reads the file dimension Allocate( X(N), stat=test )! Allocates array of size N If (test.ne.0) write(6,*) Error with array allocation do i=1, N read(10,*) X(i)! reads data do close(10) deallocate(x)! Clears memory The rank of an allocatable array is specified by the number of colons in the DIMENSION attribute. e.g. REAL, ALLOCATABLE, DIMENSION(:,:) :: Y! rank-two array The rule of thumbs: Do not use the allocatable attribute unless you really need to! Reason: 1) the compiler has a difficulty to optimize allocatable arrays. 2) messing with allocate / deallocate statements can produce phantom arrays, with a much heavier burden on the computer memory as compared to static arrays. 7 SELECT CASE Statement SELECT CASE (selector) CASE (label-list-1) statements-1 CASE (label-list-2) statements-2 CASE (label-list-n) statements-n CASE DEFAULT statements-default END SELECT selector is an expression whose result is of type INTEGER, CHARACTER or LOGICAL (i.e., no REAL type can be used for the selector). The rule of executing the SELECT CASE statement goes as follows: 1. The selector expression is evaluated 2. If the result is in label-list-i, then the sequence of statements in statements-i are executed, followed by the statement following END SELECT 3. If the result is not in any one of the label lists, there are two possibilities: a) if CASE DEFAULT is there, then the sequence of statements in statements-default are executed, followed by the statement following END SELECT b) if there is no CASE DEFAULT is not there, the statement following END SELECT is executed. INTEGER :: month SELECT CASE (month) CASE (12,1,2) write (*,*) 'Winter' CASE (3:5) write (*,*) 'Spring' CASE (6:8) write (*,*) 'Summer' CASE (9:11) write (*,*) 'Autumn' CASE DEFAULT write (*,*) 'Error: Something is wrong with your date' END SELECT 8

5 Derived types in Fortran 90 Fortran 90 supports five standard types for constants/variables: integer, real, complex, character, and logical. Besides, you can define a new type as shown in the example below. Suppose we have a grid with N x N grid cells. Each grid is characterized by x and y coordinates Temperature T density rho Program Newtype implicit NONE integer, parameter :: N=100 integer i type :: Grid! Declaring a new type Grid sequence! Forces to store the data in the memory in sequence real*8, dimension(1:n,1:n) :: T, rho! Elements of the derived type real*8, dimension(1:n) :: x, y type Grid type(grid) :: Cell! Declaring a variable Cell with type Grid Do i=1,n Cell%x(i)=i! Assigning values to the elements of the variable Cell Cell%y(i)=i Cell%T(i,i)=100.d0 Enddo Elements of derived types are accessed with the "%" operator 9 Functions in Fortran 90 In addition to intrinsic functions, Fortran allows you to design your own functions. A Fortran function has the following syntax: type FUNCTION function-name (arg1, arg2,..., argn) Declaration of modules IMPLICIT NONE declaration of constants and variables execution part END [FUNCTION function-name] type gives the type of the function value (i.e., INTEGER, REAL, LOGICAL and CHARACTER) function-name is the name you assign to the function, it must be unique. arg1, arg2, are so-called dummy arguments, which are the means of communication of the function with outer program units. Dummy arguments must be variable names, arithmetic expressions, or names of other functions/subroutines. Communication with other program units can also be done via the list of modules. The execution part must contain at least one operator function-name =. In other words, you must calculate the result of the function at least once. Functions can be internal or external to another program unit. For internal functions, [FUNCTION function-name] should be placed at the of the function declaration Simple example of external function INTEGER FUNCTION Sum(a, b, c) IMPLICIT NONE INTEGER, INTENT(IN) :: a, b, c Sum = a + b + c END Dummy arguments a, b, c must be explicitly declared (otherwise, how would the compiler know the type of the arguments?). The INTENT(IN) specification tells the compiler that the arguments cannot be reassigned values inside the function. 10

6 Example of internal function Linear interpolation of a tabulated function y=f(x) Program Tabular real, dimension(5), parameter :: x=(/1.,2.,3.,4.,5./) real, dimension(5), parameter :: y=(/1.,3.,6.,12.,21./) Real xdot,ydot integer i Write(6,*) 'input x coordinate between 1 and 5' Read(5,*) xdot i=1 Do while (x(i).le.xdot) i=i+1 Enddo ydot=lininter(x(i-1),x(i),y(i-1),y(i),xdot) write(6,*) ydot! Declaration of internal function begins CONTAINS Real Function LinInter(x1,x2,y1,y2,x) implicit NONE Real x1,x2,y1,y2,x If (x1.ne.x2) then LinInter= y1+(x-x1)*(y2-y1)/(x2-x1) Else LinInter=y1 Endif function LinInter! Declaration of internal function s! Tabulated x-data! Tabulated y-data! Reads the argument x! Localizes a pair of x-data that bound the argument x! Calculates the linearly interpolated function y 11 Comparison of internal and external functions Internal function Program Tabular real, dimension(5), parameter :: x=(/1.,2.,3.,4.,5./) real, dimension(5), parameter :: y=(/1.,3.,6.,12.,21./) Real xdot,ydot integer i Write(6,*) 'input x coordinate between 1 and 5' Read(5,*) xdot i=1 Do while (x(i).le.xdot) i=i+1 Enddo ydot=lininter(x(i-1),x(i),y(i-1),y(i),xdot) write(6,*) ydot! Declaration of internal function begins CONTAINS Real Function LinInter(x1,x2,y1,y2,x) implicit NONE Real x1,x2,y1,y2,x If (x1.ne.x2) then LinInter= y1+(x-x1)*(y2-y1)/(x2-x1) Else LinInter=y1 Endif function LinInter! Declaration of internal function s All variables of program Tabular (called global variables) are visible by the internal function. External function Program Tabular real, dimension(5), parameter :: x=(/1.,2.,3.,4.,5./) real, dimension(5), parameter :: y=(/1.,3.,6.,12.,21./) Real xdot,ydot Real, external :: LinInter integer i Write(6,*) 'input x coordinate between 1 and 5' Read(5,*) xdot i=1 Do while (x(i).le.xdot) i=i+1 Enddo ydot=lininter(x(i-1),x(i),y(i-1),y(i),xdot) write(6,*) ydot!. Declaration of external function begins Real Function LinInter(x1,x2,y1,y2,x) implicit NONE Real x1,x2,y1,y2,x If (x1.ne.x2) then LinInter= y1+(x-x1)*(y2-y1)/(x2-x1) Else LinInter=y1 Endif The external function knows nothing about the global variables in program Tabular. Communication is performed exclusively via the list of arguments. Good 12 practice even in the case of internal functions!

7 Subroutines in Fortran 90 The syntax of subroutines is similar to that of the functions. SUBROUTINE subroutine-name (arg1, arg2,..., argn) Declaration of modules IMPLICIT NONE declaration of constants and variables execution part END [SUBROUTINE subroutine-name] A subroutine, just like the main program, must have a name and this name is used to call the subroutine during program execution. The main purpose of subroutines is to perform a set of frequently used operations. 13 Example of internal subroutine Finding the real roots of a quadratic equation Program RealRoots real x1, x2, a, b, c, Disc write(6,*) Input parameters a, b, and c read(5,*) a, b, c Disc=b*b-4*a*c If (Disc.ge.0.) then x1=(-b+sqrt(disc)) / (2*a) x2=(-b-sqrt(disc)) / (2*a) write(6, (A25,2F8.2) ) The real roots are, x1, x2 Else write(6,*) No real roots Endif End You need to run the code all over again, if the real roots are not found Note that the names of the dummy and actual arguments may not coincide. However, the number and type of both dummy and actual arguments must coincide! Internal variables x1, x2, Disc are not visible in the main program. However, the global variables a1, b1, c1 are visible in the internal subroutine. If global and internal variables have the same name, the internal ones take the precedence (prevail). Program RealRoots real a1, b1, c1 logical flag Do while (.not.flag) write(6,*) Input parameters a, b, and c read(5,*) a1, b1, c1 Call RealRoot(a1,b1,c1,flag)! Calls the internal subroutine Enddo! declaration of internal subroutines begins. CONTAINS Subroutine RealRoot(a,b,c,flag) real, intent(in) :: a, b, c logical, intent(out) :: flag! flag must be assigned a value real x1,x2,disc! Internal variables Disc=b*b - 4*a*c If (Disc.ge.0.) then x1=(-b+sqrt(disc)) / (2*a) x2=(-b-sqrt(disc)) / (2*a) write(6, (A28,2F8.2) ) The real roots are, x1, x2 flag=.true. Else write(6,*) No real roots flag=.false. Endif subroutine RealRoot!.. Declaration of internal subroutines s End 14

8 Functions/subroutines as dummy arguments Dummy arguments in Fortran can be not only variables and arithmetic expressions but also the names of other EXTERNAL functions/subroutines. This feature is very handy when one needs to frequently call different functions of similar form. The following code provides an example. External functions need to have the same number of arguments! Program Dummy Real x,y Real, external :: One,Two! declares external functions! Call Evaluate(One,x,y) Call Evaluate(Two,x,y)! CONTAINS Subroutine Evaluate(funcName,x,y) Real, intent(in) :: funcname,x Real, intent(out) :: y y = funcname(x) + funcname(2*x) +1./funcName(-x) End!.. External function Real function One(x) Real, intent(in) ::x one=x**2 + sin(x) End!. Yet another external function Real function Two(x) Real, intent(in) :: x two= /x**2 tan(x) 15 Modules in Fortran 90 Purpose: Sharing variables, functions and subroutines between different program units MODULE module-name declaration of constants and variables [CONTAINS declaration of functions and subroutines] END MODULE module-name MODULE constants implicit NONE Real*8, parameter :: Msol = d33 Real*8, parameter :: parsec = d18 END MODULE constants PROGRAM main USE constants, ONLY: pi write (6,*) 'Pi = ', pi END 16

9 Procedure overloading Procedure overloading is used a lot in modular programming. Basically, the same name is given to two or more functions or subroutines. The program distinguishes between them based on the signature of the call made. For example, one could overload two subroutines to be called setzcut, with one taking an argument of type real and the other taking an argument of type integer. If I call setzcut passing an integer, then the subroutine taking an integer is called

10 19 20

11 21 22

12 23 Assignment 2 Introduction to Fortran 90 Lecturer: Dr. Eduard Vorobyov Due date: April 9, 2012 (zero tolerance!) Write a Fortran 90 code for the numerical integration of the following definite integral: b 2 1 x x a dx (1) Using the exted Simpson s rule: b a f ( x) dx = h f ( x1 ) + f ( x2 ) + f ( x3) + f ( x4 ) + K K+ f ( xn 2) + f ( xn 1) + f ( xn ) + f ( xn+ 1) Where x 1, x 2, x n+1 are equally spaced abscissas and, in particular, x 1 = a and x n+1 = b. The integration step is calculated as h = (b-a) / n and x i = a+(i-1)*h, i=1, n+1. Calculate the integral (1) for a=0 and b=1 with relative accuracy Start the integration with n = 10 and gradually increase n (which must be an even number!) until the desired accuracy is achieved. Ideally, the code should make use of functions and subroutine calls. 24

13 Graphical representation of numerical integration. Trapezoidal rule f(x 2 ) f(x 1 ) S 1 S 2 S n h x 1 x 2 x n x n+1 h S = f x + f x 2 ( ( ) ( )) xn+ 1 x 1 ( ) n = i + ( 3 ) i= 1 f x dx S O h Note that n+1 is the number of integration points and n is the number intervals. The greater n, the better the accuracy of the integration. This fact can be used to achieve a desired accuracy by increasing the value of n and calculating the relative error between the new and old estimate of the integral. Evaluation criteria: 1) Correctness. The code must give the correct result! 2) Completeness. All tasks in the assignments must be fulfilled. 3) Conciseness. The code must be as short as possible. Remember, the shorter your code, the longer your brains! 4) Versatility. You should use as many Fortran features as possible to demonstrate your knowledge. 5) Clearness. The code must be written clearly with necessary comments included so that others could understand the code. What should be presented. 1) A printed version of the code with the results of calculations. 2) An electronic version of the source code (not executable!) to be ed to eduard.vorobiev@univie.ac.at 26

AMath 483/583 Lecture 8

AMath 483/583 Lecture 8 This lecture: Fortran subroutines and functions Arrays Dynamic memory Reading: class notes: Fortran Arrays class notes: Fortran Subroutines and Functions class notes: gfortran flags