Fortran2 - Revision history

GethinWilliams: /* To go further */

2011-03-07T16:16:02Z

To go further

GethinWilliams: /* To go further */

2011-03-07T16:15:25Z

To go further

GethinWilliams: /* To go further */

2011-03-07T16:14:37Z

To go further

GethinWilliams: /* Libraries */

2011-03-07T16:11:22Z

Libraries

GethinWilliams: /* Dealing with modules */

2011-03-07T16:06:49Z

Dealing with modules

GethinWilliams: /* Creating objects and linking them */

2011-03-07T16:01:44Z

Creating objects and linking them

GethinWilliams: /* Invoking the compiler */

2011-03-07T15:51:17Z

Invoking the compiler

GethinWilliams: /* Allocatable Arrays */

2011-03-07T15:46:01Z

Allocatable Arrays

GethinWilliams: /* Assumed Shape Arrays and Optional Arguments */

2011-03-07T15:45:02Z

Assumed Shape Arrays and Optional Arguments

GethinWilliams: /* Modules */

2011-03-01T12:28:53Z

Modules

← Older revision		Revision as of 16:16, 7 March 2011
Line 482:		Line 482:
	That's it for the Fortran tuition. The [[:category:Pragmatic Programming \| Pragmatic Programming]] course continues with a practical about project management using "[[make]]".		That's it for the Fortran tuition. The [[:category:Pragmatic Programming \| Pragmatic Programming]] course continues with a practical about project management using "[[make]]".

−	A useful Fortran textbook is called '''Fortran 90 Programming''' by Ellis, Philips & Lahey. Take a look at the [[A_Good_Read\|'A Good Read?']] for more details.	+	A useful Fortran textbook is called '''Fortran 90 Programming''' by Ellis, Philips & Lahey. Take a look at the [[A_Good_Read\|'A Good Read?']] page for more details.

← Older revision		Revision as of 16:15, 7 March 2011
Line 482:		Line 482:
	That's it for the Fortran tuition. The [[:category:Pragmatic Programming \| Pragmatic Programming]] course continues with a practical about project management using "[[make]]".		That's it for the Fortran tuition. The [[:category:Pragmatic Programming \| Pragmatic Programming]] course continues with a practical about project management using "[[make]]".

−	A useful Fortran textbook is called '''Fortran 90 Programming''' by Ellis, Philips & Lahey. Take a look at the [[A_Good_Read\|~~references page~~]] for more details.	+	A useful Fortran textbook is called '''Fortran 90 Programming''' by Ellis, Philips & Lahey. Take a look at the [[A_Good_Read\|'A Good Read?']] for more details.

← Older revision		Revision as of 16:14, 7 March 2011
Line 482:		Line 482:
	That's it for the Fortran tuition. The [[:category:Pragmatic Programming \| Pragmatic Programming]] course continues with a practical about project management using "[[make]]".		That's it for the Fortran tuition. The [[:category:Pragmatic Programming \| Pragmatic Programming]] course continues with a practical about project management using "[[make]]".

