1. Introduction
In the following, we will assume that the reader is familiar with a programming language such as True BASIC. We first give an example of an F program.

program product_example
   real :: m, a, force
   m = 2.0                       ! mass in kilograms
   a = 4.0                       ! acceleration in mks units
   force = m*a                   ! force in newtons
print *, force
end program product_example

The first statement must be a program statement; the last statement must have a corresponding end program statement.

Integer numerical variables and floating point numerical variables are distinguished. The names of all variables must be between 1 and 31 alphanumeric characters of which the first must be a letter and the last must not be an underscore.

The types of all variables must be declared.

Real numbers are written as 2.0 rather than 2.

The case is significant, but two names that differ only in the case of one or more letters cannot be used together. All keywords (words that are part of the language and cannot be redefined.) are written in lower case. Some names such as product are reserved and cannot be used as names.

Comments begin with a ! and can be included anywhere in the program.

Statements are written on lines which may contain up to 132 characters.

The asterisk (*) following print is the default format.

We next introduce syntax that allows us to enter the desired values of m and a from the keyboard. Note the use of the (unformatted) read statement and how character strings are printed.

program product_example2
   real :: m, a, force
   ! SI units
   print *, "mass m = ?"
   read *, m
   print *, "acceleration a = ?"
   read *, a
   force = m*a
   print *, "force (in newtons) =", force
end program product_example2

program series
   integer :: n
   real :: sum_series       ! sum is a keyword
   sum_series = 0.0
!  add the first 100 terms of a simple series
   do n = 1, 100
      sum_series = sum_series + 1.0/real(n)**2
      print *, n,sum_series
   end do
end program series

A do construct can be exited by using the exit statement.

5. Files
Program save_data illustrates how to open a new file, write data in a file, close a file, and read data from an existing file.

program save_data
!  illustrate writing and reading file
   integer :: i,j,x
   character(len = 32) :: file_name
   print *, "name of file?"
   read *, file_name
   open (unit=5,file=file_name,action="write",status="new")
   do i = 1,4
      x = i*i
      write (unit=5,fmt=*) i,x
   end do
   close(unit=5)
   open (unit=1,file=file_name,action="read",status="old")
   do i = 1,4
      read (unit=1,fmt = *) j,x
      print *, j,x
   end do
   close(unit=1)
end program save_data

module param

integer, public, parameter :: double = 8

end module param

module common

use param
private

public :: initial

integer, public :: N

contains

subroutine initial(x)
   real (kind = double), intent(inout), dimension(:) :: x
   N = 100
   x(1) = 1.0
end subroutine initial

end module common

program test
   use param
   use common
   real (kind = double), allocatable,dimension (:) :: x
   N = 10
   allocate(x(N))
   call initial(x)
end program test

8. Random number sequences
Fortran 90 includes several useful built-in procedures. One of the most useful ones is subroutine random_number. Although it is a good idea to write your own random number generator using an algorithm that you have tested on the particular problem of interest, it is convenient to use subroutine random_number when you are debugging your program or if accuracy is not important. The following program illustrates several uses of subroutine random_number and random_seed. Note that the argument rnd of random_number must be real, has intent out, and can be either a scalar or an array.

program random_example
   real :: rnd
   real, dimension (:), allocatable :: x
   integer, dimension(2) :: seed, seed_old
   integer :: L,i,n_min,n_max,ran_int,sizer
!  generate random integers between n_min and n_max
!  dimension of seed is one in F and two in Fortran 90.
   call random_seed(sizer)
   print *, sizer
!  illustrate use of put and get
   seed(1) = 1239
   seed(2) = 9863        ! need for Fortran 90
   call random_seed(put=seed)
   call random_seed(get=seed_old)
!  confirm value of seed
   print *, "seed = ", seed_old
   L = 100         ! length of sequence
   n_min = 1
   n_max = 10
   do i = 1,L
      call random_number(rnd)
      ran_int = (n_max - n_min + 1)*rnd + n_min
      print *,ran_int
   end do
!  assign random numbers to array x as another example
   allocate(x(L))
   call random_number(x)
   print "(4f13.6)", x
   call random_seed(get=seed_old)
   print *, "seed = ", seed_old
end program random_example

9. Recursion
A simple example of a recursive definition is the factorial function

factorial(n) = n! = n(n-1)(n-2) ... 1

