Fortran 2003 programming in GEF4510. Fall 2012

Transcription

1 Fortran 2003 programming in GEF4510 Fall

2 Course content 1. Fortran historical background, what, why and how 2. A short program converting from Farenheit to centigrades and vice versa 3. The variable types, arrays, loops and allocating space 4. File I/O 5. Multidimensional arrays 6. Functions and Subroutines 7. Modules 8. Optimization 2

3 Historical background of Fortran Introduction The purpose of this book is to give a good insight in the Fortran 2003 programming language.by going through a number of examples showing how computational problems and the reading and writing data to files can be solved. Why use Fortran? In the last 15 to 20 years Fortran has been looked upon as an old-fashioned unstructured programming language by researchers and students in the field of Informatics. Fortran has lacked most of the features found in modern programming languages like C++, Java etc. Especially the lack of object orientation has been the main drawback of Fortran. This is no longer true. Fortran 2003 has all the modern features including OOP (Object Oriented Programming). The reason we still use Fortran as a programming language is because of the exeecution speed of the program. In the field of natural sciences, computer simulations of natural phenomena are becoming increasingly more important. Laboratory experiments are getting too complex and too costly to be performed. The only alternative is to use a computer simulation to try to solve the problem under study. Thus the need to have your code execute faster becomes more and more important when the simulations grows larger and larger. In number-crunching Fortran still has an edge in speed over C and C++. Tests has shown that an optimized Fortran program in some cases runs up to 30 percent faster than the equivalent C or C++ program. For programs with a runtime of weeks even a small increase in speed will reduce the overall time it takes to solve a problem. Historical background Seen in a historical perspective Fortran is an old programming language John Backus and his team at IBM begin developing the scientific programming language Fortran. It was first introduced in 1957 for a limited set of computer architectures. In a short time the language spread to other architectures and has since been the most widely used programming language for solving numerical problems. The name Fortran is derived from Formula Translation and it is still the language of choice for fast numerical computations. A couple of years later in 1959 a new version, Fortran II was introduced. This version was more advanced and among the new features was the ability to use complex numbers and splitting a 3

4 program into various subroutines. In the following years Fortran was further developed to become a programming language that was fairly easy to understand and well adapted to solve numerical problems. In 1962 a new version called Fortran IV emerged. This version had among it s features the ability to read and write direct access files and also had a new data-type called LOGICAL. This was a Boolean data-type with two states true or false. At the end of the seventies Fortran 77 was introduced. This version contained better loop and test structures. In 1992 Fortran 90 was formally introduced as an ANSI/ISO standard. This version of Fortran has made the language into a modern programming language. Fortran 95 is a small extension of Fortran 90. These latest versions of Fortran has many of the features we expect from a modern programming languages. Now we have the Fortran 2003 which incorporates object-oriented programming with type extension and inheritance, polymorphism, dynamic type allocation and type-bound procedures. 4

5 A Farenheit to Centigrade converter Let us ask a question before we continue with our problem solving. Why do I have to learn to program? In the field of Meteorology and Oceanography you will probably be using models like WRF, CAM and ROMS or other models like them. Depending on your Master-project, you will some times have to make changes or additions to an already existing model written in Fortran. Without any knowledge of programming and the Fortran language you will use too much time trying to find out how you are going to make the changes to the model and loosing valuable time. If that is not a good reason to learn how to program I would like to hear why. Our first step in learning how to program using Fortran 2003 language will be to write a small program converting a temperature from Farenheit to Centigrade and display the two temperatures on the screen. The formula for the conversion is: C = (F 32) 5 (1) 9 So how do we go about solving this problem using Fortran? First we have to take a look at the structure of a Fortran program. A Fortran program always starts with the sentence PROGRAM program_name and ends with the sentence END PROGRAM program_name. Between these two lines the actual code performing a task is written. To proceed with the solution we need a couple of variables to hold the temperature in Farenheit and Centigrades. We use the F and C for Farenheit and Centigrades. The syntax for declaring a floating point variable in Fortran is like this:!// The Farenheit variable REAL :: F!// The Centigrade variable REAL :: C Note that we use the REAL keyword to declare a floating point variable. In other languages the keyword float is used. The Fortran language is case insensitive. That means that a variable or function mane is the same if it is written with uppercase or lowercase letters. In most other languages it is the opposite where a variable whose name is written in uppercase is different from a variable in lowercase. From the Fortran 90 version we separate the variable type from the variable name with a double colon. Also from this version and on we use an exclamation sign to signal the compiler that the rest of the line is a comment. In order to make the code more readable an additional double slash si also used. As we shall see 5