−	A useful ~~reference: [http://www.amazon.co.uk/~~Fortran~~-Programming-International-Computer-Science/dp/0201544466~~ Fortran 90 Programming. Ellis, Philips, Lahey. ~~Addison-Wesley. ISBN 0-201-54446-6~~].	+	A useful Fortran textbook is called '''Fortran 90 Programming''' by Ellis, Philips & Lahey. Take a look at the [[A_Good_Read\|references page]] for more details.

@@ Line 413: / Line 413: @@
 </pre>
-The directory contains a program and a directory called <tt>operations</tt> which we will use to build our first library.
+The directory contains a program ('''main_program.f90''') and a directory called '''operations''' which we will use to build our first library.
 <pre>
@@ Line 421: / Line 421: @@
 </pre>
-The <tt>operations</tt> directory contains two Fortran files. They are actually modules and contains a set of functions that can be used to perform arithmetic operations. Have a look at them and then compile the two files to create the objects and module files.
+The operations directory contains two Fortran files. They are actually modules and contains a set of functions that can be used to perform arithmetic operations. Have a look at them and then compile the two files to create the objects and module files.
-The two object files can then be archived in a library with the command <tt>ar</tt> for <b>ar</b>chive:
+The two object files can then be archived in a library with the command '''ar''' for <b>ar</b>chive:
 <pre>
@@ Line 430: / Line 430: @@
 </pre>
-Note the "r" argument which means replace. You could call the library whatever you want. However, using the <tt>lib</tt> prefix will make the library easier to link to later on.
+Note the "r" argument which means replace. You could call the library whatever you want. However, using the '''lib''' prefix will make the library easier to link to later on.
-At this stage, the object files are not required anymore and could be deleted. However, you need to keep the library and the module files.
+At this stage, the object files are not required anymore and could be deleted.  However, you need to keep the library and the module files.
 Now we will go back to the main program and create an object for it.
@@ Line 448: / Line 448: @@
 </pre>
-Then we need to link the newly created object to the library that was created earlier on. The simpliest method is to give the full path of the library to the compiler:
+Then we need to link the newly created object to the library that was created earlier on. The simplest method is to give the full path of the library to the compiler:
 <pre>
@@ Line 461: / Line 461: @@
 Note that in the example above, the compiler will look for the library "liboperations.a" in the folder "./operations". If more than one library was required, you would have to specify them one after the other: "-llib1 -llib2 ..."
-That's all you need to know about creating libraries. One important thing to remember is that Fortran programs will require both library and module files. Sometimes they are not kept in the some location and often the module files are kept in a directory called <tt>include/</tt> and the libraries in a directory called <tt>lib/</tt>. This is the case for the netCDF example that follows.
+That's all you need to know about creating libraries. One important thing to remember is that Fortran programs will require both library and module files.  Sometimes they are not kept in the some location and often the module files are kept in a directory called <tt>include/</tt> and the libraries in a directory called <tt>lib/</tt>.  This is the case for the NetCDF example that follows.
 Some useful third party libraries include:

@@ Line 373: / Line 373: @@
 ==Dealing with modules==
-In this section we look at what happens when modules are used. The required files are in the directory called <tt>module</tt>.
+In this section we look at what happens when modules are used. The required files are in the directory called '''module'''.
 <pre>
@@ Line 379: / Line 379: @@
 </pre>
-This directory contains two files containing a main program unit and a module. Have a look at the files, compile them and create an executable.
+This directory has two files; one containing a main program unit; and another containing a Fortran module.  Have a look at the files, compile them and create an executable.
-After the module is compiled, you might have noticed that a new file has been created in the directory with the extension <tt>.mod</tt>. This file contains information about the module and when the compiler notices that a module is required, it will use this file to get the information. Therefore, this file is necessary when you compile any source file using the module. You can check it by deleting it and trying to compile the other file again.
+After the module is compiled, you might have noticed that a new file has been created in the directory with the extension '''.mod'''. This file contains information about the module and when the compiler notices that a module is required, it will use this file to get the information. Therefore, this file is necessary when you compile any source file using the module. You can check it by deleting it and trying to compile the other file again.
 <b>Note:</b> If you change the module significantly but don't recompile the file that uses the module, you might get problems as the module file that was used to create the object is out of date. So the object should be recreated too.
-By default, the compiler looks for the module files in the current directory. However, it is quite usual that some modules are stored elsewhere. For instance create a directory called <tt>include/</tt>, move the module file into it and then compile the program... you should get an error.
+By default, the compiler looks for the module files in the current directory. However, it is quite usual that some modules are stored elsewhere. For instance create a directory called '''include/''', move the module file into it and then compile the program... you should get an error.
 <pre>
@@ Line 396: / Line 396: @@
 </pre>
-Luckily, it is possible to tell the compiler to include another directory in its search. This is done with the option <tt>-I</tt> for <b>include</b>.
+Luckily, it is possible to tell the compiler to include another directory in its search. This is done with the option '''-I''' for <b>include</b>.
 <pre>

@@ Line 320: / Line 320: @@
 ==Creating objects and linking them==
-First of all, let's see how to put a subroutine in a separate file. In the <tt>subroutine</tt> folder you will find a basic Fortran program in the file <tt>onefile.f90</tt>. It contains a main program unit and a subroutine.
+First of all, let's see how to put a subroutine in a separate file. In the '''subroutine''' directory you will find a basic Fortran program in the file '''onefile.f90'''. It contains a main program unit and a subroutine.
 <pre>
@@ Line 334: / Line 334: @@
 The content of this small Fortran program has also been split into two separate files:
-* one for the main program unit (<tt>main_program.f90</tt>)
+* one for the main program unit, '''main_program.f90'''
-* one the subroutine (<tt>sub1.f90</tt>).
+* one the subroutine, '''sub1.f90'''.
 If you invoke the compiler on either of these files, it will complain that something is missing. Try it to see the two types of error messages.
-The reason for this is that (i) the main program needs the definition of the subroutine; and (ii) a Fortran program needs a main program unit so neither file is enough on its own. Luckily, you can also invoke the compiler on the two files at the same time.
+The reason for this is that; (i) the main program needs the definition of the subroutine; and (ii) a Fortran program needs a main program unit so neither file is enough on its own. Luckily, you can also invoke the compiler on the two files at the same time.
 <pre>
@@ Line 345: / Line 345: @@
 </pre>
-It works! (and note that the order of the files does not matter). By giving two files as arguments to the compiler, it is clever enough to understand that there might be dependencies between the files and it takes care of them automatically.
+It works! (Note that the order of the files does not matter.)  By giving two files as arguments to the compiler, it is clever enough to understand that there might be dependencies between the files and it takes care of them automatically.
-The problem with this approach is that if the subroutine is modified, the main program will also have to be recompiled to generate the executable. This would be a issue for larger Fortran programs because it would be time consuming. We will also see later on that we might want to included external subroutines contained in a library and to which the source code is not available.
+The problem with this approach is that if the subroutine is modified, the main program will also have to be recompiled to generate the executable. This would be a issue for larger Fortran programs because it would be time consuming.  We will also see later on that we might want to included external subroutines contained in a library and to which the source code is not available.
-Instead, it is possible to ask the compiler to compile a file and "ignore" the dependencies. By doing this, the compiler creates an object file (usual extension <tt>.o</tt>) which contains all the information needed to create an executable minus the actual dependencies. This is done by using option <tt>-c</tt> for "<b>c</b>ompile only".
+Instead, it is possible to ask the compiler to compile a file and "ignore" the dependencies.  By doing this, the compiler creates an object file (usual extension '''.o''') which contains all the information needed to create an executable minus the actual dependencies. This is done by using option '''-c''' for "<b>c</b>ompile only".
 <pre>
-$ gfortran main_program.f90 -c
+$ gfortran -c main_program.f90
-$ gfortran sub1.f90 -c
+$ gfortran -c sub1.f90
 </pre>
-Check that two new files have been created. By default, they should be named like the source file but with a <tt>.o</tt> extension. Again, this default behaviour could be changed with the option <tt>-o</tt>.
+Check that two new files have been created. By default, they should be named like the source file but with a '''.o''' extension. Again, this default behaviour could be changed with the option '''-o'''.
 Then the two objects have to be linked together to create an executable file. This is done by invoking a the compiler on the object files:
@@ Line 366: / Line 366: @@
 This might seem like an extra step compared to the previous method but the advantage of this method is that you can modify one file independently of the other, re-create the object for the modified file only and then link the objects together. If you have many files in your project, that would save a significant amount of time.
-Try to do it.
+Try it.
 <b>Note 1:</b> Although you can modify the files independently, they still need to make sense in terms of Fortran syntax. For instance, if you add an argument to the subroutine but don't modify the main program unit, the program might not work as expected.

@@ Line 300: / Line 300: @@
 $ ls -rtl
 total 420
--rw-r--r-- 1 ggjpr uucp     93 Mar  3 20:39 hello_world.f90
+-rw-r--r-- 1 fred users     93 Mar  3 20:39 hello_world.f90
--rwxr-xr-x 1 ggjpr uucp 411750 Mar  3 20:41 a.out
+-rwxr-xr-x 1 fred users 411750 Mar  3 20:41 a.out
 </pre>
-Try to execute the file <tt>a.out</tt> (remember to include the current directory in your call, i.e. <tt>./a.out</tt>). Also note the size difference between the source file and the executable. Source files take up a lot less room.
+Try to execute the file '''a.out''' (remember to include the current directory in your call, i.e. '''./a.out'''). Also note the size difference between the source file and the executable. Source files take up a lot less room.
-The compiler could be invoked with many options to check differents aspects of the fortran syntax, to control what types of warnings to issue, to perform various optimisations of the code or to  create debugging information. We will not go into details in this practical so refer to the compiler documentation if you want more information.
+The compiler could be invoked with many options to check aspects of the Fortran syntax; to control what types of warnings are issued; to perform various optimisations of the code or to create debugging information.  We will not go into details in this practical so refer to the compiler documentation if you want more information (try '''man gfortran''').
-If you modify the source file, you need to recompile it before executing <tt>a.out</tt> for your changes to take effect.
+If you modify the source file, you need to recompile it before executing a.out for your changes to take effect.
-The first compiler option we will be using is used to change the name of the executable file. This is done with the option <tt>-o</tt> followed by the name required:
+The first compiler option we will be using is used to change the name of the executable file. This is done with the option '''-o''' followed by the name required:
 <pre>

@@ Line 14: / Line 14: @@
 =Allocatable Arrays=
-We'll begin by looking at '''allocatable arrys'''.
+We'll begin by looking at '''allocatable arrays'''.
 Previously, we declared the size of our arrays when we wrote our code.  This is all well and good, and at least we knew where we stood.  However, this exact specification of the shape of all things can become a painful limitation.  Suppose you were writing a program to process a list of University employees.  The number of employees will almost certainly vary from one month to the next.  So, we can only know the number of records to read in at '''runtime'''.  This sort of thing starts to crop up a lot when we aim to write more general-purpose, flexible & robust programs.

@@ Line 112: / Line 112: @@
    ! fill out the values
    do ii=1,extent
-      coords(ii) = (real(ii)*real(delta)) - (real(delta)/2.0) + offset
+      coords(ii) = (real(ii)*delta) - (delta/2.0) + offset
    end do

← Older revision		Revision as of 12:28, 1 March 2011
Line 262:		Line 262:

	This signals the end of the variables and the start of the definitions of any routines (subroutines or functions) that we've elected to put into our module. In this case we have three subroutines for '''initialising''', '''time-stepping''' and '''finalising''' our model, respectively. The routines contain code constructs that we have seen in previous examples. It's worth studying the error checks, use of external files, memory allocation and deallocation and the syntax for accessing elements of a derived type, just as a refresher.		This signals the end of the variables and the start of the definitions of any routines (subroutines or functions) that we've elected to put into our module. In this case we have three subroutines for '''initialising''', '''time-stepping''' and '''finalising''' our model, respectively. The routines contain code constructs that we have seen in previous examples. It's worth studying the error checks, use of external files, memory allocation and deallocation and the syntax for accessing elements of a derived type, just as a refresher.
		+
		+	[[Image:fortran-module.jpg\|300px\|thumbnail\|centre\|a fortran module.]]

	OK, so much for the module, now let's look at a program which uses it--'''prog.f90'''.		OK, so much for the module, now let's look at a program which uses it--'''prog.f90'''.