- adjustable array
The array in a subprogram has a variable dimension just as in Fortran 77 through that both
the array name and the dimension (all dimensions) are dummy arguments. The actual shape is therefore passed from the actual arguments.
SUBROUTINE SUB (A, NA)
REAL, DIMENSION (NA) :: A
- allocatable array
An array specified as ALLOCATABLE with a certain type and rank.
It can later be allocated a certain extent with the ALLOCATE statement.
The corresponding storage area can be released with the DEALLOCATE statement.
- array
Dimensioned quantity (variable or constant).
- array assignment
Assignment of a whole array to another one is permitted provided they have the same shape, and also if the expression on the right hand side is a scalar, in
which case all the elements on the left hand side will be assigned this same value. Array sections can be used here instead of arrays.
- array function
A function which operates on an array and returns an array or a scalar, or a function
which operates on a scalar and returns an array. An array valued function is an
array function which returns an array.
- array section
Part of an array (the part can have a rank greater than one, but array
sections with rank one are the most common cases).
- assumed-shape array
An array in a subprogram which is not local and has a certain data type and a certain rank.
SUBROUTINE SUB (A)
REAL, DIMENSION (:, :, :) :: A
The extent is determined from an explicit INTERFACE in
the calling program unit, and an explicit specification of the shape
of A there (including the extent).
INTERFACE
SUBROUTINE SUB (A)
REAL, DIMENSION (:, :, :) :: A
END SUBROUTINE SUB
END INTERFACE
- assumed-size array
The array has a variable dimension, like in Fortran 77, through that both the array name
and the parameters of the dimension are dummy arguments, except the last dimension, which
is given by a *
SUBROUTINE SUB (A, NA1, NA2)
REAL, DIMENSION (NA1, NA2,*) :: A
In Fortran 66 the concept "assumed-size array" was not defined, but it was
simulated by placing the digit "1" where the "*" is in Fortran 77.
This custom violates the index check and is of course forbidden by modern compilers, for
example the NAG Fortran 90 compiler. Many old programs still use
this way of simulating dynamic memory allocation.
- attribute
At the specification of a variable the additional properties PARAMETER, PUBLIC,
PRIVATE, INTENT, DIMENSION, SAVE, OPTIONAL, POINTER, TARGET, ALLOCATABLE, EXTERNAL and
INTRINSIC are called attributes. They can also be given by statements.
- automatic array
Array in a subprogram where the array is local but the parameters for the dimensions are
among the dummy arguments.
SUBROUTINE SUB (I, J, K)
REAL, DIMENSION (I, J, K) :: X
- BLOCK DATA
A BLOCK DATA program unit contains definitions (initial values) which are to be
used in the other program units. BLOCK DATA is now being replaced with the more
powerful module.
- deferred-shape array
The array is an array pointer or an allocatable array.
- extent
The number of elements along the various dimensions.
- EXTERNAL
The functions and subroutines you write or obtain from application libraries. The opposite
is INTRINSIC. When external functions or subroutines are used as actual
parameters at the reference of another subprogram they have to be specified as EXTERNAL.
- function
A program unit which returns a function value (or several, if array valued) in its name
and has a number of arguments. Functions without arguments are permitted, it is also
permitted but not advisable that a function changes any of its arguments.
- generic
A generic function can have the property that the data type of the argument gives the same
data type to the function. The value SIN(1.0D0) is also more accurate (calculated
to a higher precision) than that of SIN(1.0). In addition, there exist intrinsic
functions, for example REAL() which can have arguments of various data types, but
always returns a value of a certain data type. For generic subroutines only the arguments
are adjusted.
- interface
Since all the different program units in a Fortran program are compiled completely
independent all information on the arguments have to be transferred manually. In Fortran
77 this was done with very long and cumbersome argument lists. In Fortran 90 an INTERFACE
can be used. This has to be used in the following cases
- modules that use user defined data types
- call with keyword arguments or optional arguments
- user defined generic routines
- use of assumed-shape arrays
- use of arrays specified with pointers
- at the definition of a new interpretation of an OPERATOR
- to increase the chance that INTENT has any effect (implementation dependent
case)
- call of an array valued function
- If IMPLICIT NONE is being used, an INTERFACE may be required at the
use of a subprogram as the actual argument
- internal function
A function which is local to a certain program unit, and is after a CONTAINS statement.
All the variables in the program unit are directly available. An internal function can not
be used outside the program unit where it is defined. This can be useful in order to avoid
name conflicts between functions and subroutines from different libraries. An internal
function can not be used as an argument! It also exists internal subroutines.
- intrinsic
Those functions and subroutines that are delivered together with the compiler are called
intrinsic, and have some special properties, they do not usually have to be specified.
Since Fortran 90 has so many intrinsic functions, some manufacturers may choose to let
some of them instead be available in a usual library, and thus be external. The opposite
to intrinsic is external. If intrinsic functions or subroutines are used as arguments at
the call of some other subprogram they must be specified as INTRINSIC. Note the
very important difference between an intrinsic and an internal subprogram.
- loop
With a loop we mean a number of executable statements that are repeated a number of times,
the usual case is a DO-loop, but also an IF-statement (arithmetic or
logical or the newer IF...THEN...ELSE...ENDIF or a CASE construct) can
be called a loop.
- main program
Each Fortran program has to consist of exactly one main program and and any number of subroutines, functions, modules
and BLOCK DATA program units. A main program may start with
the statement PROGRAM name and must be terminated with a statement END
PROGRAM name or END PROGRAM or the simpler END.
- module
A module contains specifications and definitions to be used in other program units.
Replaces BLOCK DATA.
- nested
Inside a DO-loop can be further DO-loops, inside an IF...THEN...ELSE...ENDIF
or CASE can also be additional constructs. Sometimes also IF and CASE
constructs are called loops.
- program unit
The collective reference to a main program, a subroutine,
a function, a module or a BLOCK
DATA program unit.
- rank
The number of dimensions. WARNING: Not the mathematical rank.
- recursive
A function or a subroutine that calls itself. Permitted from Fortran 90.
- result variable
A function is called by its function name, and on return that name contains the value of
the function. If the function is recursive a special result variable has to be used inside
the function in order to store the result temporarily, but it is still returned in the
usual way via the function name. The result variable is also useful for array functions,
even in the non-recursive case. It is always permitted in a function specification to use
the result variable.
- shape
The shape of an array consists of its rank and extent.
- statement function
A function local to a program unit, is located between the ordinary specifications and the
executable statements. Very simple, available already in FORTRAN I. A more general concept
is the internal function after a CONTAINS statement. A
statement function may not be used as an argument!
- subroutine
A program unit which does not return any value through its name and has a number of
arguments. It is permitted for a subroutine to change the values of its arguments. A
subroutine can however have other tasks to perform, quite often related to input and
output. A subroutine does not have a data type.