Introduction to Fortran

Doug Sondak
SCV
sondak@bu.edu
Information Services & Technology 08/14/2024

Outline
Boston University Slideshow Title Goes Here

 Goals
 Introduction
 Fortran History
 Basic syntax
 Makefiles
 Additional syntax

2
Information Services & Technology 08/14/2024

Goals
Boston University Slideshow Title Goes Here

 To be able to write simple Fortran programs

 To be able to understand and modify existing Fortran
code
 To be able to manage programming projects using
makefiles

3
Information Services & Technology 08/14/2024

Introduction
Boston University Slideshow Title Goes Here

 Matlab is great! Why do I need to learn a new

language?!
 All codes must be translated to machine language
 Interpreted language
 Matlab, Python, Java
 Translation is performed incrementally at run time
 Compiled language
 Fortran, C, C++
 Translation is performed once, then executable is run

4
Information Services & Technology 08/14/2024

Introduction (cont’d)
Boston University Slideshow Title Goes Here

 Compiled languages run faster

 I translated a program from Matlab to C for a user, and it ran 7 times
as fast (your results may vary!)
 Large-scale computing is usually done with compiled language
 Some convenient features of interpreted languages
(e.g., no need to declare variables) result in
performance and/or memory penalties

5
Information Services & Technology 08/14/2024

Fortran History
Boston University Slideshow Title Goes Here

 Before Fortran, programs were written in assembly

language
 low-level commands such as “load x from memory into register 7” or
“add values in registers 10 and 11 an write result to register 4”
 Fortran was the first widely-used high-level computer
language
 1957
 Developed by IBM for scientific applications

6
Information Services & Technology 08/14/2024

Fortran History
Boston University Slideshow Title Goes Here

 Fortran 66 (1966)
 Fortran 77 (1978)
 Fortran 90 (1991)
 “fairly” modern (structures, etc.)
 Current “workhorse” Fortran
 Fortran 95 (minor tweaks to Fortran 90)
 Fortran 2003
 Gradually being implemented by compiler companies
 Object-oriented support
 Interoperability with C is in the standard (yay!)

7
Information Services & Technology 08/14/2024

What Language Should I Use?

Boston University Slideshow Title Goes Here

 I usually suggest using the language you know best

 Interpreted languages are great for many applications,
but are not a good choice for major number crunching
 Researchers often write codes in Matlab, and they grow and grow
until they are much too slow (the codes, not the researchers)
 Then a painful translation is often required

8
Information Services & Technology 08/14/2024

What Language? (cont’d)

 Fortran is hard to beat for performance
Boston University Slideshow Title Goes Here
 C has the potential to be as fast as Fortran if you avoid
aliasing issues and promise the optimizer you have
done so
 Fortran doesn’t have this issue due to the different
nature of its pointers
 I have not written large C++ codes, but it’s to my
understanding that object-oriented constructs tend to
be slow
 Suggestion – write computationally-intensive codes in
Fortran or C
 Can parallelize using MPI and/or OpenMP

9
Information Services & Technology 08/14/2024

Fortran Syntax
 Program is contained in a text file
Boston University Slideshow Title Goes Here

 called source code or source file

 Source code must be processed by a compiler to
create an executable
 Source file suffix can vary, but we will always use .f90
 Since source file is simply text, can be written using
any text editor
 usually emacs or vi

10
Information Services & Technology 08/14/2024

Fortran Syntax (cont’d)

Boston University Slideshow Title Goes Here

 First statement in code is program statement

 Followed by program name
program myprog (first line in source code)
 I like to give the source file the same name as the program
myprog.f90 (name of source file)
 Last statement is a corresponding end program
 also followed by program name
end program myprog

11
Information Services & Technology 08/14/2024

Fortran Syntax (3)

Boston University Slideshow Title Goes Here

 Variables have types

 For now, we’ll look at 3 types: real, integer, and
character
 Real variables have decimals
 Real can be a whole number, but decimal places are stored internally
 Even when a real is a whole number, it’s good practice to write one
decimal place
3.0 rather than 3

12
Information Services & Technology 08/14/2024