6 later in this course a program that is easy to read is also easy to understand and also makes it easier to find and correct errors. One ting we have to be aware of is that Fortran uses what is called implicit declarations of variables. This is from the earliest versions of Fortran and can cause unwanted results due to misspelling of a variable name. To prevent this all programs written in Fortran should have as the first line of code after the PROGRAM program_name the which tells the compiler to check that all variables has benn declared thus avoid problems. The net step is to initialize the Farenheit variable and perform the conversion according to the formula. The whole program can look like this. PROGRAM farenheit_to_centigrades!// Declare the Farenheit variable F as a floating!// point number REAL :: F!// Declare the Centigrade variable C as a floating!// point number REAL :: C!// Assigne a value to F as a constant number!// note the decimal point after the constant number F = 75.!// Perform the calculations C = (F - 32.)*5./9.!// Write the result to the screen PRINT *, C END PROGRAM farenheit_to_centigrades We need to comment on some of the code here. In order to tell the compiler that the constant value like 75. we have to use a decimal point as part of the number. If we omit this the compiler will assume that is an integer and in some cases the calculations will be wrong. Also note the use of parenthesis to perform the calculations in the proper sequence. The sentence PRINT *, C writes the value of the Centigrades to the display. Writing the source code is one thing, but in order to run the program we have to compile it from source code to a binary executable program file. There are several commercial Fortran compilers, but we are going to use the GNU Fortran compiler called gfortran to compile our program. So how do we do it? Assume we have called our file with the source code farenheit_to_centigrades.f90. To compile it we use the command gfortran -o farenheit_to_centigrades farenheit_to_centigrades.f90 6

7 where the o is a signal to the compiler that the next argument is the name of the program and the last argument is the name of the file with the source code. This command tells the compiler to create a binary program file called farenheit_to_centigrades which can be run by typing the program name in a terminal window. All Fortran programs are compiled this way. We shall take a look at how we compile a program consisting of several files with source code later. 7

8 A more user friendly temperature converter The temperature conversion program we made in the previous section is not very user friendly. Th convert a new temperature we have to change the source code, recompile the program and then run it again. Back in 1957 this was not uncommon, but we do not have to use stoen age tools here. We will therefore upgrade our program with a user interface asking for a temperature in either Farenheit or Centigrade and print the result to the screen as before. The first thing we have to do is to write the "prompt" to the screen. To do this we declare a text variable using the keyword CHARACTER with a length option like this CHARACTER(LEN=80) which means that we have allocated a space for a text up to 80 characters long. Also we need a single character variable to hold the answer of the temperature (F or C) for conversion. The complete program is here:!//////////////////////////////////////////////////////////!//!// f2c.f90!//!// Program to convert from Farenheit to!// Centigrades or vice versa!////////////////////////////////////////////////////////// PROGRAM f2c!// Temperature in Farenheit REAL :: F!// Temperature in Centigrades REAL :: C!// Character string to hold the prompts for communicating!// with the user CHARACTER(LEN=80) :: prompt1, prompt2!// A single character to hold the answer!// which is is either F or C CHARACTER :: answer!// Assign a value to the prompt1 prompt1 = Enter F for Farenheit or C for centigrade!// Print the contents to the screen without trailing blank!// characters PRINT *, TRIM(prompt1) 8

9 !// Read the input from the keyboard READ(*,*) answer!// Assign a value to the prompt2 prompt2 = Enter a temperature!// Print the contents to the screen without trailing blank!// characters PRINT *, TRIM(prompt2)!// Is the temperature given in Farenheit IF(answer.EQ. F ) THEN!// Yes, read the input from the keyboard into!// the F variable READ(*,*) F!// Convert from Farenheit to Centigrade C = (F - 32) * (5. / 9.)!// Print the result to the screen PRINT *, C ELSE!// No, read the input from the keyboard into!// the C variable READ(*,*) C!// convert from Centigrade to Farenheit F = (C * 9. / 5.) + 32!// Print the result to the screen PRINT *, F END PROGRAM f2c Note that this program contains a descriptive comment as the first part of the source code including the name of the file containing the source code. This is a very good way of making the code more readable and easier to understand and should always be used even for very small programs. The use of the keyword TRIM tells the compiler to print out the text witout printing the trailing space characters. We use the READ to get the answer entered by the user and put it in the proper variable. The use of the construct READ(*,*) means we read the input from the keyboard with default formatting into the recieving variable. 9

10 Variable types, arrays, loops and memory allocation Until now we have used single variables with the exception of a character string. Most often we need to use large amount of data stored in one dimensional vectors or matrices with two or more dimensions. We shall start with a program calculating the Fibonacchi sequence and store the numbers in a vector of integers. Also we shall have a user interface asking for the length of the sequence. The formula for calculating the Fibonacchi sequence is this: F n = F n 1 + F n 2 (2) We will of course start with the program skeleton as always with the code PROGRAM fibonacchi END PROGRAM fibonacchi The easy part done it is now the work begins. We will need to break the problem down into several smaller parts like I suggest here: Decide which variables we need to store the numbers, the indexes and if we need it some help variables. Decide how we are going to access the variables and how we are going to perform the calculations on each element of the sequence First we need an array of integers to hold the numbers. The length of this array (or vector) is not known in advance so we will have to use an allocatable array where we allocate the needed space at runtime. In addition we need an index variable and a status variable where the first one is for accessing the various elements of the array and the status variable to check the result of the allocation. Since we have to get the length ogf the array at runtime we also need a user interface like we had in the temperature conversion program. The code is shown here:!////////////////////////////////////////////////////////////////!//!// fibonacchi.f90!//!// Program to display the fbonacchi sequence from!// 1 to n!//!//////////////////////////////////////////////////////////////// 10

