Computational Techniques I

Size: px

Start display at page:

Download "Computational Techniques I"

Dennis Peters
5 years ago
Views:

1 Computational Techniques I Course Zero Madrid Alicia Palacios, alicia.palacios@uam.es Cristina Sanz Sanz, cristina.sanz@uam.es

2 Outline 1. Introduction: how to run, input 2. Data types 3. Declaration statement 4. Arrays and matrices 5. Operators 6. Input/output statements 7. Formatted variables 8. Program control: IF statements and DO loops 9. Indexed variables 10. Subprograms 11. Libraries 12. Makefiles

3 9) Working with indexed variables:

4 Index variables: Reading and writing Element by element: 1) In line: read(15,*) a(1,1),a(1,2),a(1,3),a(2,1),a(2,2),a(2,3) 2) Using a do cycle: do 10 i = 1, n do 20 j = 1, m read(15,*) a(i,j) 20 end do 10 end do

5 Index variables: Reading and writing By rows or columns: 1) Using implicit do-cycles: do i = 1, n read(15,*) (a(i,j), j = 1, m)! implicit do-cycles end do 2) Direct read: do i = 1, n read(15,*) a(i,:)! reads as many as its dimension end do

6 Index variables: Reading and writing By blocks: 1) Using implicit do-cycles: read(15,*) ((a(i,j), j = 1, m), i= 1, n) 2) Direct read: read(15,*) a(:,:) The same can be used for the write directive

7 Index variables: Reading and writing Element by element Input files: input.dat input2.dat Output of program:

8 Index variables: Reading and writing By rows or columns or blocks Input file: input3.dat Output of program:

9 Index variables: Reading and writing Blocks with implicit do s Input file: input3.dat Output of program:

10 Index variables: Reading and writing In classroom practice 1 (10 minutes) 1) Using the input files input1.dat, input2.dat, input5.dat practice the reading and writing directives. 2) Try the different forms of reading/writting to learn the subtle differences between them. 3) Using input3.dat and the direct read by blocks (read(16,*) a(:,:)) answer the next question: Has the direct reading read by rows or columns?

11 Index variables: numerical operations and intrinsic functions With specific elements: a(1,3) = 1.0 exp(z(3)) Operations with elemental intrinsic functions: real(kind=8), dimension(5,5) :: a,b,c b = exp(a) It is equivalent to : do 20 i=1,5 do 10 j=1,5 b(i,j) = exp( a(i,j)! b and a are properly defined 10 enddo 20 enddo

12 Index variables: numerical operations and intrinsic functions With specific elements: a(1,3) = 1.0 exp(z(3)) Operations with elemental intrinsic functions: real(kind=8), dimension(5,5) :: a,b,c b = exp(a) Using sections: real(kind=8), dimension (5,5) ::a real(kind=8), dimension (5) :: z a(1,2:4) = 1.0 exp((z(2:4)) It is equivalent to : do 20 i=1,5 do 10 j=1,5 b(i,j) = exp( a(i,j)! b and a are properly defined 10 enddo 20 enddo It is equivalent to : do k = 2, 4, 1 a(1,k) = exp(z(k)) enddo

13 Miscellaneous statements: ALLOCATABLE arrays Example integer :: natom,i,j, error character(len=4), dimension(:),allocatable :: name_atom real(kind=8), dimension(:,:),allocatable :: coor open (11,file= bf3.xyz,action= read ) read (11,*)natom read (11,*) allocate (name_atom(natom)) allocate (coor(natom,3)) do i=1,natom read (11,*,end=20),name_atoms(i),(coor(i,j),j=1,3) 20 end do... deallocate (name_atoms) deallocate (coor) Very useful avoiding overuse of memory allocating arrays when necessary, in the above example after reading dimension from a file

14 Miscellaneous statements: ALLOCATABLE When the array/string/ dimensions are only known during the execution of the program those can be declare as: Declaration/definition (statement/atribute allocatable): real(kind=8), dimension(:,:), allocatable :: din_mat Allocation of memory (allocate): allocate(din_mat(5,5)) Deallocation of memory (deallocate): deallocate(din_mat) Checking the status, by using the function allocated: if (.not.allocated(din_mat)) allocate(din_mat(5,5))

15 Miscellaneous statements: ALLOCATABLE In classroom practice 2 (10 minutes) Use the input5.dat and write a program that: 1) counts the number of elements in the input file, 2) allocate a matrix/vector to store the elements, 3) writes the square root of each element of the matrix/vector.

