xbeta
Fortran

Home Page | All Pages | Recently Revised | Authors | Feeds | Export |

Best Practices

Initialize variables

It is good practice to initialize all variables before they are used, including data members of derived types and allocatable arrays each time they are allocated. It is not safe to assume that they will always be set to zero. This is also important because the behavior may differ across compilers or architectures. Members of derived types can be initialized as follows:

type :: mytype
  real(dp) :: value = 0.0_dp
  integer  :: n     = 0
end type

Automatic Documentation

Add comments while coding and use an automatic documentation generation program such as f90doc to generate HTML reference documentation to accompany your program.

Use the kind attribute

In Fortran 90?, intrinsic types such as real and integer have a kind attribute which guarantees a specific precision and/or range. real*8 and counterparts should not be used (Chin, Worth, and Greenough, 2006, p. 5). double precision is no longer needed and can be thought of as a kind of real. The following example declares two real variables a and b which are guaranteed to have at least 15 significant digits of precision and an exponent rage of at least 307 (Lemmon and Schafer, 2005, p. 20–22):

integer, parameter :: dp = selected_real_kind(15, 307)
real(kind=dp) :: a
real(dp)      :: b

One can also guarantee precision up to that of the machine-compiler-specific double precision real by using the kind function to get the kind of 1.d0:

integer, parameter :: dp = kind(1.d0)

Another possibility, suggested by Metcalf, et. al (2004, p. 71), ensures that the double and quad types are actually twice and four times the precision of a single:

integer, parameter ::                              &
    sp = kind(1.0),                                &
    dp = selected_real_kind(2*precision(1.0_sp)),  &
    qp = selected_real_kind(2*precision(1.0_dp))

Psuedo Object Oriented Style in Fortran 90

Derived types

In object-oriented languages such as C++, one can define classes that contain both data and methods which operate on that data. One can then create separate instances of the class, each with its own data. A method called from an instance of the class will work on the data held by that particular instance.

In Fortran, modules may contain data, but there is no notion of separate instances of a module. In order to obtain class-like behavior, one can use a combine a module, which contains the methods that operate on the class, with a derived type containing the data. There can be separate “instances” of the type in that we can allocate many variables of that type which can be passed as parameters to the methods contained in the module.

To illustrate these points consider a simple Circle class, based on an example in Akin (2003, p. 34):

module class_Circle
  implicit none
  private
  public :: Circle, circle_area, circle_print

  real :: pi = 3.1415926535897931d0 ! Class-wide private constant

  type Circle
     real :: radius
  end type Circle
contains
  function circle_area(this) result(area)
    type(Circle), intent(in) :: this
    real :: area
    area = pi * this%radius**2
  end function circle_area

  subroutine circle_print(this)
    type(Circle), intent(in) :: this
    real :: area
    area = circle_area(this)  ! Call the circle_area function
    print *, 'Circle: r = ', this%radius, ' area = ', area
  end subroutine circle_print
end module class_Circle

program circle_test
  use class_Circle
  implicit none

  type(Circle) :: c     ! Declare a variable of type Circle.
  c = Circle(1.5)       ! Use the implicit constructor, radius = 1.5.
  call circle_print(c)  ! Call a class subroutine
end program circle_test

Object-Oriented Features of Fortran 2003

Type-bound procedures

New features in Fortran 2003 allow us to improve upon the object-oriented approach above by using type-bound procedures which allow us to write

a = c%area
call c%print

instead of the more verbose

a = circle_area(c)
call circle_print(c)

The program above, modified to use type-bound procedures, looks like this

module class_Circle
  implicit none
  private
  real :: pi = 3.1415926535897931d0 ! Class-wide private constant

  type, public :: Circle
     real :: radius
   contains
     procedure :: area => circle_area
     procedure :: print => circle_print
  end type Circle
contains
  function circle_area(this) result(area)
    class(Circle), intent(in) :: this
    real :: area
    area = pi * this%radius**2
  end function circle_area

  subroutine circle_print(this)
    class(Circle), intent(in) :: this
    real :: area
    area = this%area()  ! Call the type-bound function
    print *, 'Circle: r = ', this%radius, ' area = ', area
  end subroutine circle_print
end module class_Circle


program circle_test
  use class_Circle
  implicit none

  type(Circle) :: c     ! Declare a variable of type Circle.
  c = Circle(1.5)       ! Use the implicit constructor, radius = 1.5.
  call c%print          ! Call the type-bound subroutine
end program circle_test

Note that we have changed the dummy parameters from type(Circle) to class(Circle). We can then call the class functions in an object-oriented fashion as a = c%area and call c%print, where the type is passed to the first argument of the functions circle_area and circle_print automatically. See Metcalf, Reid, and Cohen (2004, p. 279) for additional information.

External Resources

Mathematical Libraries

Software Repositories

Free Compilers

Commercial Compilers

Utilities

  • f90doc - a documentation generation program for Fortran programs much like Javadoc or Doxygen.

References

category: Scientific computation, Fortran

Revised on February 13, 2008 16:32:51 by Jason Blevins (67.159.68.132)
Edit | Back in time (20 revisions) | See changes | Views: Print | TeX | Linked from: Scientific computation