11 PROGRAM fibonacchi!// Variable declarations!// Declaring integer variables!// Counter variable :: i!// Length of fibonacchi array :: n!// The status variable :: res!// Array to hold the fibonacchi sequence with!// unknown length at compile time, ALLOCATABLE, DIMENSION(:) :: sequence!// The prompt to ask for length of the fibonacchi!// sequence CHARACTER(LEN=80) :: prompt!// Assign value to the prompt prompt = Enter the length of the sequence:!// Get the number of non blank characters in prompt i = LEN(TRIM(prompt))!// Display the prompt asking for the length suppressing!// the line feed WRITE(*,FMT= (A),ADVANCE= NO ) prompt(1:i+1)!// Read the keyboard input READ(*,*) n!// Allocate space for the sequence ALLOCATE(sequence(n), STAT=res)!// Test the value of the res variable for errors!// We have an error. Print a message and stop the program PRINT *, Error in allocating space, status:, res STOP!// Initialize the two first elements in the sequence sequence(1) = 1 sequence(2) = 1!// Loop and calculate the fibonacchi numbers DO i = 3, n sequence(i) = sequence(i-1) + sequence(i-2) 11

12 !// Print the sequence to the screen PRINT *, sequence END PROGRAM fibonacchi Some explanation to the code. To declare an array with unknown length we use the keywords, ALLOCATABLE, DIMENSION(:) where we replace the length of the array with a colon :. If we knew in advance the length of the array was 100 elements we could use this construct, DIMENSION(100). Since we want a dynamic program we have to use the first construct. Using the keyword PRINT * always prints the text to the screen with a linefeed as the last operation. This is not something we want in a user interface so we have to add some code to suppress the linefeed. This is why we use WRITE(*,FMT= (A)ADVANCE= NO ) instead of PRINT *. When we have stored the length of the array in the variable n we can allocate space for the array sequence using the construct: ALLOCATE(sequence(n), STAT=res). Then we test if the res is different from zero which means that the allocation failed and we stop the program. Then we initialize the first two elements of the array to one and start the loop calculating the next element in the sequence based on the value of the two previous elements. Note that we start the value of the index variable with the value of 3. that is because we already have given the first two elements og the array the value of 1. Finally we display the contents of the sequence on the screen. 12

13 File I/O Usually we do not enter data into a program manually. Mostly the data is generated either through the output of a program written to a file and not to the display, or from data produced by sensors in one way or another. We will now take a look at how we can read data from a file into an array, perform some operation on the data set and write the result to a new file. As before we have to think how we should break down the problem into smaller, more manageable parts. In our case w know in advance the length of the array which is 7 elements long. first we declare a static variable containing the length of the array. Then we declare two arrays, one to hold the Farenheit and the other to hold the Centigrades. In addition to this we need two character strings to hold the input filename and the output filename. Further we need two static variables to hold the unit numbers which we use to reference the two files with. These reference numbers are integers. Once we have declared these variables we also have to declare the index and status variable. Before we can access the contents of a file we have to open it using the unit number we declared and testing that the opening was successful. once we have opened the file we can read the contents into the array using a loop running from one to the length of the array. Once we have read in the contents of the file into the array we can then loop and convert from Farenheit to Centigrades storing the result into the other array. Once this conversion is finished we write the contents of the array to the output file after we have opened it like we did for the input file. As the alst thing to do is to close the files before the program terminates. The complete code with comments are shown below. PROGRAM temp_calc!// A program calculating centigrades from farenheit!// Create a static variable to hold the length of the array, PARAMETER :: n = 7!// Declare the arrays for the temperatures in Farenheit and!// Centigrades REAL,DIMENSION(n) :: farenheit REAL,DIMENSION(n) :: centigrade!// Index variables :: i!// Character strings to hold the filenames CHARACTER(LEN=80) :: farenheit_file CHARACTER(LEN=80) :: centigrade_file!// Constant values for the Logical Unit Number 13

14 !// for referencing the files for opening, reading!// and writing, PARAMETER :: ilun = 10, PARAMETER :: olun = 11!// A status variable to hold the result of file!// operations :: res!// Assign the input filename for Farenheit temp. farenheit_file = "farenheit.txt"!// Assign the output filename for Centigrade temp. centigrade_file = "centigrade.txt"!// Open the input file OPEN(UNIT=ilun,FILE=farenheit_file,FORM="FORMATTED",IOSTAT=res)!// Test if the operation was successful!// No, an error occurred, print a message to!// the screen PRINT *, "Error in opening file, status: ", res!// Stop the program STOP!// Loop and read each line of the file DO i = 1, n!// Read the current line READ(UNIT=ilun,FMT= (F4.1,X,F4.1),IOSTAT=res) farenheit(i)!// Was the read successful?!// No, test if we have reached End Of File (EOF) IF(res /= -1) THEN!// No, an error has occurred, print a message PRINT *, "Error in reading file, status: ", res!// Close the file CLOSE(UNIT=ilun)!// Stop the program STOP!// Loop and convert from Farenheit to Centigrade 14