16 Intrinsic functions

17 Intrinsic functions: Array function SUM SUM (ARRAY, dim, mask) returns the sum of all the elements in the array ARRAY, of those that obey the relation in the third argument MASK if that one is given, along only the desired dimension if the second argument DIM is given. Output of program:

Intrinsic functions: Array function PRODUCT PRODUCT(ARRAY, dim, mask) returns the product of all the elements in the array ARRAY, of those that obey

18 Intrinsic functions: Array function PRODUCT PRODUCT(ARRAY, dim, mask) returns the product of all the elements in the array ARRAY, of those that obey the relation in the third argument MASK if that one is given, along only the desired dimension if the second argument DIM is given. Output of program:

Intrinsic functions: Vector and matrix multiplication DOT_PRODUCT(VECTOR_A, VECTOR_B) makes a scalar product of two vectors, which must have the same length (same number of

19 Intrinsic functions: Vector and matrix multiplication DOT_PRODUCT(VECTOR_A, VECTOR_B) makes a scalar product of two vectors, which must have the same length (same number of elements). MATMUL(MATRIX_A, MATRIX_B) makes the matrix product of two matrices, which must be consistent, i.e. have the dimensions like (M, K) and (K, N). Output of program:

20 Intrinsic functions: Array manipulation TRANSPOSE (MATRIX) transposes a matrix, which is an array of rank 2. It replaces the rows and columns in the matrix. Output of program:

Intrinsic functions: Array inquiry functions SIZE(ARRAY, dim) is a function which returns the number of elements in an array ARRAY, if DIM is not given, and the number

21 Intrinsic functions: Array inquiry functions SIZE(ARRAY, dim) is a function which returns the number of elements in an array ARRAY, if DIM is not given, and the number of elements in the relevant dimension if DIM is included. SHAPE(SOURCE) is a function which returns the shape of an array SOURCE as an integer vector. Output of program:

22 Intrinsic functions In classroom practice 3 (10 minutes) Write a program that: 1) Reads from a file a vector and a matrix and store them in allocatable arrays. 2) Obtain the dot product of the vector with itself. 3) Obtain the matrix product of the matrix with itself. 4) Write the solution into an output file.

23 10) Subprograms:

24 Subprograms and program units Two types of subprograms: the function and the subroutine. Function: takes arguments, and return a single value. Subroutine: may take arguments, and may return several values. Three types of program units: Main program: each application needs to have exactly one main-program, where execution begins and ends Internal/External subprograms: can be either functions or subroutines. Subprograms correspond to different subtasks of the overall algorithm, and they can be invoked from the main-program, or even from other subprograms. Modules: These are general containers, which can encapsulate data, definitions of derived types, namelist-group, interfaces, or module subprograms.

25 Functions or subroutines? Number or entities to be returned: Only one entity to be returned from subprogram No values returned or more than one (or or > 1) FUNCTION SUBROUTINE Convenience of calling: FUNCTION can simply appear as part of an expression SUBROUTINE needs to be called on a separate line. Programming convention: avoiding side effects improving the readability: 1) Modification of procedure arguments. 2) Modification of data external to the procedure. 3) Saved variables. 4) Including stop-statements. 5) Performing I/O on units external of the procedure. 6) Calling other procedures with side effects.

26 Functions or subroutines? Functions Can appear as parts of more complicated expressions. The returned value has to be stored in a variable of the same type. Argument and result type may be scalar, string, array and subprogram. Subroutines Subroutines are invoked with an explicit call-statement, on a separate line. Arguments and results, if there are any, may be scalar, string, array and subprogram.

