Fortran Specification Statements
by Michael Metcalf / CERN CN-AS
(taken from https://w3.pppl.gov/~hammett/comp/f90tut/f90.tut7.html
For a complete list of Fortran tutorial link and other useful links, look at
https://w3.pppl.gov/~hammett/
Implicit typing
The imlicit typing rules of FORTRAN 77 still hold. However, it is good practice to explicitly type all variables, and this can be forced by inserting the statement
IMPLICIT NONE
at the beginning of each prorgam unit.
PARAMETER attribute
A named constant can be specified directly by adding the PARAMETER attribute and the constant values to a type statement:
REAL, DIMENSION(3), PARAMETER :: field = (/ 0., 1., 2. /)
TYPE(triplet), PARAMETER :: t = &
triplet( 0., (/ 0., 0., 0. /) )
DATA statement
The DATA statement can be used also for arrays and variables of derived type. It is also the only way to initialise just parts of such objects, as well as to initialise to binary, octal or hexadecimal values:
TYPE(triplet) :: t1, t2
DATA t1/triplet( 0., (/ 0., 1., 2. /) )/, t2%u/0./
DATA array(1:64) / 64*0/
DATA i, j, k/ B'01010101', O'77', Z'ff'/
Characters
There are many variations on the way character arrays may be specified. The shortest and longest are
CHARACTER name(4, 5)*20
CHARACTER (KIND = kanji, LEN = 20), DIMENSION (4, 5) :: name
Initialization expressions
The values used in DATA and PARAMETER statements, or with these attributes, are constant expressions that may include references to: array and structure constructors, elemental intrinsic functions with integer or character arguments and results, and the six transformational functions REPEAT, SELECTED_INT_KIND, TRIM, SELECTED_REAL_KIND, RESHAPE and TRANSFER:
INTEGER, PARAMETER :: long = SELECTED_REAL_KIND(12), &
array(3) = (/ 1, 2, 3 /)
Specification expressions
It is possible to specify details of variables using any non-constant, scalar, integer expression that may also include inquiry function references:
SUBROUTINE s(b, m, c)
USE mod ! contains a
REAL, DIMENSION(:, :) :: b
REAL, DIMENSION(UBOUND(b, 1) + 5) :: x
INTEGER m
CHARACTER(LEN=*) c
CHARACTER(LEN= m + LEN(c)) cc
REAL (SELECTED_REAL_KIND(2*PRECISION(a))) z
PUBLIC and PRIVATE
These attributes are used in specifications in modules to limit the scope of entities. The attribute form is
REAL, PUBLIC :: x, y, z ! default
INTEGER, PRIVATE :: u, v, w
and the statement form is
PUBLIC :: x, y, z, OPERATOR(.add.)
PRIVATE :: u, v, w, ASSIGNMENT(=), OPERATOR(*)
The statement form has to be used to limit access to operators, and can also be used to change the overall default:
PRIVATE ! sets default for module
PUBLIC :: only_this
For derived types there are three possibilities: the type and its components are all PUBLIC, the type is PUBLIC and its components PRIVATE (the type only is visible and one can change its details easily), or all of it is PRIVATE (for internal use in the module only):
MODULE mine
PRIVATE
TYPE, PUBLIC :: list
REAL x, y
TYPE(list), POINTER :: next
END TYPE list
TYPE(list) :: tree
:
END MODULE mine
USE statement
To gain access to entities in a module, we use the USE statement. It has options to resolve name clashes if an imported name is the same as a local one:
USE mine, local_list => list
or to restrict the used entities to a specified set:
USE mine, ONLY : list