15 DO i = 1, n centigrade(i) = (farenheit(i) - 32) * 5. / 9.!// Print the temperatures to the screen DO i = 1, 7 PRINT *, "Degrees Farenheit ", farenheit(i),& " Degrees Centigrade ",centigrade(i)!// Open the output file OPEN(UNIT=olun,FILE=outfile,FORM="FORMATTED",IOSTAT=res)!// Test if the operation was successful!// No, an error occurred, print a message to!// the screen PRINT *, "Error in opening output file, status: ", res!// Stop the program STOP DO i = 1, n WRITE(UNIT=olun,FMT= (F4.1,A1,F4.1),IOSTAT=res) centigrade(i)!// Test if the operation was successful!// No, an error occurred, print a message to!// the screen PRINT *, "Error in writing file, status: ", res!// Exit the loop EXIT!// Close the input file CLOSE(UNIT=ilun)!// Close the output file CLOSE(UNIT=olun) END PROGRAM temp_calc Again we need to comment some of the new things in the code. First we use the keyword PARAMETER to specify that the comtents of the static variable is not to be changed at runtime. Using the OPEN function we use the already mentioned unit number. then we provide the filename as part of the FILE argument and the result of the call to the open is returned in the IOSTAT=res keyword/argument pair. Much of the same procedure is used in erading and writing of data from 15

16 and to files. In this case we use formatted files which means that the file ca be displayed on the screen in contrast to bianry files which will only display garbage on the screen. Two examples of how a binary and formatted files looks like is shown ^@^@^@<B9><B8>_N^@H<C7>D$0P^@^@^@<BA>^C<FF><84> ^C3<C0>H<C7>D$8<80><DC>s^@L<8D>D$0H<C7>D$@ ^@^@^@H<C7>D$H<E0> N^@H<C7>D$P^D^@^@^@<E8>O<C3> As we can see the binary format is unreadable unless you use a program which convert from binary to ASCII format, where ASCII format is the same as a formatted file in Fortran. ASCII is short for American Standard Code for Iformation Interchange. Next wh anve the format description of the file contents. We use the keyword/argument pair FMT= (F4.1,X,F4.1) to tell the system that we have a floating point number with 4 digits including the decimal point and one decimal, a space character and then another floating point number like the first. 16

17 Multidimensional arrays In the field of Meteorology and Oceanography the data sets we operate on is usually in four dimensions, space and time. this means that we have to declare matrices in four dimensions to be able to store the data. the next example shows how we can use a two dimensional matrix to store a set of temperatures in Farenheit from two measuring stations read in from a file and convert the temperatures into Centigrades. The solution will be just like the previous program with the exception that we here operate on a matrix with two dimensions and thus needs a nested loop to perform the calculations. The complete code is shown below. PROGRAM temp_calc2!// A program calculating Centigrades from Farenheit from two!// measuring stations!// Declare the arrays for the temperatures in Farenheit and!// Centigrades REAL,DIMENSION(7,2) :: farenheit REAL,DIMENSION(7,2) :: centigrade!// Index variables :: i, j!// Character strings to hold the filenames CHARACTER(LEN=80) :: farenheit_file CHARACTER(LEN=80) :: centigrade_file!// Constant values for the Logical Unit Number!// for referencing the files for opening, reading!// and writing, PARAMETER :: ilun = 10, PARAMETER :: olun = 11!// A status variable to hold the result of file!// operations :: res!// Assign the input filename for Farenheit temp. farenheit_file = "farenheit.txt"!// Assign the output filename for Centigrade temp. centigrade_file = "centigrade.txt"!// Open the Farenheit input file OPEN(UNIT=ilun,FILE=farenheit_file,FORM="FORMATTED",IOSTAT=res)!// Test if the operation was successful 17

18 !// No, an error occurred, print a message to!// the screen PRINT *, "Error in opening file, status: ", res!// Stop the program STOP!// Loop and read each line of the file DO i = 1, 7!// Read the current line READ(UNIT=ilun,FMT= (F4.1,X,F4.1),IOSTAT=res) farenheit(i,1), & farenheit(i,2)!// Was the read successful?!// No, test if we have reached End Of File (EOF) IF(res /= -1) THEN!// No, an error has occurred, print a message PRINT *, "Error in reading file, status: ", res!// Close the file CLOSE(UNIT=ilun)!// Stop the program STOP!// Close the input file CLOSE(UNIT=ilun)!// Loop and convert from Farenheit to Centigrade DO j = 1, 2 DO i = 1, 7 centigrade(i,j) = (farenheit(i,j) - 32) * 5./9.!// Open the Centigrade output file OPEN(UNIT=olun,FILE=centigrade_file,FORM="FORMATTED",IOSTAT=res)!// Test if the operation was successful!// No, an error occurred, print a message to!// the screen PRINT *, "Error in opening output file, status: ", res!// Stop the program STOP 18