Fortran Syntax (4)

 Integer variables do not have decimals
Boston University Slideshow Title Goes Here

 Integer arithmetic is truncated, not rounded

3/2 = 1
2/3 = 0
 If these were reals, results would be
3.0/2.0 = 1.5
2.0/3.0 = 0.6666667
 Character variables contain literal text
 enclosed in single quotes
‘T’
 Character strings contain groups of characters
‘This is a character string.’

13
Information Services & Technology 08/14/2024

Fortran Syntax (5)

Boston University Slideshow Title Goes Here

 Need to declare the type for every variable

real :: velocity, mass, pi
integer :: imax, jdim
character :: p
 Due to backward compatibilty with obsolescent
Fortran 77, always use the line
implicit none
 This promises the compiler that you will declare all variables
 Always goes directly after program statement with one exception that
we’ll cover later
 Fortran 77 would automatically type variables based on first letter of
variable name

14
Information Services & Technology 08/14/2024

Fortran Syntax (6)

Boston University Slideshow Title Goes Here

 Comment character is !
 Anything to the right of a comment character on a given line will be
ignored by the compiler
 Use comments liberally to document your source code
 print*
 “list-directed” output
 Simple way to produce output on the screen
 Follow by comma, then stuff to print
print*, ’This is my character string.’

15
Information Services & Technology 08/14/2024

Fortran Syntax (7)

Boston University Slideshow Title Goes Here

 Not case-sensitive
 Ampersand at end of line tells compiler that statement
is continued on next source line
 Spaces don’t matter except within literal character
strings
 I use them liberally to make code easy to read, e.g., before and after
equals signs
 Note that source lines do not end with semicolons (as
in C or Matlab)

16
Information Services & Technology 08/14/2024

Exercise 1
Boston University Slideshow Title Goes Here

 Write a “hello world” program in an editor

 Program should print a character string
 4 lines of code
 Save it to a file name with a .f90 suffix
 solution

17
Information Services & Technology 08/14/2024

Compilation
Boston University Slideshow Title Goes Here

 A compiler is a program that reads source code and

converts it to a form usable by the computer
 Internally, three steps are performed:
 compiler translates source code to assembly language
 assembler translates assembly language to machine language
 linker gathers machine-language modules and libraries
 All these steps sometimes loosely referred to as “compiling”

18
Information Services & Technology 08/14/2024

Compilation (cont’d)
Boston University Slideshow Title Goes Here

 Code compiled for a given processor will not generally

run on other processors
 AMD and Intel are compatible
 On katana we have Portland Group compilers (pgf90)
and GNU compilers (gfortran)
 We’ll use pgf90, since it usually results in faster-
executing code
 PGI Fortran reference is at http://www.pgroup.com/doc/pgifortref.pdf

19
Information Services & Technology 08/14/2024

Compilation (3)
Boston University Slideshow Title Goes Here

 Compilers have huge numbers of options

 See PGI compiler documentation at
http://www.pgroup.com/doc/pgiug.pdf
 For now, we will simply use the –o option, which allows
you to specify the name of the resulting executable

20
Information Services & Technology 08/14/2024

Compilation (4)
Boston University Slideshow Title Goes Here
 In a Unix window:
pgf90 –o hello hello.f90
 Emacs users may find this convenient:
 CTL-x 2 will split the window horizontally
 CTL-x o toggles between windows
 “o” stands for “other”
 M-x will prompt for a command at the bottom of the window
 Type “shell” (no quotes) for the command
 Half of emacs window will now be a Unix shell, so you can do
your compilation there
 In a normal Unix tcshell you can retrieve previous Unix
commands with the up arrow; here it’s CTL up arrow

21
Information Services & Technology 08/14/2024

Compilation (5)
Boston University Slideshow Title Goes Here

 Compile your code

 If it simply returns a Unix prompt it worked
 If you get error messages, read them carefully and see
if you can fix the source code and re-compile
 Once it compiles correctly, type the executable name
at the Unix prompt, and it will print your string

22
Information Services & Technology 08/14/2024