27 Subprograms of type function Function call in the main program: name_of_variable = name_of_function(argument_list) type function name_of_function(argument_list) [Declaration statements] [Executable statements] Dummy arguments name_of_function = expr RETURN! Not necessary END function [name_of_function] Note: Dummy arguments must maintain order and type Extra local variables can be used

28 Subprograms of type function Example real(kind=8) function dist (r1, r2) implicit none real(kind=8), intent(in), dimension(3) :: r1, r2!raux = auxiliary vector real(kind=8), dimension(3) :: raux raux(:) = r1(:) r2(:) dist = sqrt(dot_product(raux(:),raux(:))) return end function dist Function call: integer, parameter :: Natom=100! Matrix of coordinates real(kind=8), dimension(natom,3) :: r_c real(kind=8) :: d45!distance between atoms 4 and 5 d45 = dist(r_c(4,1:3),r_c(5,1:3))

29 Subprograms of type subroutine Subroutine call in the main program: CALL subroutine_name (argument_list)! Dummy arguments subroutine [name_of subroutine] (argument list) [Declaration statements] [Executable statements] Dummy arguments return! Not necessary, but advisable end subroutine [name_of subroutine] Note: Dummy arguments must maintain order and type Other local variables can be used

30 Subprograms of type subroutine: INTENT The statement INTENT tells the compiler how to use each dummy argument. subroutine name_subroutine(nf,nc,nout) integer, intent(in) :: nf integer, intent(inout) :: nc integer, intent(inout) :: nc Options: IN : subroutine takes the value from a formal argument and does not change its content. OUT : is a result; the value is not defined before the call to the subroutine and have to be stablish before leaving the soubroutine by using the statement return. INOUT : is both, an input data at the beginning of the execution and a result at the end of it.

31 Subprograms of type subroutine Example subroutine mat_wrt(a,nr,nc) implicit none! coments! It writes a matrix in unit 16 (mat_wrt.out)! a : matrix! nf, nc : number of rows and columns!! statements to declare arguments real(kind=8),dimension(nr,nc),intent(in) :: a integer, intent(in) :: nr, nc! statements to declare local variables integer :: i,j! open a file open(16, file = mat_wrt.out )! to write by rows do i= 1,nr write(16, (a12,1x,i4) ) Row number:, i write(16, (6(1x,E11.4)) ) (a(i,j), j=1,nc) end do! close the file and return close(16) return end subroutine mat_wrt

32 Subprograms In classroom practice 4 (15 minutes) 1) Write a subprogram (function or subroutine) that: a) Receives as arguments a real number and a real square matrix. b) The subprogram must return a matrix whose diagonal elements have been multiplied by the real number. 2) Write a main program that calls the subprogram and writes the matrix in an output file. Hint 1: Create two different files, one for the subroutine and one for the main program. Hint 2: How to compile: gfortran main_program.f90 subprogram.f90 -o myprog.exe

33 Where are the subprograms placed? As external subprograms: usually in a different file, interface statement As internal subprogram: same file, contains statement

34 External subprograms: INTERFACE Let s consider the subroutine mat_wrtt subroutine mat_wrt(a,nr,nc) implicit none! coments! Writes in unit 16 matrix a(mat_wrt.out)! a : matrix! nf, nc : number of rows and columns!! statements to declare arguments real(kind=8),dimension(nr,nc),intent(in) :: a integer, intent(in) :: nr, nc! statements to declare local variables integer :: i,j! open a file open(16, file = mat_wrt.out )! to write by rows do i= 1,nr write(16, (a12,1x,i4) ) Row number:, i write(16, (6(1x,E11.4)) ) (a(i,j), j=1,nc) end do! close the file and return close(16) return end subroutine mat_wrt To use the external subroutine we must define it in an interface statement: interface subroutine mat_wrt(a,nf,nc) implicit none integer, intent(in) :: nf, nc real(kind=8),dimension(:,:),intent(in) :: a end subroutine mat_wrt end interface

35 External subprograms: INTERFACE Output of program

