Language elements
Fortran isBasics
The basic component of the Fortran language is its ''character set''. Its members are *the letters A ... Z and a ... z (which are equivalent outside a character context) *the numerals 0 ... 9 *the underscore _ *the special characters= : + blank - * / ( ) , . $ ' ! " % & ; < > ?
Tokens that have a syntactic meaning to the compiler are built from those components. There are six classes of tokens:
From the tokens, statements are built. These can be coded using the new free ''source form'' which does not require positioning in a rigid column structure:
&
on the continued line is also required.
Automatic conversion of source form for existing programs can be carried out bIntrinsic data types
Fortran has five ''intrinsic data types'':INTEGER
, REAL
, COMPLEX
, LOGICAL
and CHARACTER
. Each of those types can be additionally characterized by a ''kind''. Kind, basically, defines internal representation of the type: for the three numeric types, it defines the precision and range, and for the other two, the specifics of storage representation. Thus, it is an abstract concept which models the limits of data types' representation; it is expressed as a member of a set of whole numbers (e.g. it may be for integers, denoting bytes of storage), but those values are not specified by the Standard and not portable. For every type, there is a ''default kind'', which is used if no kind is explicitly specified. For each intrinsic type, there is a corresponding form of ''literal constant''. The numeric types INTEGER
and REAL
can only be signed (there is no concept of sign for type COMPLEX
).
Literal constants and kinds
=INTEGER
= Integer literal constants of the default kind take the formtwo_bytes
is
two_bytes
is the kind type parameter; it can also be an explicit default integer literal constant, like
RANGE
function supplies the actual decimal range (so the user must make the actual mapping to bytes):
DATA
(initialization) statements, binary (B), octal (O) and hexadecimal (Z) constants may be used (often informally referred to as "BOZ constants"):
=REAL
= There are at least two real kindsthe default and one with greater precision (this replaces=COMPLEX
=COMPLEX
data type is built of two integer or real components:
=LOGICAL
= There are only two basic values of logical constants:.TRUE.
and .FALSE.
. Here, there may also be different kinds. Logicals don't have their own kind inquiry functions, but use the kinds specified for INTEGER
s; default kind of LOGICAL
is the same as of INTEGER.
KIND
function operates as expected:
=CHARACTER
= The forms of literal constants forCHARACTER
data type are
KIND
function:
Number model and intrinsic functions
The numeric types are based on number models with associated inquiry functions (whose values are independent of the values of their arguments; arguments are used only to provide kind). These functions are important for portable numerical software:Scalar variables
Scalar variables corresponding to the five intrinsic types are specified as follows:KIND
parameter specifies a non-default kind, and the ::
notation delimits the type and attributes from variable name(s) and their optional initial values, allowing full variable specification and initialization to be typed in one statement (in previous standards, attributes and initializers had to be declared in several statements). While it is not required in above examples (as there are no additional attributes and initialization), most Fortran-90 programmers acquire the habit to use it everywhere.
CHARACTER
s and specifies the string length (replacing the older *len
form).
The explicit KIND=
and LEN=
specifiers are optional:
Derived data types
For derived data types, the form of the type must be defined first:%
qualifier is used:
TypeName(1stComponentLiteral, 2ndComponentLiteral, ...)
'':
point
is accessed as
%
qualifier was chosen rather than dot (.
) because of potential ambiguity with operator notation, like .OR.
).
Implicit and explicit typing
Unless specified otherwise, all variables starting with letters I, J, K, L, M and N are defaultINTEGER
s, and all others are default REAL
; other data types must be explicitly declared. This is known as ''implicit typing'' and is a heritage of early FORTRAN days. Those defaults can be overridden by ''IMPLICIT TypeName (CharacterRange)
'' statements, like:
Arrays
Arrays are considered to be variables in their own right. Every array is characterized by its type,DIMENSION
keyword is optional and considered an attribute; if omitted, the array shape must be specified after array-variable name. For example,
(/ ... /)
:
, 2, 3, 4
The comma is a punctuation mark that appears in several variants in different languages. It has the same shape as an apostrophe or single closing quotation mark () in many typefaces, but it differs from them in being placed on the baseline (t ...
/code> and [1,2,3_i=1,4).html"_;"title="[1,2,3.html"_;"title="[1,2,3">[1,2,3_i=1,4)">[1,2,3.html"_;"title="[1,2,3">[1,2,3_i=1,4)/code>
instead_of_the_first_two_examples_above,_and_many_compilers_support_this_now.
A_derived_data_type_may,_of_course,_contain_array_components:_
TYPE_triplet
___REAL,_DIMENSION(3)_::_vertex
END_TYPE_triplet
TYPE(triplet),_DIMENSION(4)_::_t
so_that_
*_t(2)___________is_a_scalar_(a_structure)
*_t(2)%vertex____is_an_array_component_of_a_scalar
_Data_initialization
Variables_can_be_given_initial_values_as_specified_in_a_specification_statement:
REAL,_DIMENSION(3)_::_a_=_(/_0.1,_0.2,_0.3_/)
and_a_default_initial_value_can_be_given_to_the_component_of_a_derived_data_type:
TYPE_triplet
___REAL,_DIMENSION(3)_::_vertex_=_0.0
END_TYPE_triplet
When_local_variables_are_initialized_within_a_procedure_they_implicitly_acquire_the_SAVE_attribute:
REAL,_DIMENSION(3)_::_point_=_(/_0.0,_1.0,_-1.0_/)
This_declaration_is_equivalent_to
REAL,_DIMENSION(3),_SAVE_::_point_=_(/_0.0,_1.0,_-1.0_/)
for_local_variables_within_a_subroutine_or_function.__The_SAVE_attribute_causes_local_variables_to_retain_their_value_after_a_procedure_call_and_then_to_initialize_the_variable_to_the_saved_value_upon_returning_to_the_procedure.
_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._/)_)
_DATA_statement
The_DATA
_statement_can_be_used_for_scalars_and_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.,_1.,_2._/)_)/,_t2%vertex(1)/123./
DATA_array(1:64)_/_64*0/
DATA_i,_j,_k/_B'01010101',_O'77',_Z'ff'/
_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
_(see_#Intrinsic_procedures.html" ;"title=",2,3">[1,2,3_i=1,4).html" ;"title="[1,2,3.html" ;"title="[1,2,3">[1,2,3 i=1,4)">[1,2,3.html" ;"title="[1,2,3">[1,2,3 i=1,4)/code>
instead of the first two examples above, and many compilers support this now.
A derived data type may, of course, contain array components:
TYPE triplet
REAL, DIMENSION(3) :: vertex
END TYPE triplet
TYPE(triplet), DIMENSION(4) :: t
so that
* t(2) is a scalar (a structure)
* t(2)%vertex is an array component of a scalar
Data initialization
Variables can be given initial values as specified in a specification statement:
REAL, DIMENSION(3) :: a = (/ 0.1, 0.2, 0.3 /)
and a default initial value can be given to the component of a derived data type:
TYPE triplet
REAL, DIMENSION(3) :: vertex = 0.0
END TYPE triplet
When local variables are initialized within a procedure they implicitly acquire the SAVE attribute:
REAL, DIMENSION(3) :: point = (/ 0.0, 1.0, -1.0 /)
This declaration is equivalent to
REAL, DIMENSION(3), SAVE :: point = (/ 0.0, 1.0, -1.0 /)
for local variables within a subroutine or function. The SAVE attribute causes local variables to retain their value after a procedure call and then to initialize the variable to the saved value upon returning to the procedure.
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. /) )
DATA statement
The DATA
statement can be used for scalars and 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., 1., 2. /) )/, t2%vertex(1)/123./
DATA array(1:64) / 64*0/
DATA i, j, k/ B'01010101', O'77', Z'ff'/
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
(see #Intrinsic procedures">Intrinsic procedures):
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
Expressions and assignments
Scalar numeric
The usual arithmetic operators are available +, -, *, /, **
(given here in increasing order of precedence).
Parentheses are used to indicate the order of evaluation where necessary:
a*b + c ! * first
a*(b + c) ! + first
The rules for ''scalar numeric'' expressions and assignments accommodate the non-default kinds. Thus, the mixed-mode numeric expression and assignment rules incorporate different kind type parameters in an expected way:
real2 = integer0 + real1
converts integer0
to a real value of the same kind as real1
; the result is of same kind, and is converted to the kind of real2
for assignment.
These functions are available for controlled rounding of real numbers to integers:
*NINT
: round to nearest integer, return integer result
*ANINT
: round to nearest integer, return real result
*INT
: truncate (round towards zero), return integer result
*AINT
: truncate (round towards zero), return real result
*CEILING
: smallest integral value not less than argument (round up) (Fortran-90)
*FLOOR
: largest integral value not greater than argument (round down) (Fortran-90)
Scalar relational operations
For ''scalar relational'' operations of numeric types, there is a set of built-in operators:
< <= /= > >=
.LT. .LE. .EQ. .NE. .GT. .GE.
(the forms above are new to Fortran-90, and older equivalent forms are given below them). Example expressions:
a < b .AND. i /= j ! for numeric variables
flag = a b ! for logical variable flags
Scalar characters
In the case of ''scalar characters'' and given CHARACTER(8) result
it is legal to write
result(3:5) = result(1:3) ! overlap allowed
result(3:3) = result(3:2) ! no assignment of null string
Concatenation is performed by the operator '//'.
result = 'abcde'//'123'
filename = result//'.dat'
Derived-data types
No built-in operations (except assignment, defined on component-by component basis) exist between ''derived data types'' mutually or with intrinsic types. The meaning of existing or user-specified operators can be (re)defined though:
TYPE string80
INTEGER length
CHARACTER(80) value
END TYPE string80
CHARACTER:: char1, char2, char3
TYPE(string80):: str1, str2, str3
we can write
str3 = str1//str2 ! must define operation
str3 = str1.concat.str2 ! must define operation
char3 = char2//char3 ! intrinsic operator only
str3 = char1 ! must define assignment
Notice the " overloaded" use of the intrinsic symbol //
and the named operator, .concat.
. A difference between the two cases is that, for an intrinsic operator token, the usual precedence rules apply, whereas for named operators, precedence is the highest as a unary operator or the lowest as a binary one. In
vector3 = matrix * vector1 + vector2
vector3 =(matrix .times. vector1) + vector2
the two expressions are equivalent only if appropriate parentheses are
added as shown. In each case there must be defined, in a module
Module, modular and modularity may refer to the concept of modularity. They may also refer to:
Computing and engineering
* Modular design, the engineering discipline of designing complex devices using separately designed sub-components
* Modul ...
, procedures defining the operator and assignment, and corresponding operator-procedure association, as follows:
INTERFACE OPERATOR(//) !Overloads the // operator as invoking string_concat procedure
MODULE PROCEDURE string_concat
END INTERFACE
The string concatenation function is a more elaborated version of that shown already in Basics. Note that in order to handle the error condition that arises when the two strings together exceed the preset 80-character limit, it would be safer to use a subroutine to perform the concatenation (in this case operator-overloading would not be applicable.)
MODULE string_type
IMPLICIT NONE
TYPE string80
INTEGER length
CHARACTER(LEN=80) :: string_data
END TYPE string80
INTERFACE ASSIGNMENT(=)
MODULE PROCEDURE c_to_s_assign, s_to_c_assign
END INTERFACE
INTERFACE OPERATOR(//)
MODULE PROCEDURE string_concat
END INTERFACE
CONTAINS
SUBROUTINE c_to_s_assign(s, c)
TYPE (string80), INTENT(OUT) :: s
CHARACTER(LEN=*), INTENT(IN) :: c
s%string_data = c
s%length = LEN(c)
END SUBROUTINE c_to_s_assign
SUBROUTINE s_to_c_assign(c, s)
TYPE (string80), INTENT(IN) :: s
CHARACTER(LEN=*), INTENT(OUT) :: c
c = s%string_data(1:s%length)
END SUBROUTINE s_to_c_assign
TYPE(string80) FUNCTION string_concat(s1, s2)
TYPE(string80), INTENT(IN) :: s1, s2
TYPE(string80) :: s
INTEGER :: n1, n2
CHARACTER(160) :: ctot
n1 = LEN_TRIM(s1%string_data)
n2 = LEN_TRIM(s2%string_data)
IF (n1+n2 <= 80) then
s%string_data = s1%string_data(1:n1)//s2%string_data(1:n2)
ELSE ! This is an error condition which should be handled - for now just truncate
ctot = s1%string_data(1:n1)//s2%string_data(1:n2)
s%string_data = ctot(1:80)
END IF
s%length = LEN_TRIM(s%string_data)
string_concat = s
END FUNCTION string_concat
END MODULE string_type
PROGRAM main
USE string_type
TYPE(string80) :: s1, s2, s3
CALL c_to_s_assign(s1,'My name is')
CALL c_to_s_assign(s2,' Linus Torvalds')
s3 = s1//s2
WRITE(*,*) 'Result: ',s3%string_data
WRITE(*,*) 'Length: ',s3%length
END PROGRAM
Defined operators such as these are required for the expressions that are
allowed also in structure constructors (see Derived-data types):
str1 = string(2, char1//char2) ! structure constructor
Arrays
In the case of arrays then, as long as they are of the same shape (conformable), operations and assignments are extended in an obvious way, on an element-by-element basis. For example, given declarations of
REAL, DIMENSION(10, 20) :: a, b, c
REAL, DIMENSION(5) :: v, w
LOGICAL flag(10, 20)
it can be written:
a = b ! whole array assignment
c = a/b ! whole array division and assignment
c = 0. ! whole array assignment of scalar value
w = v + 1. ! whole array addition to scalar value
w = 5/v + a(1:5, 5) ! array division, and addition to section
flag = ab ! whole array relational test and assignment
c(1:8, 5:10) = a(2:9, 5:10) + b(1:8, 15:20) ! array section addition and assignment
v(2:5) = v(1:4) ! overlapping section assignment
The order of expression evaluation is not specified in order to allow for optimization on parallel and vector machines. Of course, any operators for arrays of derived type must be defined.
Some real intrinsic functions that are useful for numeric
computations are
CEILING FLOOR MODULO (also integer)
EXPONENT FRACTION
NEAREST RRSPACING SPACING
SCALE SET_EXPONENT
These are array valued for array arguments (elemental), like all FORTRAN 77 functions (except LEN):
INT REAL CMPLX
AINT ANINT NINT
ABS MOD SIGN
DIM MAX MIN
SQRT EXP LOG
LOG10 SIN COS
TAN ASIN ACOS
ATAN ATAN2
SINH COSH TANH
AIMAG CONJG
LGE LGT LLE
LLT ICHAR CHAR
INDEX
(the last seven are for characters).
Control statements
Branching and conditions
The simple GO TO
''label'' exists, but is usually avoided in most cases, a more specific branching construct will accomplish the same logic with more clarity.
The simple conditional test is the IF
statement: IF (a > b) x = y
A full-blown IF
construct is illustrated by
IF (i < 0) THEN
IF (j < 0) THEN
x = 0.
ELSE
z = 0.
END IF
ELSE IF (k < 0) THEN
z = 1.
ELSE
x = 1.
END IF
CASE construct
The CASE
construct is a replacement for the computed GOTO
, but is better
structured and does not require the use of statement labels:
SELECT CASE (number) ! number of type integer
CASE (:-1) ! all values below 0
n_sign = -1
CASE (0) ! only 0
n_sign = 0
CASE (1:) ! all values above 0
n_sign = 1
END SELECT
Each CASE
selector list may contain a list and/or range of integers,
character or logical constants, whose values may not overlap within or between
selectors:
CASE (1, 2, 7, 10:17, 23)
A default is available:
CASE DEFAULT
There is only one evaluation, and only one match.
DO construct
A simplified but sufficient form of the DO
construct is illustrated by
outer: DO
inner: DO i = j, k, l ! from j to k in steps of l (l is optional)
:
IF (...) CYCLE
:
IF (...) EXIT outer
:
END DO inner
END DO outer
where we note that loops may be optionally named so that any EXIT or CYCLE
statement may specify which loop is meant.
Many, but not all, simple loops can be replaced by array expressions and
assignments, or by new intrinsic functions. For instance
tot = 0.
DO i = m, n
tot = tot + a(i)
END DO
becomes simply tot = SUM( a(m:n) )
Program units and procedures
Definitions
In order to discuss this topic we need some definitions. In logical terms, an
executable program consists of one ''main program'' and zero or more
''subprograms'' (or ''procedures'') - these do something.
Subprograms are either ''functions ''or ''subroutines'', which are
either ''external, internal'' or ''module'' subroutines. (External
subroutines are what we knew from FORTRAN 77.)
From an organizational point of view, however, a complete program consists of
''program units''. These are either ''main programs, external
subprograms'' or ''modules'' and can be separately compiled.
An example of a main (and complete) program is
PROGRAM test
PRINT *, 'Hello world!'
END PROGRAM test
An example of a main program and an external subprogram, forming an executable program, is
PROGRAM test
CALL print_message
END PROGRAM test
SUBROUTINE print_message
PRINT *, 'Hello world!'
END SUBROUTINE print_message
The form of a function is
FUNCTION name(arg1, arg2) ! zero or more arguments
:
name = ...
:
END FUNCTION name
The form of reference of a function is x = name(a, b)
Internal procedures
An internal subprogram is one ''contained'' in another (at a maximum
of one level of nesting) and provides a replacement for the statement function:
SUBROUTINE outer
REAL x, y
:
CONTAINS
SUBROUTINE inner
REAL y
y = x + 1.
:
END SUBROUTINE inner ! SUBROUTINE mandatory
END SUBROUTINE outer
We say that outer
is the ''host'' of inner
, and that inner
obtains
access to entities in outer
by ''host association'' (e.g. to x
), whereas
y
is a ''local'' variable to inner
.
The ''scope'' of a named entity is a ''scoping unit'', here
outer
less inner
, and inner
.
The names of program units and external procedures are ''global'', and
the names of implied-DO variables have a scope of the statement that contains
them.
Modules
Modules are used to package
* global data (replaces COMMON and BLOCK DATA from Fortran 77);
* type definitions (themselves a scoping unit);
* subprograms (which among other things replaces the use of ENTRY from Fortran 77);
* interface blocks (another scoping unit, see Interface blocks);
* namelist groups (see any textbook).
An example of a module
containing a type definition, interface block and function subprogram is
MODULE interval_arithmetic
TYPE interval
REAL lower, upper
END TYPE interval
INTERFACE OPERATOR(+)
MODULE PROCEDURE add_intervals
END INTERFACE
:
CONTAINS
FUNCTION add_intervals(a,b)
TYPE(interval), INTENT(IN) :: a, b
TYPE(interval) add_intervals
add_intervals%lower = a%lower + b%lower
add_intervals%upper = a%upper + b%upper
END FUNCTION add_intervals ! FUNCTION mandatory
:
END MODULE interval_arithmetic
and the simple statement
USE interval_arithmetic
provides ''use association'' to all the module's entities. Module
subprograms may, in turn, contain internal subprograms.
Controlling accessibility
The PUBLIC
and PRIVATE
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
The USE
statement's purpose is to gain access to entities in a module.
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
These may be combined:
USE mine, ONLY : local_list => list
Arguments
We may specify the intent of dummy arguments:
SUBROUTINE shuffle (ncards, cards)
INTEGER, INTENT(IN) :: ncards
INTEGER, INTENT(OUT), DIMENSION(ncards) :: cards
Also, INOUT is possible: here the actual argument must be a variable
(unlike the default case where it may be a constant).
Arguments may be optional:
SUBROUTINE mincon(n, f, x, upper, lower, equalities, inequalities, convex, xstart)
REAL, OPTIONAL, DIMENSION :: upper, lower
:
IF (PRESENT(lower)) THEN ! test for presence of actual argument
:
allows us to call mincon
by
CALL mincon (n, f, x, upper)
Arguments may be keyword rather than positional (which come first):
CALL mincon(n, f, x, equalities=0, xstart=x0)
Optional and keyword arguments are handled by explicit interfaces, that is
with internal or module procedures or with interface blocks.
Interface blocks
Any reference to an internal or module subprogram is
through an interface that is 'explicit' (that is, the compiler can see all the
details). A reference to an external (or dummy) procedure is usually 'implicit'
(the compiler assumes the details). However, we can provide an explicit
interface in this case too. It is a copy of the header, specifications and END
statement of the procedure concerned, either placed in a module or inserted
directly:
REAL FUNCTION minimum(a, b, func)
! returns the minimum value of the function func(x)
! in the interval (a,b)
REAL, INTENT(in) :: a, b
INTERFACE
REAL FUNCTION func(x)
REAL, INTENT(IN) :: x
END FUNCTION func
END INTERFACE
REAL f,x
:
f = func(x) ! invocation of the user function.
:
END FUNCTION minimum
An explicit interface is obligatory for
* optional and keyword arguments;
* POINTER and TARGET arguments (see Pointers
Pointer may refer to:
Places
* Pointer, Kentucky
* Pointers, New Jersey
* Pointers Airport, Wasco County, Oregon, United States
* The Pointers, a pair of rocks off Antarctica
People with the name
* Pointer (surname), a surname (including a l ...
);
* POINTER function result;
* new-style array arguments and array functions ( Array handling).
It allows
full checks at compile time between actual and dummy arguments.
In general, the best way to ensure that a procedure interface is explicit is either to place the procedure concerned in a module or to use it as an internal procedure.
Overloading and generic interfaces
Interface blocks provide the
mechanism by which we are able to define generic names for specific procedures:
INTERFACE gamma ! generic name
FUNCTION sgamma(X) ! specific name
REAL (SELECTED_REAL_KIND( 6)) sgamma, x
END
FUNCTION dgamma(X) ! specific name
REAL (SELECTED_REAL_KIND(12)) dgamma, x
END
END INTERFACE
where a given set of specific names corresponding to a generic name must
all be of functions or all of subroutines. If this interface is within a module,
then it is simply
INTERFACE gamma
MODULE PROCEDURE sgamma, dgamma
END INTERFACE
We can use existing names, e.g. SIN, and the compiler sorts out the
correct association.
We have already seen the use of interface blocks for defined operators and
assignment (see Modules
Broadly speaking, modularity is the degree to which a system's components may be separated and recombined, often with the benefit of flexibility and variety in use. The concept of modularity is used primarily to reduce complexity by breaking a sy ...
).
Recursion
Indirect recursion is useful for multi-dimensional
integration. For
volume = integrate(fy, ybounds)
We might have
RECURSIVE FUNCTION integrate(f, bounds)
! Integrate f(x) from bounds(1) to bounds(2)
REAL integrate
INTERFACE
FUNCTION f(x)
REAL f, x
END FUNCTION f
END INTERFACE
REAL, DIMENSION(2), INTENT(IN) :: bounds
:
END FUNCTION integrate
and to integrate ''f(x, y)'' over a rectangle:
FUNCTION fy(y)
USE func ! module func contains function f
REAL fy, y
yval = y
fy = integrate(f, xbounds)
END
Direct recursion is when a procedure calls itself, as in
RECURSIVE FUNCTION factorial(n) RESULT(res)
INTEGER res, n
IF(n.EQ.0) THEN
res = 1
ELSE
res = n*factorial(n-1)
END IF
END
Here, we note the RESULT
clause and termination test.
Pure procedures
This is a feature for parallel computing.
In the FORALL statement and construct
''The'' () is a grammatical article in English, denoting persons or things already mentioned, under discussion, implied or otherwise presumed familiar to listeners, readers, or speakers. It is the definite article in English. ''The'' is the m ...
, any side effects in a function can impede optimization on a parallel processor the order of execution of the assignments could affect the results. To control this situation, we add the PURE
keyword to the SUBROUTINE
or FUNCTION
statementan assertion that the procedure (expressed simply):
* alters no global variable,
* performs no I/O,
* has no saved variables (variables with the SAVE
attribute that retains values between invocations), and
* for functions, does not alter any of its arguments.
A compiler can check that this is the case, as in
PURE FUNCTION calculate (x)
All the intrinsic functions are pure.
Array handling
Array handling is included in Fortran for two main reasons:
* the notational convenience it provides, bringing the code closer to the underlying mathematical form;
* for the additional optimization opportunities it gives compilers (although there are plenty of opportunities for degrading optimization too!).
At the same time, major extensions of the functionality in this area have been
added. We have already met whole arrays above #Arrays 1 and here #Arrays 2 - now
we develop the theme.
Zero-sized arrays
A zero-sized array is handled by Fortran as a
legitimate object, without special coding by the programmer. Thus, in
DO i = 1,n
x(i) = b(i) / a(i, i)
b(i+1:n) = b(i+1:n) - a(i+1:n, i) * x(i)
END DO
no special code is required for the final iteration where i = n
. We note
that a zero-sized array is regarded as being defined; however, an array of shape
(0,2) is not conformable with one of shape (0,3), whereas x(1:0) = 3 is a valid 'do nothing' statement.
Assumed-shape arrays
These are an extension and replacement for
assumed-size arrays. Given an actual argument like:
REAL, DIMENSION(0:10, 0:20) :: a
:
CALL sub(a)
the corresponding dummy argument specification defines only the type and
rank of the array, not its shape. This information has to be made available by an
explicit interface, often using an interface block (see Interface blocks). Thus we write just
SUBROUTINE sub(da)
REAL, DIMENSION(:, :) :: da
and this is as if da
were dimensioned (11,21). However, we can specify any
lower bound and the array maps accordingly.
REAL, DIMENSION(0:, 0:) :: da
The shape, not bounds, is passed, where the default lower bound is 1 and the default upper bound is the corresponding extent.
Automatic arrays
A partial replacement for the uses to which EQUIVALENCE
was put is provided by this facility, useful for local, temporary arrays, as in
SUBROUTINE swap(a, b)
REAL, DIMENSION(:) :: a, b
REAL, DIMENSION(SIZE(a)) :: work
work = a
a = b
b = work
END SUBROUTINE swap
The actual storage is typically maintained on a stack.
ALLOCATABLE and ALLOCATE
Fortran provides dynamic allocation of
storage; it relies on a heap storage mechanism (and replaces another use of
EQUIVALENCE
). An example for establishing a work array for a whole program is
MODULE work_array
INTEGER n
REAL, DIMENSION(:,:,:), ALLOCATABLE :: work
END MODULE
PROGRAM main
USE work_array
READ (input, *) n
ALLOCATE(work(n, 2*n, 3*n), STAT=status)
:
DEALLOCATE (work)
The work array can be propagated through the whole program via a USE
statement in each program unit. We may specify an explicit lower bound and
allocate several entities in one statement. To free dead storage we write, for
instance,
DEALLOCATE(a, b)
Deallocation of arrays is automatic when they go out of scope.
Elemental operations, assignments and procedures
We have already met whole array
assignments and operations:
REAL, DIMENSION(10) :: a, b
a = 0. ! scalar broadcast; elemental assignment
b = SQRT(a) ! intrinsic function result as array object
In the second assignment, an intrinsic function returns an array-valued
result for an array-valued argument. We can write array-valued functions
ourselves (they require an explicit interface):
PROGRAM test
REAL, DIMENSION(3) :: a = (/ 1., 2., 3./), &
b = (/ 2., 2., 2. /), r
r = f(a, b)
PRINT *, r
CONTAINS
FUNCTION f(c, d)
REAL, DIMENSION(:) :: c, d
REAL, DIMENSION(SIZE(c)) :: f
f = c*d ! (or some more useful function of c and d)
END FUNCTION f
END PROGRAM test
Elemental procedures are specified with scalar dummy arguments that may be called with
array actual arguments. In the case of a function, the shape of the result is the shape of the array
arguments.
Most intrinsic functions are elemental and
Fortran 95 extends this feature to non-intrinsic procedures, thus providing the effect
of writing, in Fortran 90, 22 different versions, for ranks 0-0, 0-1, 1-0, 1-1, 0-2,
2-0, 2-2, ... 7-7, and is further an aid to optimization on parallel processors.
An elemental procedure must be pure.
ELEMENTAL SUBROUTINE swap(a, b)
REAL, INTENT(INOUT) :: a, b
REAL :: work
work = a
a = b
b = work
END SUBROUTINE swap
The dummy arguments cannot be used in specification expressions (see above) except as arguments to certain intrinsic functions (BIT_SIZE
, KIND
, LEN
, and the numeric inquiry ones, (see below
Below may refer to:
*Earth
*Ground (disambiguation)
*Soil
*Floor
*Bottom (disambiguation)
Bottom may refer to:
Anatomy and sex
* Bottom (BDSM), the partner in a BDSM who takes the passive, receiving, or obedient role, to that of the top or ...
).
WHERE
Often, we need to mask an assignment. This we can do using the WHERE
, either as a statement:
WHERE (a /= 0.0) a = 1.0/a ! avoid division by 0
(note: the test is element-by-element, not on whole array), or as a construct:
WHERE (a /= 0.0)
a = 1.0/a
b = a ! all arrays same shape
END WHERE
or
WHERE (a /= 0.0)
a = 1.0/a
ELSEWHERE
a = HUGE(a)
END WHERE
Further:
* it is permitted to mask not only the WHERE
statement of the WHERE
construct, but also any ELSEWHERE
statement that it contains;
* a WHERE
construct may contain any number of masked ELSEWHERE
statements but at most one ELSEWHERE
statement without a mask, and that must be the final one;
* WHERE
constructs may be nested within one another, just FORALL
constructs;
* a WHERE
assignment statement is permitted to be a defined assignment, provided that it is elemental;
* a WHERE
construct may be named in the same way as other constructs.
The FORALL statement and construct
When a DO
construct is executed, each successive iteration is performed in order and one after the otheran impediment to optimization on a parallel processor.
FORALL(i = 1:n) a(i, i) = x(i)
where the individual assignments may be carried out in any order, and even simultaneously. The FORALL
may be considered to be an array assignment expressed with the help of indices.
FORALL(i=1:n, j=1:n, y(i,j)/=0.) x(j,i) = 1.0/y(i,j)
with masking condition.
The FORALL
construct allows several assignment statements to be executed in order.
a(2:n-1,2:n-1) = a(2:n-1,1:n-2) + a(2:n-1,3:n) + a(1:n-2,2:n-1) + a(3:n,2:n-1)
b(2:n-1,2:n-1) = a(2:n-1,2:n-1)
is equivalent to the array assignments
FORALL(i = 2:n-1, j = 2:n-1)
a(i,j) = a(i,j-1) + a(i,j+1) + a(i-1,j) + a(i+1,j)
b(i,j) = a(i,j)
END FORALL
The FORALL
version is more readable.
Assignment in a FORALL
is like an array assignment:
as if all the expressions were evaluated in any order, held in temporary storage, then all the assignments performed in any order. The first statement must fully complete before the second can begin.
A FORALL
may be nested, and may include a WHERE
.
Procedures referenced within a FORALL
must be pure.
Array elements
For a simple case, given
REAL, DIMENSION(100, 100) :: a
we can reference a single element as, for instance, a(1, 1)
. For a
derived-data type like
TYPE fun_del
REAL u
REAL, DIMENSION(3) :: du
END TYPE fun_del
we can declare an array of that type:
TYPE(fun_del), DIMENSION(10, 20) :: tar
and a reference like tar(n, 2) is an element (a scalar!) of type fun_del, but tar(n, 2)%du is an array of type real, and tar(n, 2)%du(2) is an element of it. The basic rule to remember is that an array element
always has a subscript or subscripts qualifying at least the last name.
Array subobjects (sections)
The general form of subscript for an array
section is
'lower'': 'upper'' ''stride''
(where indicates an optional item) as in
REAL a(10, 10)
a(i, 1:n) ! part of one row
a(1:m, j) ! part of one column
a(i, : ) ! whole row
a(i, 1:n:3) ! every third element of row
a(i, 10:1:-1) ! row in reverse order
a( (/ 1, 7, 3, 2 /), 1) ! vector subscript
a(1, 2:11:2) ! 11 is legal as not referenced
a(:, 1:7) ! rank two section
Note that a vector subscript with duplicate values cannot appear on the
left-hand side of an assignment as it would be ambiguous. Thus,
b( (/ 1, 7, 3, 7 /) ) = (/ 1, 2, 3, 4 /)
is illegal. Also, a section with a vector subscript must not be supplied
as an actual argument to an OUT
or INOUT
dummy argument. Arrays of arrays are not allowed:
tar%du ! illegal
We note that a given value in an array can be referenced both as an
element and as a section:
a(1, 1) ! scalar (rank zero)
a(1:1, 1) ! array section (rank one)
depending on the circumstances or requirements. By qualifying objects of
derived type, we obtain elements or sections depending on the rule stated
earlier:
tar%u ! array section (structure component)
tar(1, 1)%u ! component of an array element
Arrays intrinsic functions
''Vector and matrix multiply''
DOT_PRODUCT Dot product of 2 rank-one arrays
MATMUL Matrix multiplication
''Array reduction''
ALL True if all values are true
ANY True if any value is true. Example:
IF (ANY( a > b)) THEN
COUNT Number of true elements in array
MAXVAL Maximum value in an array
MINVAL Minimum value in an array
PRODUCT Product of array elements
SUM Sum of array elements
''Array inquiry''
ALLOCATED Array allocation status
LBOUND Lower dimension bounds of an array
SHAPE Shape of an array (or scalar)
SIZE Total number of elements in an array
UBOUND Upper dimension bounds of an array
''Array construction''
MERGE Merge under mask
PACK Pack an array into an array of rank one under a mask
SPREAD Replicate array by adding a dimension
UNPACK Unpack an array of rank one into an array under mask
''Array reshape''
RESHAPE Reshape an array
''Array manipulation''
CSHIFT Circular shift
EOSHIFT End-off shift
TRANSPOSE Transpose of an array of rank two
''Array location''
MAXLOC Location of first maximum value in an array
MINLOC Location of first minimum value in an array
Pointers
Basics
Pointers are variables with the POINTER
attribute; they are not a
distinct data type (and so no 'pointer arithmetic' is possible).
REAL, POINTER :: var
They are conceptually a descriptor listing the attributes of the objects
(targets) that the pointer may point to, and the address, if any, of a target.
They have no associated storage until it is allocated or otherwise associated
(by pointer assignment, see below
Below may refer to:
*Earth
*Ground (disambiguation)
*Soil
*Floor
*Bottom (disambiguation)
Bottom may refer to:
Anatomy and sex
* Bottom (BDSM), the partner in a BDSM who takes the passive, receiving, or obedient role, to that of the top or ...
):
ALLOCATE (var)
and they are dereferenced automatically, so no special symbol required. In
var = var + 2.3
the value of the target of var is used and modified. Pointers cannot be
transferred via I/O. The statement
WRITE *, var
writes the value of the target of var and not the pointer descriptor
itself.
A pointer can point to another pointer, and hence to its target, or to a
static object that has the TARGET
attribute:
REAL, POINTER :: object
REAL, TARGET :: target_obj
var => object ! pointer assignment
var => target_obj
but they are strongly typed:
INTEGER, POINTER :: int_var
var => int_var ! illegal - types must match
and, similarly, for arrays the ranks as well as the type must agree.
A pointer can be a component of a derived type:
TYPE entry ! type for sparse matrix
REAL :: value
INTEGER :: index
TYPE(entry), POINTER :: next ! note recursion
END TYPE entry
and we can define the beginning of a linked chain of such entries:
TYPE(entry), POINTER :: chain
After suitable allocations and definitions, the first two entries could be
addressed as
chain%value chain%next%value
chain%index chain%next%index
chain%next chain%next%next
but we would normally define additional pointers to point at, for
instance, the first and current entries in the list.
Association
A pointer's association status is one of
Some care has to be taken not to leave a pointer 'dangling' by
use of DEALLOCATE
on its target without nullifying any other pointer referring
to it.
The intrinsic function ASSOCIATED
can test the association status of a
defined pointer:
IF (ASSOCIATED(pointer)) THEN
or between a defined pointer and a defined target (which may, itself, be a
pointer):
IF (ASSOCIATED(pointer, target)) THEN
An alternative way to initialize a pointer, also in a specification statement,
is to use the NULL
function:
REAL, POINTER, DIMENSION(:) :: vector => NULL() ! compile time
vector => NULL() ! run time
Pointers in expressions and assignments
For intrinsic types we can
'sweep' pointers over different sets of target data using the same code without
any data movement. Given the matrix manipulation ''y = B C z'', we can write the
following code (although, in this case, the same result could be achieved more
simply by other means):
REAL, TARGET :: b(10,10), c(10,10), r(10), s(10), z(10)
REAL, POINTER :: a(:,:), x(:), y(:)
INTEGER mult
:
DO mult = 1, 2
IF (mult 1) THEN
y => r ! no data movement
a => c
x => z
ELSE
y => s ! no data movement
a => b
x => r
END IF
y = MATMUL(a, x) ! common calculation
END DO
For objects of derived type we have to distinguish between pointer and
normal assignment. In
TYPE(entry), POINTER :: first, current
:
first => current
the assignment causes first to point at current, whereas
first = current
causes current to overwrite first and is equivalent to
first%value = current%value
first%index = current%index
first%next => current%next
Pointer arguments
If an actual argument is a pointer then, if the dummy
argument is also a pointer,
* it must have same rank,
* it receives its association status from the actual argument,
* it returns its final association status to the actual argument (note: the target may be undefined!),
* it may not have the INTENT
attribute (it would be ambiguous),
* it requires an interface block.
If the dummy argument is not a
pointer, it becomes associated with the target of the actual argument:
REAL, POINTER :: a (:,:)
:
ALLOCATE (a(80, 80))
:
CALL sub(a)
:
SUBROUTINE sub(c)
REAL c(:, :)
Pointer functions
Function results may also have the POINTER
attribute;
this is useful if the result size depends on calculations performed in the
function, as in
USE data_handler
REAL x(100)
REAL, POINTER :: y(:)
:
y => compact(x)
where the module data_handler contains
FUNCTION compact(x)
REAL, POINTER :: compact(:)
REAL x(:)
! A procedure to remove duplicates from the array x
INTEGER n
: ! Find the number of distinct values, n
ALLOCATE(compact(n))
: ! Copy the distinct values into compact
END FUNCTION compact
The result can be used in an expression (but must be associated with a
defined target).
Arrays of pointers
These do not exist as such: given
TYPE(entry) :: rows(n)
then
rows%next ! illegal
would be such an object, but with an irregular storage pattern. For this
reason they are not allowed. However, we can achieve the same effect by defining
a derived data type with a pointer as its sole component:
TYPE row
REAL, POINTER :: r(:)
END TYPE
and then defining arrays of this data type
TYPE(row) :: s(n), t(n)
where the storage for the rows can be allocated by, for instance,
DO i = 1, n
ALLOCATE (t(i)%r(1:i)) ! Allocate row i of length i
END DO
The array assignment s = t is then equivalent to the pointer assignments s(i)%r => t(i)%r for all components.
Pointers as dynamic aliases
Given an array
REAL, TARGET :: table(100,100)
that is frequently referenced with the fixed subscripts
table(m:n, p:q)
these references may be replaced by
REAL, DIMENSION(:, :), POINTER :: window
:
window => table(m:n, p:q)
The subscripts of window are 1:n-m+1, 1:q-p+1 . Similarly, for tar%u
(as defined in already), we can use, say, taru => tar%u to point at all the u components of tar, and subscript it as taru(1, 2)
The subscripts are as those of tar itself. (This replaces yet more of EQUIVALENCE
.)
In the pointer association
pointer => array_expression
the lower bounds for pointer
are determined as if lbound
was applied to array_expression
. Thus, when a pointer is assigned to a whole array variable, it inherits the lower bounds of the variable, otherwise, the lower bounds default to 1.
Fortran 2003 allows specifying arbitrary lower bounds on pointer association, like
window(r:,s:) => table(m:n,p:q)
so that the bounds of window
become r:r+n-m,s:s+q-p
.
Fortran 95 does not have this feature; however, it can be simulated using the
following trick (based on the pointer association rules for assumed shape array dummy arguments):
FUNCTION remap_bounds2(lb1,lb2,array) RESULT(ptr)
INTEGER, INTENT(IN) :: lb1,lb2
REAL, DIMENSION(lb1:,lb2:), INTENT(IN), TARGET :: array
REAL, DIMENSION(:,:), POINTER :: ptr
ptr => array
END FUNCTION
:
window => remap_bounds2(r,s,table(m:n,p:q))
The source code of an extended example of the use of pointers to support a
data structure is in tp://ftp.numerical.rl.ac.uk/pub/MRandC/pointer.f90 pointer.f90
Intrinsic procedures
Most of the intrinsic functions have already been mentioned. Here, we deal
only with their general classification and with those that have so far been
omitted. All intrinsic procedures can be used with keyword arguments:
CALL DATE_AND_TIME (TIME=t)
and many have optional arguments.
The intrinsic procedures are grouped into four categories:
# elemental - work on scalars or arrays, e.g. ABS(a)
;
# inquiry - independent of value of argument (which may be undefined), e.g. PRECISION(a)
;
# transformational - array argument with array result of different shape, e.g. RESHAPE(a, b)
;
# subroutines, e.g. SYSTEM_CLOCK
.
The procedures not already
introduced are
Bit inquiry
BIT_SIZE Number of bits in the model
Bit manipulation
BTEST Bit testing
IAND Logical AND
IBCLR Clear bit
IBITS Bit extraction
IBSET Set bit
IEOR Exclusive OR
IOR Inclusive OR
ISHFT Logical shift
ISHFTC Circular shift
NOT Logical complement
Transfer function, as in
INTEGER :: i = TRANSFER('abcd', 0)
(replaces part of EQUIVALENCE)
Subroutines
DATE_AND_TIME Obtain date and/or time
MVBITS Copies bits
RANDOM_NUMBER Returns pseudorandom numbers
RANDOM_SEED Access to seed
SYSTEM_CLOCK Access to system clock
CPU_TIME Returns processor time in seconds
Data transfer
(This is a subset only of the actual features and, exceptionally, lower case is used
in the code examples.)
Formatted input/output
These examples illustrate various forms of I/O lists with some simple formats (see below
Below may refer to:
*Earth
*Ground (disambiguation)
*Soil
*Floor
*Bottom (disambiguation)
Bottom may refer to:
Anatomy and sex
* Bottom (BDSM), the partner in a BDSM who takes the passive, receiving, or obedient role, to that of the top or ...
):
integer :: i
real, dimension(10) :: a
character(len=20) :: word
print "(i10)", i
print "(10f10.3)", a
print "(3f10.3)", a(1),a(2),a(3)
print "(a10)", word(5:14)
print "(3f10.3)", a(1)*a(2)+i, sqrt(a(3:4))
Variables, but not expressions, are equally valid in input
statements using the read
statement:
read "(i10)", i
If an array appears as an item, it is treated as if the elements were specified in array element order.
Any pointers in an I/O list must be associated with a target, and transfer takes place between the file and the targets.
An item of derived type is treated as if the components were specified
in the same order as in the type declaration, so
read "(8f10.5)", p, t ! types point and triangle
has the same effect as the statement
read "(8f10.5)", p%x, p%y, t%a%x, t%a%y, t%b%x, &
t%b%y, t%c%x, t%c%y
An object in an I/O list is not permitted to be of a derived type
that has a pointer component at any level of component selection.
Note that a zero-sized array
may occur as an item in an I/O list.
Such an item corresponds to no actual data transfer.
The format specification may also
be given in the form of a character expression:
character(len=*), parameter :: form="(f10.3)"
:
print form, q
or as an asterisk this is a type of I/O known as
''list-directed''
I/O (see below
Below may refer to:
*Earth
*Ground (disambiguation)
*Soil
*Floor
*Bottom (disambiguation)
Bottom may refer to:
Anatomy and sex
* Bottom (BDSM), the partner in a BDSM who takes the passive, receiving, or obedient role, to that of the top or ...
), in which the format is defined by the computer system:
print *, "Square-root of q = ", sqrt(q)
Input/output operations are used to transfer data between the
storage of an executing program and an external medium, specified by a ''unit number''.
However, two I/O statements, print
and a variant of
read
, do not
reference any unit number: this is referred to as terminal I/O.
Otherwise the form is:
read (unit=4, fmt="(f10.3)") q
read (unit=nunit, fmt="(f10.3)") q
read (unit=4*i+j, fmt="(f10.3)") a
where unit=
is optional.
The value may be any nonnegative integer allowed by the system
for this purpose (but 0, 5 and 6 often denote the error, keyboard and terminal, respectively).
An asterisk is a variantagain from the keyboard:
read (unit=*, fmt="(f10.3)") q
A read with a unit specifier allows exception handling
In computing and computer programming, exception handling is the process of responding to the occurrence of ''exceptions'' – anomalous or exceptional conditions requiring special processing – during the execution of a program. In general, an ...
:
read (unit=nunit, fmt="(3f10.3)", iostat=ios) a,b,c
if (ios 0) then
! Successful read - continue execution.
:
else
! Error condition - take appropriate action.
call error (ios)
end if
There a second type of formatted output statement, the
write
statement:
write (unit=nout, fmt="(10f10.3)", iostat=ios) a
Internal files
These allow format conversion between various representations to be carried out by the program in a storage area defined within the program itself.
integer, dimension(30) :: ival
integer :: key
character(len=30) :: buffer
character(len=6), dimension(3), parameter :: form=(/ "(30i1)", "(15i2)","(10i3)" /)
read (unit=*, fmt="(a30,i1)") buffer, key
read (unit=buffer, fmt=form (key)) ival(1:30/key)
If an internal file is a scalar, it has a single record whose length is that of the scalar.
If it is an array, its elements, in array element order, are treated as successive records of the file and each has length that of an array element.
An example using a write
statement is
integer :: day
real :: cash
character(len=50) :: line
:
! write into line
write (unit=line, fmt="(a, i2, a, f8.2, a)") "Takings for day ", day, " are ", cash, " dollars"
that might write
Takings for day 3 are 4329.15 dollars
List-directed I/O
An example of a read without a specified format for input is
integer :: i
real :: a
complex, dimension(2) :: field
logical :: flag
character(len=12) :: title
character(len=4) :: word
:
read *, i, a, field, flag, title, word
If this reads the input record
10 6.4 (1.0,0.0) (2.0,0.0) t test/
(in which blanks are used as separators),
then i
, a
,
field
, flag
, and title
will acquire the values 10, 6.4,
(1.0,0.0) and (2.0,0.0), .true.
and test
respectively,
while word
remains unchanged.
Quotation marks or apostrophes are required as delimiters for a string that
contains a blank.
Non-advancing I/O
This is a form of reading and writing
without always advancing the file position to ahead of the next record.
Whereas an advancing I/O statement always repositions the file after the last
record accessed, a non-advancing I/O statement performs no
such repositioning and may therefore leave the file positioned within a
record.
character(len=3) :: key
integer :: u, s, ios
:
read(unit=u, fmt="(a3)", advance="no", size=s, iostat=ios) key
if (ios 0) then
:
else
! key is not in one record
key(s+1:) = ""
:
end if
A non-advancing read might read the first
few characters of a record and a normal read the remainder.
In order to write a prompt to a
terminal screen and to read from the next character position on the
screen without an intervening line-feed, we can write
write (unit=*, fmt="(a)", advance="no") "enter next prime number:"
read (unit=*, fmt="(i10)") prime_number
Non-advancing I/O is for external files, and is
not available for list-directed I/O.
Edit descriptors
It is possible to specify that an edit descriptor be repeated a specified number of times,
using a ''repeat count'': 10f12.3
The slash edit descriptor (see below
Below may refer to:
*Earth
*Ground (disambiguation)
*Soil
*Floor
*Bottom (disambiguation)
Bottom may refer to:
Anatomy and sex
* Bottom (BDSM), the partner in a BDSM who takes the passive, receiving, or obedient role, to that of the top or ...
)
may have a repeat count, and a repeat count
can also apply to a group of edit
descriptors, enclosed in parentheses, with nesting:
print "(2(2i5,2f8.2))", i(1),i(2),a(1),a(2), i(3),i(4),a(3),a(4)
Entire format specifications can be repeated:
print "(10i8)", (/ (i(j), j=1,200) /)
writes 10 integers, each occupying 8 character positions, on each of 20 lines (repeating the format specification advances to the next line).
Data edit descriptors
Control edit descriptors
''Control edit descriptors setting conditions'':
''Control edit descriptors for immediate processing'':
Unformatted I/O
This type of I/O should be used only in cases where the records are
generated by a program on one computer, to be read back on the same
computer or another computer using the
same internal number representations:
open(unit=4, file='test', form='unformatted')
read(unit=4) q
write(unit=nout, iostat=ios) a ! no fmt=
Direct-access files
This form of I/O is also known as random access or indexed I/O.
Here, all the records have the same
length, and each
record is identified by an index number. It is possible to write,
read, or re-write any specified record without regard to position.
integer, parameter :: nunit=2, length=100
real, dimension(length) :: a
real, dimension(length+1:2*length) :: b
integer :: i, rec_length
:
inquire (iolength=rec_length) a
open (unit=nunit, access="direct", recl=rec_length, status="scratch", action="readwrite")
:
! Write array b to direct-access file in record 14
write (unit=nunit, rec=14) b
:
!
! Read the array back into array a
read (unit=nunit, rec=14) a
:
do i = 1, length/2
a(i) = i
end do
!
! Replace modified record
write (unit=nunit, rec=14) a
The file must be an external file and
list-directed formatting and non-advancing I/O are
unavailable.
Operations on external files
Once again, this is an overview only.
File positioning statements
The open
statement
The statement is used to connect an external file to a unit,
create a file that is preconnected, or create a file and connect it to a
unit.
The syntax is
open (unit=u, status=st, action=act olist
where olist
is a list of optional specifiers.
The specifiers may appear in any order.
open (unit=2, iostat=ios, file="cities", status="new", access="direct", &
action="readwrite", recl=100)
Other specifiers are form
and position
.
The close
statement
This is used to disconnect a file from a unit.
close (unit=u iostat=ios status=st
as in
close (unit=2, iostat=ios, status="delete")
The inquire
statement
At any time during the execution of a program it is possible to inquire about the status and attributes of a file using this statement.
Using a variant of this statement, it is similarly possible to determine the status of a unit, for instance whether the unit number exists for that system.
Another variant permits an inquiry about the length of an output list when used to write an unformatted record.
For inquire by unit
inquire (unit=u, ilist)
or for inquire by file
inquire (file=fln, ilist)
or for inquire by I/O list
inquire (iolength=length) olist
As an example
logical :: ex, op
character (len=11) :: nam, acc, seq, frm
integer :: irec, nr
inquire (unit=2, exist=ex, opened=op, name=nam, access=acc, sequential=seq, form=frm, &
recl=irec, nextrec=nr)
yields
ex .true.
op .true.
nam cities
acc DIRECT
seq NO
frm UNFORMATTED
irec 100
nr 1
(assuming no intervening read or write operations).
Other specifiers are iostat, opened, number,
named, formatted, position, action, read, write, readwrite
.
References
{{DEFAULTSORT:Fortran Language Features
Features
Feature may refer to:
Computing
* Feature (CAD), could be a hole, pocket, or notch
* Feature (computer vision), could be an edge, corner or blob
* Feature (software design) is an intentional distinguishing characteristic of a software item ...