Arithmetic
Boston University Slideshow Title Goes Here

 +, -, *, /
 ** indicates power
2.41.5 2.4**1.5
 Built-in math functions such as sin, acos, exp, etc.
 argument in parentheses
sin(0.6)
 Exponential notation indicated by letter “e”
4.2 10 3 4.2e3

23
Information Services & Technology 08/14/2024

More List-Directed i/o

Boston University Slideshow Title Goes Here

 read* is list-directed read, analogous to print*

 Follow with comma, then comma-delimited list of
variables you want to read
read*, x, j
 Often use list-directed read and write together
print*, ‘Enter a float and an integer:’
read*, x, j
print*, ‘float = ‘, x, ‘ integer = ‘, j

24
Information Services & Technology 08/14/2024

Exercise 2
Boston University Slideshow Title Goes Here

 Write program to prompt for a Celcius temperature,

convert it to Fahrenheit, and print the result.
 make sure you declare all variables
 use decimal points with all reals, even if they’re whole numbers

F = (9/5)C + 32
 solution

25
Information Services & Technology 08/14/2024

Arrays
Boston University Slideshow Title Goes Here

 Specify static dimensions in declaration:

real, dimension(10,3,5) :: x
integer, dimension(10) :: i
 Can also specify ranges of values
integer, dimension(3:11, -15:-2) :: ival, jval
 Access array elements using parenthesis
a = y(3) + y(4)

26
Information Services & Technology 08/14/2024

Arrays (cont’d)
Boston University Slideshow Title Goes Here

 Dynamic allocation
 Useful when size is not known at compile time, e.g., input value
 Need to specify no. dimensions in declaration
 Need to specify that it’s an allocatable array
real, dimension(:,:,:), allocatable :: x, y
 allocate function performs allocation
allocate( x(ni,nj,nk), y(ldim,mdim,ndim) )
 When you’re done with the variables, deallocate
deallocate(x, y)
 not necessary at very end of code; Fortran will clean them up for
you

27
Information Services & Technology 08/14/2024

Parameters
Boston University Slideshow Title Goes Here

 If variable has known, fixed value, declare as

parameter and initialize in declaration
integer, parameter :: idim = 100, jdim = 200
 Compiler substitutes values wherever variables appear in code
 Efficient, since there are no memory accesses
 Often used for declaring arrays
integer, parameter :: idim = 100, jdim = 200
real, dimension(idim, jdim) :: x
integer, dimension(idim) :: iarray

28
Information Services & Technology 08/14/2024

Exercise 3
 Write program to prompt for 2 floating-point vectors of
Boston University Slideshow Title Goes Here

length 3, calculate the dot product, and print the result

 Don’t name the code “dot_product” or “dot”
 Fortran has a “dot_product” intrinsic function
 there is a Unix command called “dot”
 Can use array name in list-directed read, and it will
expect the appropriate number of values
(dimension) separated by spaces
3
 solution c  ai bi
i 1

29
Information Services & Technology 08/14/2024

Control
Boston University Slideshow Title Goes Here

 Do loop repeats calculation over range of indices

do i = 1, 10
a(i) = sqrt( b(i)**2 + c(i)**2 )
enddo
 Can use increment that is not equal to 1
 Goes at end of do statement, unlike Matlab
do i = 10, -10, -2

30
Information Services & Technology 08/14/2024

Exercise 4
Boston University Slideshow Title Goes Here

 Modify dot product program to use a do loop

 Declare scalar real variable to hold the summation
 Initialize it to zero before the do loop
 solution

31
Information Services & Technology 08/14/2024

If-Then-Else
Boston University Slideshow Title Goes Here

 Conditional execution of block of source code

 Based on relational operators
< less than
> greater than
== equal to
<= less than or equal to
>= greater than or equal to
/= not equal to
.and.
.or.

32
Information Services & Technology 08/14/2024

If-Then-Else (cont’d)
Boston University Slideshow Title Goes Here

if( x > 0.0 .and. y > 0.0 ) then

z = 1.0/(x+y)
elseif ( x < 0.0 .and. y < 0.0) then
z = -2.0/(x+y)
else
print*, ’Error condition’
endif