19 DO i = 1, 7 WRITE(UNIT=olun,FMT= (F4.1,A1,F4.1),IOSTAT=res) centigrade(i,1),, & centigrade(i,2)!// Test if the operation was successful!// No, an error occurred, print a message to!// the screen PRINT *, "Error in writing file, status: ", res!// Exit the loop EXIT!// Close the output file CLOSE(UNIT=olun) END PROGRAM temp_calc2 Like in he previous section we need to explain a couple of things, mainly the use of the nested loops. It is important for the efficiency of the program to know how Fortran accesses a matrix. Fortran and also Matlab accesses a matrix column wise. It means that all the row elements in a column will be accessed before the row elements in the next column. This is in contrast to other programming languages which accesses all the column elements in a row before moving to the next row just like we would read each line of text before moving th the next line. Therefore it is a rule of thumb to always have the first index in the innermost loop using Fortran (and Matlab). 19

20 Functions and Subroutines It is not a very good programming style to write a long program with all the necessary code in one source file. this makes the program difficult to maintain and to understand. usually we break down a problem into smaller parts like functions or subroutines. In this section we will extend the program from the previous section to read temperatures stored in either Farenheit or Centigrades and perform the correct conversion using functions for the conversion. We need therefore two functions, one which we will call f2c() and the other c2f(). First we program f2c() like this: FUNCTION f2c(f) RESULT(C)!// The input argument which is read only REAL(KIND=8), INTENT(IN) :: F!// The result from the calculations REAL(KIND=8) :: C!// Perform the calculation C = (F -32) * 5./9.!// Return the result RETURN END FUNCTION f2c And c2f().like this: FUNCTION c2f(c) RESULT(F)!// The input argument which is read only REAL(KIND=8), INTENT(IN) :: C!// The result from the calculations REAL(KIND=8) :: F!// Perform the calculation F = (C * 9. / 5.) + 32!// Return the result RETURN END FUNCTION f2c In contrast to the way we write mathematical functions Fortran are using a keyword RESULT(arg) where the datatype of the argument states what kind of function it is. In Fortran 77 and older versions the syntax was REAL FUNCTION f2c(arg). Note the use of INTENT(IN) for the input argument to the functions. This is to prevent accidental overwriting of the argument since Fortran function and subroutine arguments are always called by reference and not 20

21 by value. The only thing we need to do in the main program with the exception of the user interface is to replace the formula for the conversion with a call to the respective functions. Note that in order to use other the Fortran intrinsic functions we have to declare them as external functions of the correct type. If we omit the external attribute the compiler will flag en error and the compilation will be aborted. The complete main program is shown below. PROGRAM array2!// A program calculating centigrades from Farenheit to Centigrades!// and vice versa!// Declare the arrays for the temperatures in Farenheit and!// Centigrades REAL,DIMENSION(7,2) :: farenheit REAL,DIMENSION(7,2) :: centigrade!// Index variables :: i, j!// Character strings to hold the filenames CHARACTER(LEN=80) :: farenheit_file CHARACTER(LEN=80) :: centigrade_file!// Constant values for the Logical Unit Number!// for referencing the files for opening, reading!// and writing, PARAMETER :: ilun = 10, PARAMETER :: olun = 11!// A status variable to heold the result of file!// operations :: res!// External function(s) REAL, EXTERNAL :: f2c REAL, EXTERNAL :: c2f!// A character string for a prompt CHARACTER(LEN=80) :: prompt CHARACTER :: answer!// Assign the input filename for Farenheit temp. farenheit_file = "farenheit.txt"!// Assign the output filename for Centigrade temp. centigrade_file = "centigrade.txt"!// Ask the user if we are converting from farenheit to!// centigrade or from centigrade to farenheit 21

22 prompt = Convert from Farenheit to Centigrade (F/C)? PRINT *, TRIM(prompt) READ(*,*) answer!// Check if the answer is F or f for Farenheit IF(answer.EQ. F.OR. answer.eq. f ) THEN!// Yes, open the Farenheit input file OPEN(UNIT=ilun,FILE=farenheit_file,FORM="FORMATTED",IOSTAT=res)!// Test if the operation was successful!// No, an error occurred, print a message to!// the screen PRINT *, "Error in opening file, status: ", res!// Stop the program STOP!// Loop and read each line of the file DO i = 1, 7!// Read the current line READ(UNIT=ilun,FMT= (F4.1,X,F4.1),IOSTAT=res) farenheit(i,1), & farenheit(i,2)!// Was the read successful?!// No, test if we have reached End Of File (EOF) IF(res /= -1) THEN!// No, an error has occurred, print a message PRINT *, "Error in reading file, status: ", res!// Close the file CLOSE(UNIT=ilun)!// Stop the program STOP ELSE!// No, open the Centigrade input file OPEN(UNIT=lun,FILE=centigrade_file,FORM="FORMATTED",IOSTAT=res)!// Test if the operation was successful!// No, an error occurred, print a message to!// the screen PRINT *, "Error in opening file, status: ", res 22