36 Internal subprograms Internal subprograms: main-programs, external subprograms, and module subprograms can contain internal subprograms. For these, the contains-keyword needs to be added, on a line of its own, after the last executable statement of the host (sub)program. Then, the internal subprogram can be added between this line and the end program(/function/subroutine)-line of the host. Main program general syntax is: [PROGRAM name_of_program] [Declaration statements] [Executable statements]! It includes calls to subroutines [CONTAINS internal subprograms ] END [name_of_program] Example: PROGRAM test implicit none real, double precision(5,5) :: & a,b,c! Declaration statements integer, k,l,m! Executable statements call srint!call to a internal subroutine call srext_1!call to external subroutines call srext_2 CONTAINS subroutine srint end subroutine srint END PROGRAM test

37 What do we know (so far) about the structure of a program? I. We must have a main program II.We might have subprograms: placed in external files or contained in the same file What if our program gets big with a very long main program and loads of subroutines? How do think that the code can be arranged to make it easy to read? Fortran has two ways to ensemble code MODULES & LIBRARIES

38 Modules and Libraries What is the main difference between modules and libraries? Modules are compiled at the same time as the rest of code Libraries are precompiled and liked to the rest of code in the compilation

39 Modules Modules: external files that group items related to a particular task. Items which can be packaged in a module are: global data subprograms interface-blocks namelist-groups derived type definitions Modules syntax is: In the main program: module name_module [declaration statements] contains subprograms of the module] end [name_module] PROGRAM [name] use name_module implicit none [declaration statements] [executable statements] call subprogram END PROGRAM How to compile: gfortran module.f90 main_program.f90 -o myprog.exe

40 Modules: PUBLIC/PRIVATE All global entities of a module, by default, can be accessed by a program or another module using the USE statement. It is possible to set some restrictions that some entities are private. A private entity of a module can only be accessed within that module. Entities can explicitly be listed to be access from outside as well. Module Acessing module Compilation gfortran module.f90 main.f90 -o myprog.exe

41 Modules: Example Module with public subroutines to sort a vector of dimension n in ascending and descending order. Module contains as well private functions that return the highest and the lowest values of the vector. Do you think that we can call the private subroutines contained in the module sort?

42 Modules: Example Call from the main program:

43 Modules: other uses Define types: module MoleculeDef type atom character(len=2) :: name Integer :: Z real :: mass real :: q real, dimension(1:3) :: coord end type atom Define parameters: module constants real, parameter :: c = , pi= integer, parameter :: nxmax=10, nymax=20, nzmax=30 end module constants type molecule Integer :: Natom type(atom), dimension(1:1000) :: At end type molecule end module MoleculeDef

44 Modules In classroom practice 5 (15 minutes) 1) Using the subprogram that you wrote in practice 4 create a module in which the subprogram is public. 2) Add to the module: 2.a) a subroutine/function that receives as arguments a real number and a real square matrix. 2.b) the subprogram must return a matrix whose off-diagonal elements have been multiplied by the real number. 3) Write a main program that uses the module. Hint: How to compile: gfortran module.f90 main_program.f90 -o myprog.exe

45 11) Libraries

46 Libraries Library: collection of precompiled routines that can be used in any program. The routines, are stored in object format. Objects are linked to our program during compilation. An object file is the real output from the compilation phase..o.a: static libraries. Archive of the original.o object files.so: dynamic libraries. The suffix stands for shared object. Libraries are particularly useful for storing frequently used routines.

47 How are libraries created? Libraries: creation and usability Static libraries: gfortran -c subprograms.f90 ar -r libname.a subprograms.o Dynamic libraries: gfortran -fpic -c subprograms.f90 Objects gfortran -shared -o libname.so subprograms.o How do we link a library to our code? gfortran -o main.exe main.f90 -L/path_forlibrary -lname_of_library The linker automatically looks in libraries for routines that it does not find elsewhere.