33
Information Services & Technology 08/14/2024

Exercise 5
Boston University Slideshow Title Goes Here

 In dot product code, check if the magnitude of the dot

6
product is less than 10 using the absolute value
function abs. If it is, print a message. In either case,
print the result as before.
 solution

34
Information Services & Technology 08/14/2024

Array Syntax
Boston University Slideshow Title Goes Here

 Fortran will perform operations on entire arrays

 Like Matlab, unlike C
 To add two arrays, simply use
c=a+b
 Can also specify array sections
c(-5:10) = a(0:15) + b(0:30:2)
 Here we use b(0), b(2), b(4), etc. due to increment specification
 Numbers of elements must be consistent

35
Information Services & Technology 08/14/2024

Array Syntax (cont’d)

Boston University Slideshow Title Goes Here

 There are intrinsic functions to perform some

operations on entire arrays
 sum
sum(x) is the same as x(1) + x(2) + x(3) + …
 product
 minval
 maxval

36
Information Services & Technology 08/14/2024

Exercise 6
Boston University Slideshow Title Goes Here

 Modify dot product code to use array syntax instead of

do loop
 use “sum” intrinsic to sum components
 solution

37
Information Services & Technology 08/14/2024

Subprograms
Boston
Calculations may be grouped into subroutines and
University Slideshow Title Goes Here

functions
 perform specific tasks such as:
 read or write data
 initialize data
 solve a system of equations
 Function returns a single object (number, array, etc.),
and usually does not alter the arguments
 Altering arguments in a function, called “side effects,” is sometimes
considered bad programming practice
 Subroutine transfers calculated values (if any) through
arguments

38
Information Services & Technology 08/14/2024

Functions
Boston
Definition starts with a return type
University Slideshow Title Goes Here

 End with “end function” analogous to “end program”

 Example: distance between two vectors
real function distfunc(a, b)
real, dimension(3) :: a, b
distfunc = sqrt( sum((b-a)**2) ) !... note array syntax for b-a
end function distfunc
 Use:
z = distfunc(x, y)
 Names of dummy arguments don’t have to match actual names
 distfunc must be declared in calling routine
real :: distfunc

39
Information Services & Technology 08/14/2024

Subroutines
Boston University Slideshow Title Goes Here

 End with “end subroutine” analogous to “end program”

 Distance subroutine
subroutine distsub(a, b, dist)
real :: dist
real, dimension(3) :: a, b
dist = sqrt( sum((b-a)**2) )
end subroutine distfunc
 Use:
call distsub(x, y, d)
 As with function, names of dummy arguments don’t have to match
actual names

40
Information Services & Technology 08/14/2024

Exercise 7
Boston University Slideshow Title Goes Here

 Modify dot-product program to use a subroutine to

compute the dot product
 The subroutine definition may go before or after the main program in
source code
 Don’t forget to declare arguments
 Give the subroutine some name different that the program
 I called mine dp
 solution

41
Information Services & Technology 08/14/2024

Basics of Code Management

Boston University Slideshow Title Goes Here

 Large codes usually consist of multiple files

 I usually create a separate file for each subprogram
 Easier to edit
 Can recompile one subprogram at a time
 Files can be compiled, but not linked, using –c option;
then object files can be linked
pgf90 –c mycode.f90
pgf90 –c myfunc.f90
pgf90 –o mycode mycode.o myfunc.o

42
Information Services & Technology 08/14/2024

Exercise 8
Boston University Slideshow Title Goes Here

 Put dot-product subroutine and main program in

separate files
 Give main program same name you have been using
for code, e.g., “program dotprod” and dotprod.f90
 Give subroutine same name you used for subroutine,
e.g., “subroutine dp” and dp.f90
 Compile, link, and run
 solution

43
Information Services & Technology 08/14/2024

Makefiles
Boston University Slideshow Title Goes Here

 Make is a Unix utility to help manage codes

 When you make changes to files, it will
 Automatically deduce which files need to be compiled and compile