23 !// Stop the program STOP!// Loop and read each line of the file DO i = 1, 7!// Read the current line READ(UNIT=ilun,FMT= (F4.1,X,F4.1),IOSTAT=res) centigrade(i,1), & centigrade(i,2)!// Was the read successful?!// No, test if we have reached End Of File (EOF) IF(res /= -1) THEN!// No, an error has occurred, print a message PRINT *, "Error in reading file, status: ", res!// Close the file CLOSE(UNIT=ilun)!// Stop the program STOP!// Close the input file CLOSE(UNIT=ilun)!// Which way to convert? IF(answer.EQ. F.OR. answer.eq. f ) THEN!// Loop and convert from Farenheit to Centigrade DO j = 1, 2 DO i = 1, 7 centigrade(i,j) = f2c(farenheit(i,j)) ELSE!// Loop and convert from Centigrade to Farenheit DO j = 1, 2 DO i = 1, 7 farenheit(i,j) = c2f(centigrade(i,j)) 23

24 !// Which file to write to? IF(answer.EQ. F.OR. answer.eq. f ) THEN!// Open the Centigrade output file OPEN(UNIT=olun,FILE=centigrade_file,FORM="FORMATTED",IOSTAT=res)!// Test if the operation was successful!// No, an error occurred, print a message to!// the screen PRINT *, "Error in opening output file, status: ", res!// Stop the program STOP DO i = 1, 7 WRITE(UNIT=olun,FMT= (F4.1,A1,F4.1),IOSTAT=res) centigrade(i,1),, & centigrade(i,2)!// Test if the operation was successful!// No, an error occurred, print a message to!// the screen PRINT *, "Error in writing file, status: ", res!// Exit the loop EXIT ELSE!// Open the Farenheit output file OPEN(UNIT=olun,FILE=farenheit_file,FORM="FORMATTED",IOSTAT=res)!// Test if the operation was successful!// No, an error occurred, print a message to!// the screen PRINT *, "Error in opening output file, status: ", res!// Stop the program STOP DO i = 1, 7 WRITE(UNIT=olun,FMT= (F4.1,A1,F4.1),IOSTAT=res) farenheit(i,1),, & farenheit(i,2)!// Test if the operation was successful!// No, an error occurred, print a message to 24

25 !// the screen PRINT *, "Error in writing file, status: ", res!// Exit the loop EXIT!// Close the output file CLOSE(UNIT=olun) END PROGRAM array2 In contrast to the functions a subroutine does not return a value and is the same as a void function in other languages. We can replace the f2c() and c2f() with corresponding subroutines which can look like this: SUBROUTINE f2c(f,c)!// The input argument which is read only REAL(KIND=8), INTENT(IN) :: F!// The result of the conversion which is!// write only REAL(KIND=8), INTENT(OUT) :: C!// Perform the conversion C = (F -32) * 5./9.!// Return the result through the second argument RETURN END SUBROUTINE f2c SUBROUTINE c2f(c,f)!// The input argument which is read only REAL(KIND=8), INTENT(IN) :: C!// The result of the conversion which is REAL(KIND=8), INTENT(OUT) :: F!// Perform the conversion F = (C * 9. / 5.) + 32!// Return the result through the second argument RETURN END SUBROUTINE c2f The calling from the main program is like this:... 25

26 !// Loop and perform the conversion using!// nested loops DO j = 1, 2 DO i = 1, 7!// Call the subroutine with the current element!// of the farenheit array as the first argument to!// the soubroutine and the current element of the!// centigrade array as the second argument. CALL f2c(farenheit(i,j),centigrade(i,j))...!// Loop and perform the conversion using!// nested loops DO j = 1, 2 DO i = 1, 7!// Call the subroutine with the current element!// of the farenheit array as the first argument to!// the soubroutine and the current element of the!// centigrade array as the second argument. CALL c2f(centigrade(i,j).farenheit(i,j)) A subroutine shall not be declared as external, only non intrinsic functions. Also note the use of the INTENT(OUT) which means we can only give value to the argument and trying to read the valeu fro the argument would flag a compilation error just like it would if we were trying to give the argument a value when it has the attribute INTENT(IN) which means read only. 26

27 Modules Now it is time to progress further into the world of Fortran programming. We know now how to use functions and subroutines, but often we need to put global variables together with the corresponding procedures working with these variables. It is here we utilize the MODULE which was introduced in Fortran 90. A module consists of a set of variable declarations and an optional set of functions and subroutines working on the variables. A skeleton module can look like this: MODULE my_module!// Global variable declarations CONTAINS!// Procedure declarations END MODULE my_module A module always starts with the keyword MODULE module_name and ends with the keyword END MODULE module_name. to separate the variable declarations from the procedure declarations the keyword CONTAINS is used. To create a module all we have to do is to fill in the variables and procedures. Note that we use procedure as a common name for functions and subroutines here. We shall now transfer our temperature conversion program into a module with five separate functions and subroutines and corresponding global variables and constants. MODULE my_module!// Arrays and strings!// The array containing the temperature which we!// will perform the conversion from REAL(KIND=8),ALLOCATABLE,DIMENSION(:,:) :: from!// The array receiving the converted temperature REAL(KIND=8),ALLOCATABLE,DIMENSION(:,:) :: to!// A character string containing the name of the input!// file CHARACTER(LEN=80) :: infile!// A character string containing the name of the output!// file CHARACTER(LEN=80) :: outfile!// A single character containing the type of temperature!// which will be the input (F or C) CHARACTER :: conversion 27