factorial(1) = 1 factorial(n) = n factorial(n-1)

module fact

public :: f
contains

recursive function f(n) result (factorial_result)
   integer, intent (in) :: n
   integer :: factorial_result

   if (n <= 0) then
      factorial_result = 1
   else
      factorial_result = n*f(n-1)
   end if
end function f

end module fact

program test_factorial
   use fact

   integer :: n
   print *, "integer n?"
   read *, n
   print "(i4, a, i10)", n, "! = ", f(n)
end program test_factorial

A less simple example (taken from pp. 98-99 in The Fun of Computing,John G. Kemeny, True BASIC (1990)) is given two integers, n and m, what is their greatest common divisor, that is, the largest integer that divides both? For example, if n = 1000 and m = 32, than the greatest common divisor (gcd) is gcd = 8.

One method for finding the gcd is to integer divide n by m. We write n = q m + r, where q is the quotient and r is the remainder. If r = 0, then m divides n and m is the gcd. Otherwise, any divisor of m and r also divides n, and hence gcd(n,m) = gcd(m,r). Because r < m, we have made progress. As an example, take n = 1024 and m = 24. Then q = 42 and r = 16. So we want gcd(24,16). Now q = 1 and r = 8 and we calculate gcd(16,8). Finally q = 2, and r = 0 so gcd = 8. The following program implements this idea.

module gcd_def

public :: gcd
contains

recursive function gcd(n,m) result (gcd_result)
   integer, intent (in) :: n,m
   integer :: gcd_result
   integer :: remainder

   remainder = modulo(n,m)
   if (remainder == 0) then
      gcd_result = m
   else
      gcd_result = gcd(m,remainder)
   end if
end function gcd

end module gcd_def

program greatest
   use gcd_def

   integer :: n,m
   print *, "enter two integers n, m"
   read *, n,m
   print "(a,i6,a,i6,a ,i6)", "gcd of",n," and",m,"=",gcd(n,m)
end program greatest

The example of recursion given in almost all introductory textbooks is the towers of Hanoi. To save space, a discussion is given elsewhere together with the program. (not finished)

The volume of a d-dimensional hypersphere of unit radius can be related to the area of a (d - 1)-dimensional hypersphere. The following program uses a recursive subroutine to integrate numerically a d-dimensional hypersphere:

module common
   public :: initialize,integrate

   integer, parameter, public :: double = 8
   real (kind = double), parameter, public :: zero = 0.0
   real (kind = double), public :: h, volume
   integer, public :: d

contains

subroutine initialize()
   print *, "dimension d?"
   read *, d                         ! spatial dimension
   print *, "integration interval h?"
   read *, h
   volume = 0.0
end subroutine initialize

recursive subroutine integrate(lower_r2, remaining_d)
!  lower_r2 is contribution to r^2 from lower dimensions
   real(kind = double),intent (in) :: lower_r2
   integer, intent (in) :: remaining_d  ! # dimensions to integrate
   real (kind = double) :: x

   x = 0.5*h   ! mid-point approximation
   if (remaining_d > 1) then
      lower_d: do
         call integrate(lower_r2 + x**2, remaining_d - 1)
         x = x + h
         if (x > 1) then
            exit lower_d
         end if
      end do lower_d
   else   
      last_d: do
         if (x**2 + lower_r2 <= 1) then
           volume = volume + h**(d - 1)*(1 - lower_r2 - x**2)**0.5
         end if
         x = x + h
         if (x > 1) then
            exit last_d
         end if
      end do last_d
   end if
end subroutine integrate

end module common

program hypersphere
!  original program by Jon Goldstein
   use common

   call initialize()
   call integrate(zero, d - 1)
   volume = (2**d)*volume         ! only considered positive octant
   print *, volume
end program hypersphere

10. Character variables
The only instrinsic operator for character expressions is the concatenation operator //. For example, the concatenation of the character constants string and beans is written as

"string"//"beans"

program write_files
!  test program to open n files and write data
   integer :: i,n
   character(len = 15) :: file_name
   n = 11
   do i = 1,n
!     assign number.dat to file_name using write statement
      write(unit=file_name,fmt="(i2.2,a)") i,".dat" 
!     // is concatenation operator
      file_name = "config"//file_name
      open (unit=1,file=file_name,action="write",status="replace")
      write (unit=1, fmt=*) i*i,file_name
      close(unit=1)
   end do
end program write_files