them
 Link latest object files
 Makefile is a file that tells the make utility what to do
 Default name of file is “makefile” or “Makefile”
 Can use other names if you’d like

44
Information Services & Technology 08/14/2024

Makefiles (cont’d)
Boston University Slideshow Title Goes Here

 Makefile contains different sections with different

functions
 The sections are not executed in order!
 Comment character is #
 There are defaults for some values, but I like to define
everything explicitly

45
Information Services & Technology 08/14/2024

Makefiles (3)
 example makefile:
Boston University Slideshow Title Goes Here

### suffix rule

.SUFFIXES:
.SUFFIXES: .f90 .o
.f90.o:
$(F90) $(COMPFLAGS) $*.f90

### compiler
F90 = pgf90
COMMONFLAGS = -O3
COMPFLAGS = -c $(COMMONFLAGS)
LINKFLAGS = $(COMMONFLAGS)

### objects
OBJ = mymain.o sub1.o sub2.o fun1.o

### compile and link

myexe: $(OBJ)
$(F90) –o $@ $(LINKFLAGS) $(OBJ)

46
Information Services & Technology 08/14/2024

Makefiles (4)
Boston University Slideshow Title Goes Here

 variables
 Some character strings appear repeatedly in makefiles
 It’s convenient to give them names so if they are changed, you only
have to do it in one place
 To define variable:
name = string
 No quotes are required for the string
 String may contain spaces
 “name” is any name you want
 Variable names are usually all capitals
 To continue line, use \ character

47
Information Services & Technology 08/14/2024

Makefiles (5)
Boston University Slideshow Title Goes Here

 Variables (cont’d)
 To use variable, either of these work:
$(name)
${name}
 Example:
 Define compiler
F90 = pgf90
 To use elsewhere in makefile:
$(F90)

48
Information Services & Technology 08/14/2024

Makefiles (6)
Boston University Slideshow Title Goes Here

 Good practice to define compiler info in variables

F90 = pgf90
COMMONFLAGS = -O3
COMPFLAGS = -c $(COMMONFLAGS)
LINKFLAGS = $(COMMONFLAGS)

49
Information Services & Technology 08/14/2024

Makefiles (7)
Boston University Slideshow Title Goes Here

 Have to define all file suffixes that may be encountered

.SUFFIXES: .o .f90
 Just to be safe, delete any default suffixes first with a
null .SUFFIXES: command
.SUFFIXES:
.SUFFIXES: .o .f90

50
Information Services & Technology 08/14/2024

Makefiles (8)
Boston University Slideshow Title Goes Here

 Have to tell how to create one file suffix from another

with a suffix rule
.f90.o:
$(F90) $(COMPFLAGS) $*.f90
 The first line indicates that the rule tells how to create
a .o file from a .f90 file
 The second line tells how to create the .o file
 The big space before $(F90) is a tab, and you must
use it!
 *$ is automatically the root of the first file

51
Information Services & Technology 08/14/2024

Makefiles (9)
Boston University Slideshow Title Goes Here

 Usually define variable with all object file names

OBJ = mymain.o sub1.o anothersub.o \
firstfunc.o func2.o

52
Information Services & Technology 08/14/2024

Makefiles (10)
Boston University Slideshow Title Goes Here

 Finally, everything falls together with the definition of a

rule
target: prerequisites
recipe
 The target is any name you choose
 Often use name of executable
 Prerequisites are files that are required by target
 e.g., executable requires object files
 Recipe tells what you want the makefile to do

53
Information Services & Technology 08/14/2024

Makefiles (11)
Boston University Slideshow Title Goes Here
### suffix rule
.SUFFIXES:
.SUFFIXES: .f90 .o
.f90.o:
$(F90) $(COMPFLAGS) $*.f90

### compiler
F90 = pgf90
COMMONFLAGS = -O3
COMPFLAGS = -c $(COMMONFLAGS)
LINKFLAGS = $(COMMONFLAGS)

### objects
OBJ = mymain.o sub1.o sub2.o fun1.o

### compile and link

myexe: $(OBJ)
$(F90) –o $@ $(LINKFLAGS) $(OBJ)

Automatic variable for target