28 !// Integers to hold the number of rows columns of!// arrays :: m, n CONTAINS!// The procedure declarations FUNCTION f2c(f) RESULT(C)!// The input argument which is read only REAL(KIND=8), INTENT(IN) :: F!// The result from the calculations REAL(KIND=8) :: C!// Perform the calculation C = (F -32) * 5./9.!// Return the result RETURN END FUNCTION f2c FUNCTION c2f(c) RESULT(F)!// The input argument which is read only REAL(KIND=8), INTENT(IN) :: C!// The result from the calculations REAL(KIND=8) :: F!// Perform the calculation F = (C * 9. / 5.) + 32!// Return the result RETURN END FUNCTION c2f!// Subroutines skeleton SUBROUTINE load(res) :: res,parameter :: lun = 10 END SUBROUTINE load SUBROUTINE dump(res) :: res 28

29 ,PARAMETER :: lun = 10 END SUBROUTINE dump SUBROUTINE solve(res) END SUBROUTINE solve :: res END MODULE my_module Here we have a skeleton outlining the module. All we have to do is to fill in the missing code in the three subroutines since we already have written the two functions f2c and c2f. Let us take the first subroutine load and write it. In this case the input file contains a description of the contents of the file and then two integers telling the size of the array in number of columns and rows. We have to open the file and read the first line discarding it since we are interested in the two integers so we can allocate space for the arrays. The code solving this problem can look like this: SUBROUTINE load(res)!// Argument containing the result of the operations in the!// subroutine :: res!// Index variables :: i, j, k, l!// The unit number associated with the file,parameter :: lun = 10!// Help variable for use with extracting each!// number from the buffer :: buff_end!// A character string to hold each line read from the!// file CHARACTER(LEN=256) :: buffer!// A help variable to hold each ASCII number CHARACTER(LEN=20) :: tmp_num!// An external function converting from ASCII digits to!// a binary floating point number REAL(KIND=8),EXTERNAL :: a2d!// Open the file OPEN(UNIT=lun,FILE=TRIM(infile),FORM= FORMATTED,IOSTAT=res)!// Is the open a success? 29

30 !// No, print an error message and return to the main!// program PRINT *, Error in opening file, status:, res RETURN READ(UNIT=lun,FMT= (A),IOSTAT=res) buffer!// Print an error message and return to the main!// program PRINT *, Error in reading file, status:, res CLOSE(UNIT=lun) RETURN READ(UNIT=lun,FMT= (I4),IOSTAT=res) m!// Print an error message and return to the main!// program PRINT *, Error in reading file, status:, res CLOSE(UNIT=lun) RETURN READ(UNIT=lun,FMT= (I4),IOSTAT=res) n!// Print an error message and return to the main!// program PRINT *, Error in reading file, status:, res CLOSE(UNIT=lun) RETURN ALLOCATE(F(m,n),STAT=res)!// Print an error message and return to the main!// program PRINT *, Error in allocating space, status:, res CLOSE(UNIT=lun) RETURN ALLOCATE(C(m,n),STAT=res)!// Print an error message and return to the main 30

31 !// program PRINT *, Error in allocating space, status:, res CLOSE(UNIT=lun) RETURN... END SUBROUTINE load Now we have managed to retrieve the size of the array and allocated the necessary space for the array we can proceed with reading the values into the array. Depending on the formatting of the values we have to adjust the way we read the data into the array. Normally we read in one line at the time and convert the ASCII digits to binary numbers in one way or another. Very often this kind of data is presented as a comma separated text file where each number is separated from the next with a comma, a semicolon or just a space character. We will therefore assume that our file is such a.csv file and write the code to support this file type. SUBROUTINE load(res)...!// Loop and read all the lines from the file DO i = 1, m!// Clear the buffer character string buffer =!// Read the line into the buffer READ(UNIT=lun,FMT= (A),IOSTAT=res), buffer!// Was the operation successful?!// No, print an error message and return to the main!// program PRINT *, Error in reading file, status:, res!// colse the input file CLOSE(UNIT=lun)!// Return to the main program RETURN!// Fine the number of characters in the buffer with the!// exception of trailing space buff_end = LEN_TRIM(buffer)!// Initialize index variables j = 1 l = 1 31

32 !// Find the next comma in the buffer and extract the!// ASCII digits for this number DO k = 1,buff_End IF(buffer(k:k).EQ., ) THEN!// Convert form ASCII digits to a binary number!// using the external function a2f (ASCII to floating) from(i,j) = a2d(buffer(l:k-1))!// Update index variables j = j + 1 l = k + 1!// Close the input file CLOSE(UNIT=lun) END SUBROUTINE load Here we traverse each line of data and extract the temperature taking the part of the text that contains the number in ASCII digits to real number using the a2f function which is an external function for the conversion of ASCII digits to floating point. Having the load subroutine ready we will take a look at the dump subroutine. This works in many way like load, but is much easier to program not needing the conversion from ASCII digits to binary numbers. So let us roll up our sleeves and start coding. SUBROUTINE dump(res)!// Argument containing the result of the operations in the!// subroutine :: res!// Index variables :: i, j!// Unit number associated with the file,parameter :: lun = 10!// Open the file OPEN(UNIT=lun,FILE=TRIM(outfile),FORM= FORMATTED,IOSTAT=res)!// Print an error message and return to the main!// program PRINT *, Error in opening file, status:, res RETURN 32