48 Libraries: linking to main program 1)Divide the module sort.f90 into several files: ascending.f90 descending.f90 low.f90 high.f90 2)Create the library: a)gfortran -c ascending.f90 descending.f90 low.f90 high.f90 b)ar -r libsort.a ascending.o descending.o low.o high.o 3)Rewrite the main program that calles these subroutines: 4)Compile the program linking the library: gfortran -o main-static.exe main.f90 -L./dota -lsort 5)Execute the program:./main-static.exe

49 Libraries: let me introduce you to blas and lapack BLAS: Basis Linear Algebra Subprograms Routines that provide standard building blocks for performing basic vector and matrix operations. Level 1: perform scalar, vector and vector-vector operations Level 2: perform matrix-vector operations Level 3: perform matrix-matrix operations LAPACK: Linear Algebra Package Routines for solving systems of simultaneous linear equations, least-squares solutions of linear systems of equations, eigenvalue problems, and singular value problems. This libraries can be download and installed in most operating systems. They are already installed in these computers. The path where they are installed is: /usr/lib64

50 Libraries: use of a blas function Compilation gfortran -o example10.exe -L/usr/lib64 example10.f90 -lblas

51 Libraries: use of a blas subroutine Compilation gfortran -o example11.exe -L/usr/lib64 example11.f90 -lblas

52 Libraries (timewise...) In classroom practice 6 (15 minutes) 1) Create different files with each of the subprograms of module of practice 5. 2) Create the library. 3) Write a main program that uses the subprograms of the library. 4) Compile and link the library. Help: Static libraries: gfortran -c subprograms.f90 ar -r libname.a subprograms.o Dynamic libraries: gfortran -fpic -c subprograms.f90 Objects gfortran -shared -o libname.so subprograms.o gfortran -o main.exe main.f90 -L/path_forlibrary -lname_of_library

53 12) Makefiles:

54 Command line compilation Example: program abc.f90, and external subroutines a.f90, b.f90 and c.f90. Let s compile these in the usual command-line me thod: > gfortran -o abc.exe abc.f90 a.f90 b.f90 c.f90 If we modify b.f90 the program has to be recompiled: > gfortran -o abc.exe abc.f90 a.f90 b.f90 c.f90 f90 When our program has many modules and subprograms compilation can take long time

55 Makefile A makefile is a file that compiles the code. When changes are made to some of the code, only the updated files need to be recompiled. The code must be linked again to create the new executable. Makefile knows the pieces of a large program that need to be recompiled. Makefile has all the sentences to compile and link the code up. NOTE: The importance of separate the pieces of code in different files: Keeping all program units in a single file obliges a recompilation of the whole code when we do any small change.

56 Makefile structure: Example Makefile example for abc : [Tab] # makefile : makes the ABC program abc : a.o b.o c.o abc.o gfortran -o abc.exe abc.o a.o b.o c.o abc.o : abc.f90 gfortran -O -c abc.f90 a.o : a.f90 gfortran -O -c a.f90 b.o : b.f90 gfortran -O -c b.f90 c.o : c.f90 gfortran -O -c c.f90 clean: rm *.o *~

57 Makefile: important points Since abc depends on the files a.o, b.o and c.o, all of the.o files must exist and be up-to-date. Makefile will recompile those changed from last compilation. Comments: must be delimited by hash marks (#). Continuation character: backslash (\) the end of the line. By default, the first target file appearing in the makefile is the one that is built. The order of the other targets does not matter. Makefile is invoked from the command line typing make (if name of file is makefile ). If filename is not makefile then use: make -f <mymakefile> In the makefile we can define variables. Note that variables names in make are case-sensitive!

58 Makefile example Makefile using module Makefile using dynamic library

59 Makefiles In classroom practice 7 1) Create a makefile to compile the code of practice 6

Review More Arrays Modules Final Review

Review More Arrays Modules Final Review OUTLINE 1 REVIEW 2 MORE ARRAYS Using Arrays Why do we need dynamic arrays? Using Dynamic Arrays 3 MODULES Global Variables Interface Blocks Modular Programming 4 FINAL REVIEW THE STORY SO FAR... Create