54
Information Services & Technology 08/14/2024

Makefiles (12)
Boston
When youSlideshow
University type “make,” it will look for a file called “makefile” or
Title Goes Here

“Makefile”
 It then searches for the first target in the file
 In our example (and the usual case) the object files are
prerequisites
 It checks the suffix rule to see how to create an object file
 In our case, it sees that .o files depend on .f90 files
 It checks the time stamps on the associated .o and .f90 files to
see if the .f90 is newer
 If the .f90 file is newer it performs the suffix rule
 In our case, compiles the routine

55
Information Services & Technology 08/14/2024

Makefiles (13)
Boston University Slideshow Title Goes Here
Once all the prerequisites are updated as required, it
performs the recipe
 In our case it links the object files and creates our
executable
 Many makefiles have an additional target, “clean,” that
removes .o and other files
clean:
rm –f *.o
 When there are multiple targets, specify desired target
as argument to make command
make clean

56
Information Services & Technology 08/14/2024

Exercise 9
Boston University Slideshow Title Goes Here

 Create a makefile for your dot product code

 Include two targets
 executable
 clean
 Delete your old object files using “make clean”
 Build your code using the makefile
 solution

57
Information Services & Technology 08/14/2024

Kind
Boston University Slideshow Title Goes Here

 Declarations of variables can be modified using “kind”

parameter
 Often used for precision of reals
 Intrinsic function selected_real_kind(n) returns kind
that will have at least n significant digits
 n = 6 will give you “single precision”
 n = 12 will give you “double precision”

58
Information Services & Technology 08/14/2024

Kind (cont’d)
Boston University Slideshow Title Goes Here

integer, parameter :: rk = selected_real_kind(12)

real(rk) :: x, y, z
real(rk), dimension(101,101,101) :: a
 If you want to change precision, can easily be done by
changing one line of code

59
Information Services & Technology 08/14/2024

Exercise 10
Boston University Slideshow Title Goes Here

 Modify dot-product code to use kinds to declare

double-precision reals
 Don’t forget to modify all files
 “make” will automatically compile and link
 solution

60
Information Services & Technology 08/14/2024

Modules
Boston University Slideshow Title Goes Here

 Program units that group variables and subprograms

 Good for global variables
 Checking of subprogram arguments
 If type or number is wrong, linker will yell at you
 Can be convenient to package variables and/or
subprograms of a given type

61
Information Services & Technology 08/14/2024

Modules (cont’d)
Boston University Slideshow Title Goes Here

module module-name
implicit none
… variable declarations …
contains
… subprogram definitions …
end module module-name

62
Information Services & Technology 08/14/2024

Modules (3)
Boston University Slideshow Title Goes Here

 Only need “contains” if module contains subprograms

 I usually name my modules (and associated files) with
_mod in the name, e.g., solvers_mod,
solvers_mod.f90
 In program unit that needs to access components of
module use module-name
 use statement must be before implicit none

63
Information Services & Technology 08/14/2024

Modules (4)
Boston University Slideshow Title Goes Here

 use statement may specify specific components to

access by using “only” qualifier:
use solvers_mod, only: nvals, x
 A Fortran style suggestion:
 Group global variables in modules based on function
 Employ “use only” for all variables required in program unit
 All variables then appear at top of program unit in declarations or
“use” statements

64
Information Services & Technology 08/14/2024

Modules (5)
Boston University Slideshow Title Goes Here

 When linking object files, modules must come first

in the list
 In my makefiles I create a MODS variable analogous to OBJS
 Link command then contains $(MODS) $(OBJS)

65
Information Services & Technology 08/14/2024

Exercise 11
Boston University Slideshow Title Goes Here

 Create module prec_mod

 Separate file called prec_mod.f90
 Parameter rk
 Real kind for double
 Use this module in dot-product program units
 Modify makefile to compile module
 add module list to dependencies and link recipe
 solution

66
Information Services & Technology 08/14/2024

Derived Types
Boston University Slideshow Title Goes Here

 Analogous to structures in C
 Can package a number of variables under one name