33 !// Write the number of rows and columns to the file WRITE(UNIT=lun,FMT= (I4),IOSTAT=res) m!// Print an error message and return to the main!// program PRINT *, Error in writing file, status:, res RETURN WRITE(UNIT=lun,FMT= (I4),IOSTAT=res) n!// Print an error message and return to the main!// program PRINT *, Error in writing file, status:, res RETURN!// Loop and write the converted temperatures to the!// output file DO i = 1,n DO j = 1, m -1!// Write the n-1 elements of the row to the file!// separated by a comma WRITE(UNIT=lun,FMT= (F4.1,A1),ADVANCE= NO ) to(i,j),,!// Print an error message and return to the main!// program PRINT *, Error in writing file, status:, res RETURN!// Write the nth element of the row to the file!// separated by a comma WRITE(UNIT=lun,FMT= (F4.1),IOSTAT=res) to(i,m)!// Print an error message and return to the main!// program PRINT *, Error in writing file, status:, res RETURN!// Close the output file CLOSE(UNIT=lun) 33

34 END SUBROUTINE dump Simple compared to load is it not? then all we have to do is write the solve subroutine which can be done like this. SUBROUTINE solve(res)!// Argument containing the result of the operations in the!// subroutine :: res!// Index variables :: i, j!// Test which way to convert IF(conversion.EQ. F ) THEN!// Loop and convert from Farenheit to Centigrades DO j = 1,m DO i = 1, n!// Calling f2c with the current element of from as!// input argument and put the result in the!// corresponding element in the to array to(i,j) = f2c(from(i,j)) ELSE!// Loop and convert from Centigrades to Farenheit DO j = 1,m DO i = 1, n!// Calling c2f with the current element of from as!// input argument and put the result in the!// corresponding element in the to array to(i,j) = c2f(from(i,j)) END SUBROUTINE solve This is also quite simple. We just check which way to convert and then call the correct function within the nested loops. The only thing different her and in the load and dump subroutines is the way we traverse the array. Note that we are traversing the array column by column in load and dump, but row by row in the solve. The last one is, as mentioned before, the correct way in Fortran, but due to the way the data is stored in the files we have to go the "wrong way" in load and dump. 34

35 The only thing to do now is to write the main program which will use the module. The program can look like this. PROGRAM convert_temp!// The main program!// Use the module called my_module USE my_module!// A status variable :: res!// Ask the user which way to convert WRITE(*,FMT= (A),ADVANCE= NO ) & Enter F for conversion from Farenheit or C the other wy: READ(*,*) conversion!// Ask the user for the input file WRITE(*,FMT= (A),ADVANCE= NO ) & Enter the name of the input file: READ(*,*) infile!// Ask the user for the output file WRITE(*,FMT= (A),ADVANCE= NO ) & Enter the name of the output file: READ(*,*) outfile!// Call the load subroutine sith the status!// variable as the only argument CALL load(res)!// Was the call successful?!// No, stop the program STOP CALL solve(res)!// Was the call successful?!// No, stop the program STOP CALL dump(res)!// Was the call successful?!// No, stop the program 35

36 STOP END PROGRAM convert_temp As we can see the main program is quite small, as it should be, and all the work is done in the procedures in the module. This shows that using modules will give us a more structured program which is far more readable and easy to understand than putting all the code in one large file. Also a module can use another module and so on so we can have a hierarchical structure of the program. In order to compile and run this program we have to take the compilation either in one step or we can use two steps. It is often preferable to use two steps since it is easier to trace syntax errors in the source code that way. The two steps are like this. gfortran -c my_module.f90 gfortran -o convert_temp convert_temp.f90 my_module.o -L./ -lstrconv The first step with the c tells the compiler to take the source code and compile it into an intermediate binary object file with the extension.o. The second step tells the compiler to produce an executable binary program consisting of the compiled source code for the main program and then link the contents of the object file into the executable program together with procedures from a library using the -L./ -lstrconv to tell the compiler that the location of the library is in the current directory and the library file is libstrconv.a shortened to -lstrconv which is the standard way of writing it. When this has been successfully completed we just type the name of the executable program in a terminal window to run it. 36

37 Optimization As the programs grow larger and the datasets we are using are increasing in size we have to make our program work as fast as possible. This is not an easy task to do on our own, but we shall look at some small things that we can do to optimize our code. The following items will help us to make the code run faster. Use the compiler options for optimizing the code Be sure to traverse matrices the correct way according to the programming language. Put all tests and calculations outside loops when it is possible Do all assignment of a value to a variable only once if it will not change while running the program. One of the compiler flags mostly used for optimization is the On wher n is the level of optimization. For most compilers O3 it the highest level of optimization. Note that in some cases where the code consists of several hundred thousand of lines this level of optimization can cause problem because of the size of the code. A last advice is to learn the various options your compiler offers and use it to make your pgorgam run faster. 37