type grid
integer :: nvals
real, dimension(100,100) :: x, y, jacobian
end type grid

67
Information Services & Technology 08/14/2024

Derived Types (cont’d)

Boston University Slideshow Title Goes Here

 To declare a variable
type(grid) :: airfoil
 Components are accessed using %
airfoil%nvals = 20
airfoil%x = 0.0 !... array notation, initialize entire array
 Handy way to transfer lots of data to a subprogram
call calc_jacobian(airfoil)

68
Information Services & Technology 08/14/2024

Exercise 12
Boston University Slideshow Title Goes Here

 Create module with definition of rvec3 type

 Size of vector nvals = 3
 not a parameter – can’t have parameter in derived type
 Real 3-component vector
 Use prec_mod
 Modify code to use rvec3
 Modify makefile to include new module
 solution

69
Information Services & Technology 08/14/2024

i/o
Boston University Slideshow Title Goes Here

 List-directed output (print*) gives little control

 write statement allows formatted output
write(unit, format) variables
 Unit is a number indicating where you want to write
data
 The number 6 is std out (write to screen)

70
Information Services & Technology 08/14/2024

i/o (cont’d)
Boston University Slideshow Title Goes Here

 im
 For integers
 m is total number of places in field
i3 125
 am
 For character strings
 m is number of characters
a5 hello
 Left-justifies
 If m isn’t specified, writes number of characters in variable
declaration

71
Information Services & Technology 08/14/2024

i/o (3)
Boston University Slideshow Title Goes Here

 fm.n
 For floating-point (real) numbers
 m is total number of characters in field
 n is number of decimal places
f5.3 1.234
f5.2 -1.23
 If m is larger than required, right-justifies
 em.n
 Exponential notation
e9.2 -0.23e-01
 Always zero left of decimal

72
Information Services & Technology 08/14/2024

i/o (4)
Boston University Slideshow Title Goes Here

 esm.n
 scientific notation
es9.2 -2.30e-02
 In format statement, put formats within ‘()’
 Example write statement
write(6, ‘(a, f6.2, i5, es15.3)’) ‘answers are ’, x, j, y

73
Information Services & Technology 08/14/2024

i/o (5)
Boston University Slideshow Title Goes Here

 Suppose you want to write to a file?

 open statement
open(11, file=‘mydata.d’)
 “11” is unit number
 Don’t use 5 or 6
 Reserved for std in, std out
 Use this unit in your write statement
 When you’re finished writing, close the file
close(11)

74
Information Services & Technology 08/14/2024

i/o (6)
Boston University Slideshow Title Goes Here

 Can also read from file

 read rather than write
 Can use * instead of format specifier
read(11,*) j, x

75
Information Services & Technology 08/14/2024

Exercise 13
Boston University Slideshow Title Goes Here

 Write your dot-product result to a file

 Only have to change very end of main program
 solution

76
Information Services & Technology 08/14/2024

Unformatted i/o
Boston University Slideshow Title Goes Here
 Binary data take less disk space than ascii (formatted)
data
 Data can be written to file in binary representation
 Not directly human-readable
open(199, file=‘unf.d’, form=‘unformatted’)
write(199) x(1:100000), j1, j2
read(199) x(1:100000), j1, j2
 Note that there is no format specification
 Fortran unformatted slightly different format than C
binary
 Fortran unformatted contains record delimiters

77
Information Services & Technology 08/14/2024

Exercise 14
Boston University Slideshow Title Goes Here

 Modify dot-product program to:

 Write result to unformatted file
 don’t write character string, just number
 After file is closed, open it back up and read result
 Print result to make sure it wrote/read correctly
 solution

78
Information Services & Technology 08/14/2024

References
Boston University Slideshow Title Goes Here

 Lots of books available

 “Fortran 95/2003 Explained” by Metcalf, Reid, and Cohen is good
 PGI
 Compiler
http://www.pgroup.com/doc/pgiug.pdf
 Fortran language reference
http://www.pgroup.com/doc/pgifortref.pdf
 gfortran
http://gcc.gnu.org/wiki/GFortran
 Feel free to e-mail me with any questions

79