This glossary contains terms that are commonly used in this manual
and the Compaq Fortran 77 user manuals. The terms and short
descriptions are informative and are not part of the standard
definition of the Fortran programming language.
The performance guide for Compaq Fortran 77 for OpenVMS VAX systems
has an additional glossary containing terms describing specific
performance features.
- 3f library routines (U*X)
-
Compaq Fortran 77 library routines (in reference page section 3f)
that handle the various differences between Compaq Fortran 77 and C
in argument passing and data types. Some 3f routines are language
interface routines that make appropriate system calls or call
library routines. You can call these routines from Compaq Fortran 77
programs. For a list of 3f routines, see the
intro(3f)
reference page.
- absolute pathname (U*X, NT)
-
A directory path specified in fixed relationship to the root
directory. On Tru64 UNIX systems, the first character is a slash
(/). On NT systems, the first character is a backslash (\).
Contrast with relative pathname.
- actual argument
-
A value passed from a calling program unit to a subprogram.
- aggregate reference
-
A reference to a record field that resolves into a reference to a
structured data item (a record structure or substructure).
- alphabetic character
-
A letter of the alphabet (uppercase A through Z and lowercase a
through z).
- alphanumeric
-
Pertaining to letters, digits and other special characters, such as
punctuation marks and mathematical symbols (for example, plus and
minus signs).
- alternate key (VMS)
-
An optional key within the data records in an indexed file, which
can be used to build an alternate index.
- ANSI
-
The American National Standards Institute. An organization through
which accredited organizations create and maintain voluntary
industry standards.
- argument
-
A variable (parameter) passed between a calling routine and a called
routine. See also actual argument
and dummy argument.
- arithmetic expression
-
A numeric constant, variable, or function value, or combination
of these, joined by arithmetic operators and parentheses, so that
the entire expression can be evaluated to produce a single numeric
value. For example,
-L
or X+(Y-4.5)*Z
.
- arithmetic operator
-
A symbol designating an arithmetic operation. In Fortran, the
symbols +, -, *, /, and ** are used to designate addition,
subtraction, multiplication, division, and exponentiation,
respectively.
- array
-
A group of components, called elements, that all have the same data
type and share a common symbolic name. Components of an array are
specified individually with subscripts. See also array element.
- array declaration
-
A program statement specifying an array name, the number of
dimensions it contains, and its dimension bounds. An array
declaration can appear in a DIMENSION, COMMON, or explicit type
statement. See also array name.
- array element
-
An item in an array, identified by the array name followed by one or
more subscripts in parentheses, indicating the element's position in
the array. For example,
B(3)
or A(2,5)
.
- array name
-
The symbolic name associated with an array.
- array name reference
-
A reference to a record field that resolves into a reference to an
array. See also array.
- ASCII
-
The American Standard Code for Information Interchange. A 7-bit
character encoding scheme associating an integer from 0 through 127
with 128 characters. See also multinational character set.
- assignment statement
-
A statement that assigns (stores) the value of an expression on the
right of an equal sign to the storage location of the variable to
the left of the equal sign.
- assumed-size array
-
A dummy array whose size is assumed from the associated actual
argument. The upper bound of its last dimension is specified by
an asterisk (*).
- background process (U*X, NT)
-
A process for which the command interpreter is not waiting. Its
process group differs from that of its controlling terminal, so
it is blocked from most terminal access. Contrast with
foreground process.
- batch process (VMS)
-
A process that runs without user interaction. Contrast with
interactive process.
- big endian
-
A method of data storage in which the least significant bit of a
numeric value spanning multiple bytes is in the highest
addressed byte. Contrast with little endian.
- binary constant
-
A constant that is a string of binary digits (0 or 1) enclosed by
apostrophes and preceded or followed by the letter B.
- binary operator
-
An operator that acts on a pair of operands. The exponentiation,
multiplication, division, and concatenation operators are binary
operators.
- bit constant
-
A constant that is a binary, octal, or hexadecimal number.
- bit field
-
A contiguous group of bits within a binary pattern; they are
specified by a starting bit position and length. The functions
IBSET, IBCLR, BTEST, and IBITS, and the subroutine MVBITS operate
on bit fields.
- blank common block
-
A common block (one or more contiguous areas of storage) without a
name. Common blocks are defined by a COMMON statement.
- block
-
In general, a group of related items treated as a physical unit.
For example, a block can be a sequence of program statements that
perform a specific function, or a set of records accessed as a
single unit.
- block data subprogram
-
A program unit, containing a BLOCK DATA statement and its associated
specification statements, that establishes common blocks and assigns
initial values to the variables in named common blocks.
- bottleneck
-
The slowest process in an executing program. This process determines
the maximum speed of execution.
- bounds
-
See dimension bounds.
- breakpoint
-
A critical point in a program, during which execution is stopped
so that you can see if the program variables contain the correct
values. Breakpoints are often used to debug programs.
- built-in function
-
See intrinsic function.
- carriage-control character
-
A character in the first position of a printed record that
determines the vertical spacing of the output line.
- character constant
-
A constant that is a string of printable ASCII characters enclosed
by apostrophes ('). On Alpha processors, the string can also be
enclosed by quotation marks (").
- character expression
-
A character constant, variable, function value, or another constant
expression, separated by a concatenation operator (//); for
example,
DAY//' FIRST'
.
- character storage unit
-
The amount of storage needed to represent one scalar character
value. In Compaq Fortran 77, one character storage unit is
equivalent to one byte of memory.
- character string
-
A sequence of contiguous characters; a character data value. See
also character constant.
- character substring
-
One or more contiguous characters in a character string.
- character type
-
A data type consisting of alphanumeric characters. See also
data type.
- comment
-
Text that documents or explains a program, and begins with a
letter C (or c) or an asterisk (*) in column 1 of a source line.
(Note that the letter C can also denote a compiler directive.)
A comment can also begin with an exclamation point (!), which
can appear anywhere in a source line-except in a Hollerith or
character constant, in column 6 of a fixed-format line, or inside
a placeholder (associated with the compiler option DESIGN on VAX
processors). The comment extends from the exclamation point to the
end of the line. The Fortran compiler does not process comments,
but shows them in program listings. See also
compiler directive.
- common block
-
A storage area (area in memory) shared by one or more program units.
This storage area is defined by a COMMON statement. If the common
block is given a name, it is a named common block; if it is not
given a name, it is a blank common block. See also
blank common block and
named common block.
- compiler directive
-
A statement that tells the compiler to perform certain tasks when
it compiles a source program unit. The tag CDEC$ (and CPAR$ on VAX
processors) must appear in columns 1 through 5.
- complex constant
-
A constant that is a pair of real or integer constants representing
a complex number; the pair is separated by a comma and enclosed
in parentheses. The first constant represents the real part of
the number; the second constant represents the imaginary part. In
Compaq Fortran 77, there are two types of complex constants: COMPLEX
(COMPLEX*8) and DOUBLE COMPLEX (COMPLEX*16).
- complex type
-
A data type that represents the values of complex numbers. The value
is expressed as a complex constant. See also data type.
- concatenate
-
The combination of two items into one by placing one of the items
after the other. In Fortran, the concatenation operator (//)
is used to combine character items. See also
character expression.
- conservative automatic inlining
-
The inline expansion of small procedures, with conservative
heuristics to limit extra code.
- constant
-
A data item with a fixed value that does not change during the
execution of a program. The value of a constant can be numeric or
logical, or it can be a character string. For the precise ranges of
numeric constants, see Section E.3.
Contrast with variable.
- contiguous
-
Pertaining to entities that are adjacent (next to one another)
without intervening spaces; for example, contiguous characters or
contiguous areas of storage.
- control statement
-
A statement that alters the normal order of execution by
transferring control to another section of a program unit or a
subprogram. A control statement can be conditional (such as the
IF or computed GO TO statement) or unconditional (such as the STOP
or GO TO statement).
- critical region
-
A section of code (such as parallel DO-loops) that must execute
serially (sequentially) to achieve correct results.
- data item
-
A unit of data (or value) to be processed. Includes constants,
variables, arrays, character substrings, or records.
- data type
-
The properties and internal representation that characterize data
and functions. The basic data types are integer, real, complex,
logical, and character.
- data type declaration
-
See type declaration statement.
- data type length specifier
-
The form *n appended to a data type name. For example, the *4 in
REAL*4.
- denormalized number (Alpha)
-
A computational floating-point result smaller than the lowest value
in the normal range of a data type (the smallest representable
normalized number) that gradually underflows and loses precision
until it reaches the smallest representable subnormal value (>= 0)
for that data type. You cannot write a constant for a denormalized
number.
- dimension
-
A range of values for one subscript or index of an array. An array
can have from 1 to 7 dimensions.
- dimension bounds
-
For a named array, the limits within which the values of the
subscripts of its array elements must lie. These bounds are
specified in an array declaration. See also array
declaration.
- direct access
-
A method for retrieving or storing data in which the data (record)
is identified by the record number, or the position of the record
in the file. The record is accessed directly (nonsequentially);
therefore, all information is equally accessible. Also called random
access. Contrast with sequential access.
- double-precision constant
-
A processor approximation to the value of a real number that
occupies 8 bytes of memory and can assume a positive, negative,
or zero value. The precision is greater than a constant of real
(single-precision) type. For the precise ranges of double-precision
constants, see Section E.3. See
also denormalized number (Alpha).
- driver program (U*X, NT)
-
A program that is the user interface to the language compiler.
It accepts command options and file names and causes one or more
language utilities or system programs to process each file.
- dummy aliasing
-
The sharing of memory locations between dummy (formal) arguments and
other dummy arguments or COMMON variables that are assigned.
- dummy argument
-
A variable name used in a function or subroutine that accepts the
calling program unit's actual argument value. Dummy arguments are
defined in FUNCTION statements, SUBROUTINE statements, and statement
function definitions.
- edit descriptor
-
A nonrepeatable format descriptor that directly displays text or
affects the conversions performed by subsequent field descriptors.
- element
-
See array element.
- end-of-file
-
The condition that exists when all records in a file open for
sequential access have been read.
- error number
-
A small integer value denoting an I/O error condition, obtained by
using the IOSTAT keyword in an I/O statement.
- executable statement
-
A Fortran statement that specifies an action to be performed.
- expression
-
A scalar field reference, a function reference, or a combination
of these, joined by operators so that the expression can be reduced
to a single value. An expression can have any of the Fortran data
types.
- extension
-
See language extension.
- external file
-
A sequence of records that exists in a medium external to the
executing program.
- external routine
-
A procedure or function called from outside the program in which the
program is defined. Also called an external subprogram.
- field
-
(1) A set of contiguous characters, considered as a single item, in
a record or line. (2) A substructure of a STRUCTURE declaration.
- field descriptor
-
A repeatable format descriptor that causes the transfer or
conversion of data to or from its internal representation.
- field separator
-
The comma (,) or slash (/) that separates edit descriptors or field
descriptors in a format specification.
- field width
-
The size in characters of the field. See also field,
definition 1.
- file
-
A collection of logically related records. If the file is in
internal storage, it is an internal file; if the file is on an input/output
device, it is an external file.
- file access
-
The way records are accessed (and stored) in a file. The Fortran
file access modes are sequential and direct. On OpenVMS systems, you
can also use a keyed mode of access.
- file organization
-
The way records in a file are physically arranged on a storage
device. Fortran files can have sequential or relative organization.
On OpenVMS systems, files can also have indexed organization.
- fixed-length record type
-
A file format in which all the records are the same length.
- fixed-point
-
Pertaining to a type of computation with real numbers in which the
decimal point separating whole numbers and fractions is located
in a single, unchanging (fixed) position. For example, 99.9 is a
fixed-point real number. Contrast with floating-point.
- floating-point
-
Pertaining to a type of computation (or data type) with real or
complex numbers expressed in scientific notation. In this notation,
a number is expressed as a factor multiplied by an appropriate power
of 10. The decimal point "floats" to store the maximum number of
significant digits. For example, 864.5 can be expressed as 0.8645
* 10**3 (or 0.8645E3). Contrast with fixed-point.
See also denormalized number (Alpha).
- foreground process (U*X, NT)
-
A process for which the command interpreter is waiting. Its
process group is the same as that of its controlling terminal,
so the process is allowed to read from or write to the terminal.
Contrast with background process.
- foreign file
-
An unformatted file that contains data from a foreign platform, such
as data from a CRAY, IBM, or big endian IEEE machine.
- format
-
A specific arrangement of data. A FORMAT statement specifies how
data is to be read or written.
- format specification
-
The part of a FORMAT statement that specifies data arrangement. It
is a list within parentheses that can include field descriptors,
edit descriptors, and field separators.
- formatted data
-
Data written to a file by using formatted I/O statements. Such data
contains ASCII representations of binary number values.
- formatted I/O statement
-
A statement that contains explicit format specifiers to control the
translation of data from internal (binary) form within a program to
external (readable character) form in the records, or vice versa.
- full pathname (U*X, NT)
-
See absolute pathname.
- function
-
See function subprogram.
- function reference
-
A reference, in an expression, consisting of a function name and
its arguments. A function reference returns a value that is used in
evaluating the expression in which the function appears.
- function subprogram
-
A series of statements that perform some operation and return a
single value (through the function name) to the calling program
unit. A function subprogram begins with a FUNCTION (or optional
OPTIONS) statement and is invoked by a function reference in a main
program unit or a subprogram unit. See also
subroutine subprogram and
statement function.
- global optimization
-
A level of optimization enabling code motion, strength reduction,
split life analysis, instruction scheduling, and inlining of
arithmetic functions. Global optimization can be thought of as
optimization within a program unit (across statements).
Additional global optimization is a level of optimization
that improves speed at the cost of increasing the size of the
OpenVMS object module, Tru64 UNIX object file, or NT object file.
This optimization includes interprocedural analysis, inlining
procedures, multiplication and division expansion, loop unrolling,
and code replication. Additional global optimization can be
thought of as optimization across program units. See also
optimization.
- global section
-
A data structure (for example, global COMMON) or shareable image
section potentially available to all processes in the system.
- global symbol
-
A symbol name defined in a OpenVMS module (such as a source, object,
or image module), Tru64 UNIX object file, or NT object file that is
available for reference by another module or object file.
- hexadecimal constant
-
A constant that is a string of hexadecimal digits (range 0 to 9,
or an uppercase or lowercase letter in the range A to F) enclosed
by apostrophes and followed by the letter X. The letter X can
alternatively precede the string, and the letter Z can alternatively
precede or follow the string.
- Hollerith constant
-
A constant that is a string of printable ASCII characters preceded
by nH, where n is the number of characters in the string (including
spaces and tabs).
- implicit typing
-
The specification of the type of data to be stored in a variable by
the beginning letter of the symbolic (variable) name.
- index
-
(1) The variable used as a loop counter in a DO statement. (2) An
intrinsic function specifying the starting position of a substring
inside a string. (3) On OpenVMS systems, an internal data structure
that provides a guide, based on key values, to file components in an
indexed file.
- indexed file organization (VMS)
-
A file organization that allows random retrieval of records by
key value and sequential retrieval of records within the key of
reference. Each file contains records and a primary key index (and,
optionally, one or more alternate key indexes).
- initialize
-
The assignment of an initial value to a variable.
- input/output (I/O)
-
The data that a program reads or writes. Also, devices to read and
write data.
- integer constant
-
A constant that is a whole number with no decimal point. It can
have a leading sign and is interpreted as a decimal number. For the
precise ranges of integer constants, see
Section E.3.
- interactive process
-
A process that must periodically get user input to do its work.
Contrast with batch process (VMS) or
background process (U*X).
- internal file
-
The designated internal storage space (or variable buffer) that
is manipulated during input and output. An internal file can be
a character variable, character array, character array element,
or character substring. In general, an internal file contains one
record. However, an internal file that is a character array has one
record for each array element.
- intrinsic function
-
Supplied as a part of the Fortran library, a subprogram that
performs mathematical, numeric, character, bit manipulation, and
other miscellaneous functions. Also called a built-in or library
function. See also 3f library routines (U*X).
- invoke
-
To call upon; used especially with reference to subprograms. For
example, to invoke a function is to execute the function.
- I/O
-
See input/output.
- iteration count
-
The number of executions of the DO range, which is determined as
follows:
[(terminal value - initial value + increment value) / increment value]
- key (VMS)
-
A value in a file of indexed organization that OpenVMS systems
use to build indexes into the file. Each key is identified by its
location within the component, its length, and its data type. Also
called the key field. See also alternate key,
index, and
primary key.
- keyed access (VMS)
-
A method for retrieving or writing data in which the data (a record)
is identified by specifying the information in a key field of the
record. See also key.
- key of reference (VMS)
-
A key used by OpenVMS systems to determine the index to use when
sequentially accessing components of an indexed file. See
also key,
indexed file organization, and
sequential access.
- label
-
See statement label.
- language extension
-
A Compaq Fortran 77 language element that is not part of the
FORTRAN-77 standard.
- library function
-
See intrinsic function.
- linker
-
A system program that creates an executable program from one or more
OpenVMS object modules, Tru64 UNIX object files, or NT object files
produced by a language compiler or assembler. The linker resolves
external references, acquires referenced library routines, and
performs other processing required to create OpenVMS executable
images, Tru64 UNIX executable files, or NT executable files.
- list-directed I/O statement
-
An I/O statement that uses a data list (as do namelist I/O
statements) instead of using explicit format specifiers. Input
is accomplished by
READ *, list
; output
by WRITE *, list
. Contrast with
formatted I/O statement.
- listing
-
A printed copy of a program.
- little endian
-
A method of data storage in which the least significant bit of a
numeric value spanning multiple bytes is in the lowest
addressed byte. This is the method used on Compaq (formerly DIGITAL)
systems. Contrast with big endian.
- local optimization
-
A level of optimization enabling optimizations within the source
program unit and recognition of common expressions. See
also optimization.
- local symbol
-
A name defined in a program unit that is not accessible outside of
that program unit.
- logical constant
-
A constant that specifies the value .TRUE. or .FALSE..
- logical expression
-
An integer or logical constant, variable, function value, or another
constant expression, joined by a relational or logical operator. The
logical expression is evaluated to a value of either true or false.
For example,
.NOT. 6.5 + (B .GT. D)
.
- logical operator
-
A symbol that represents an operation on logical expressions. The
logical operators are .AND., .OR., .NEQV., .XOR., .EQV., and .NOT..
- logical unit
-
A channel in memory through which data transfer occurs between the
program and the device or file. See also unit identifier.
- longword
-
Four contiguous bytes (32 bits) starting on any addressable byte
boundary. Bits are numbered 0 to 31. The address of the longword
is the address of the byte containing bit 0. When the longword is
interpreted as a signed integer, bit 31 is the sign bit. The value
of signed integers is in the range -2**31 to 2**31-1. The value of
unsigned integers is in the range 0 to 2**32-1.
- loop
-
A group of statements that are executed repeatedly until an ending
condition is reached.
- main program
-
A program unit containing a PROGRAM statement (or not containing a
SUBROUTINE, FUNCTION, or BLOCK DATA statement). The main program
is the first program unit to receive control when a program is
run, and exercises control over subprograms. Contrast with
subprogram.
- makefile (U*X, NT)
-
On Tru64 UNIX systems, an argument passed to the
make
command containing a sequence of entries that specify dependencies.
The contents of a makefile override the system built-in rules
for maintaining, updating, and regenerating groups of programs.
For more information on makefiles on Tru64 UNIX systems, see
make(1)
.
- message file
-
A file (or catalog, in Tru64 UNIX) that contains the diagnostic
message text of errors that may occur during program execution (run
time).
- misaligned data
-
Data not aligned on a natural boundary. See also
natural boundary.
- module
-
A portion of a program or program library, as in a source module,
object module, or image module; a program unit that contains or
causes definitions that other program units can access.
- multinational character set
-
An 8-bit character encoding scheme associating an integer from
128 through 255 with 128 characters. This character set contains
international alphanumeric characters, including characters with
diacritical marks. See also ASCII.
- named common block
-
A common block (one or more contiguous areas of storage) with a
name. Common blocks are defined by a COMMON statement.
- namelist I/O statement
-
An I/O statement that uses a data list (as do list-directed I/O
statements) instead of using explicit format specifiers. Input
is accomplished by
READ namelist
; output
by WRITE namelist
. Contrast with
formatted I/O statement.
- natural boundary
-
The virtual address of a data item that is the multiple of the size
of its data type. For example, a REAL*8 data item aligned on natural
boundaries has an address that is a multiple of eight.
- naturally aligned record
-
A record that is aligned on a natural boundary up to 8 bytes; each
field is naturally aligned. Contrast with
packed record.
- nesting
-
The placing of one structure inside another structure of the same
kind. For example, nesting a loop within another loop (a nested
loop), or nesting a subroutine within another subroutine (a nested
subroutine).
- nonexecutable statement
-
A Fortran statement that describes program attributes, but does not
cause any action to be taken when the program is executed.
- numeric storage unit
-
The amount of storage needed to represent one real, integer, or
logical value. In Compaq Fortran 77, one numeric storage unit is
equivalent to 4 bytes of memory.
- object file (U*X, NT)
-
The binary output of an Tru64 UNIX language processor (such as an
assembler or compiler), which can either be executed or be used as
input to the linker. Contrast with object module.
- object module (VMS)
-
The binary output of a language processor such as the assembler
or a compiler, which is used as input to the linker. Contrast
with object file.
- octal constant
-
A constant that is a string of octal digits (range of 0 to 7)
enclosed by apostrophes and followed by the letter O. The string
can also be preceded by the letter O.
- operand
-
The passive element in an expression on which an operation is
performed. Every expression must have at least one operand. For
example, in
I .NE. J
,
I and J are operands. Contrast with operator.
- operator
-
The active element in an expression that performs an operation.
An expression can have zero or more operators. For example, in
I .NE. J
, .NE. is the operator. Contrast with
operand.
- optimization
-
The process of producing efficient object or executing code that
takes advantage of the hardware architecture to produce more
efficient execution. See also global optimization.
- order of subscript progression
-
A characteristic of a multidimensional array in which the leftmost
subscripts vary most rapidly.
- overflow
-
An error condition occurring when an arithmetic operation yields a
result that is larger than the maximum value in the range of a data
type.
- packed record
-
A record that starts on an arbitrary byte boundary; each field
starts in the next unused byte. Contrast with
naturally aligned record.
- pad
-
The filling of unused positions in a field or character string with
dummy data (such as zeros or blanks).
- parameter
-
(1) In general, any quantity of interest in a given situation; often
used in place of the term "argument." (2) A Fortran named constant.
- passed-length character argument
-
A dummy argument that assumes the length attribute of the
corresponding actual argument. An asterisk (*) specifies the length
of the dummy character argument.
- pathname (U*X, NT)
-
The path from the root directory to a subdirectory or file. See
also root.
- pipe (U*X, NT)
-
A connection that allows one program to get its input directly from
the output of another program.
- platform
-
A combination of operating system and hardware that provides a
distinct environment in which to use a software product. The current
Compaq Fortran 77 platforms are Tru64 UNIX on Alpha, OpenVMS on VAX,
and OpenVMS on Alpha.
- precision
-
The number of significant digits in a real number. See also
double-precision constant and
single-precision constant.
- primary key (VMS)
-
The required key within the data records of an indexed file, which
is used to determine the placement of records within the file and to
build the primary index.
- procedure
-
A computation that can be invoked during program execution. It
can be a subroutine or function, an internal, external, or dummy
procedure, or a statement function. A subprogram can define more
than one procedure if it contains an ENTRY statement. See
also subprogram.
- program
-
A set of instructions that can be compiled and executed by itself.
Program blocks contain a declaration and an executable section.
- program section
-
A particular common block or local data area for a particular
routine containing equivalence groups; used in data-flow analysis.
- program unit
-
A main program or a subprogram; the fundamental component of an
executable program. A sequence of statements and optional comments
that can be a main program, a procedure, an external program, or a
block data program unit.
- quadword
-
Four contiguous words (64 bits) starting on any addressable byte
boundary. Bits are numbered 0 to 63. (Bit 63 is used as the sign
bit.) A quadword is identified by the address of the word containing
the low-order bit (bit 0). The value of the quadword is in the range
-2**63 to 2**63-1.
- random access
-
See direct access.
- real constant
-
A constant that is a number written with a decimal point, exponent,
or both. It can have single precision (REAL*4), double precision
(REAL*8), or quad
precision (REAL*16). For the precise ranges of real constants, see
Section E.3.
- record
-
(1) A set of logically related data items (in a file) that is
treated as a unit; such a record contains one or more fields.
This definition applies to I/O records and items that are declared
RECORD. (2) One or more data items that are grouped in a structure
declaration and specified in a RECORD statement. See also
field and structure declaration.
- record access
-
The method used to store and retrieve records in a file.
- record type
-
The property that determines whether records in a file are all the
same length, of varying length, or use other conventions to define
where one record ends and another begins.
- recursion
-
The act of a routine directly or indirectly calling itself.
- relational expression
-
An expression containing one relational operator and two operands
of numeric or character type. The result is a value that is true or
false. For example,
A-C .GE. B+2
or DAY .EQ. 'MONDAY'
.
- relational operator
-
The symbols used to express a relational condition or expression.
The relational operators are .EQ., .NE., .LT., .LE., .GT., and .GE..
- relative file organization
-
A file organization that consists of a series of component
positions, called cells, numbered consecutively from 1 to n. Compaq
Fortran 77 uses these numbered, fixed-length cells to calculate the
component's physical position in the file.
- relative pathname (U*X, NT)
-
A directory path expressed in relation to any directory other than
the root directory. Contrast with absolute pathname.
- root (U*X)
-
The top-level directory in the Tru64 UNIX file system. The root
directory is represented by a slash (/).
- routine
-
A subprogram; a function or procedure. See also
function subprogram,
subroutine subprogram, and procedure.
- run time
-
The time during which a computer executes the statements of a
program.
- scalar
-
Pertaining to single data items. Contrast with vector.
- scalar memory reference
-
A reference to a scalar variable, scalar record field, or array
element that resolves into a single data item (having a data type)
and can be assigned a value with an assignment statement. It is
similar to a scalar reference, but it excludes constants, character
substrings, and expressions.
- scalar reference
-
A reference to a scalar variable, scalar record field, array
element, constant, character substring, or expression that resolves
into a single data item having a data type. Contrast with
scalar memory reference.
- scalar variable
-
A variable name specifying one storage location. Contrast
with array name.
- scale factor
-
A number indicating the location of the decimal point in a real
number and, if there is no exponent, the size of the number on
input.
- scope
-
The portion of a program in which a declaration or a particular name
has meaning.
- seed
-
A value (which can be assigned to a variable) that is required
in order to properly determine the result of a calculation; for
example, the argument i in the random number generator (RAN)
function syntax:
y = RAN (i)
.
- sequential access
-
A method for retrieving or storing data in which the data (record)
is read from, written to, or removed from a file based on the
logical order (sequence) of the record in the file. (The record
cannot be accessed directly.) Contrast with
direct access.
- sequential file organization
-
A file organization in which records are stored one after the other,
in the order in which they were written to the file.
- short field termination
-
The use of a comma (,) to terminate the field of a numeric
field descriptor. This technique overrides the field width (w)
specification in the field descriptor and therefore avoids padding
of the input field. The comma can only terminate fields less than w
characters long. See also field descriptor.
- signal
-
The software mechanism used to indicate that an exception condition
(abnormal event) has been detected. For example, a signal can be
generated by a program or hardware error, or by request of another
program.
- single-precision constant
-
A processor approximation of the value of a real number that
occupies 4 bytes of memory and can assume a positive, negative,
or zero value. The precision is less than a constant of double-precision type.
For the precise ranges of single-precision
constants, see Section E.3. See
also denormalized number (Alpha).
- source program
-
A program (or code) in a high-level language form. Also called
source code.
- specification statement
-
A nonexecutable statement that provides information about the data
used in the source program. Such a statement can be used to allocate
and initialize variables, arrays, records, and structures, and
define other characteristics of symbolic names used in a program.
- statement
-
An instruction in a programming language that represents a step
in a sequence of actions or a set of declarations. There are two
main classes of statements: executable and nonexecutable. See
also executable statement and
nonexecutable statement.
- statement block
-
A sequence of zero or more statements following a block IF statement
up to, but not including, the next block IF statement. Block IF
statements can begin with IF THEN, ELSE IF THEN, or ELSE, and end
with END IF.
- statement function
-
A computing procedure defined in a single Fortran statement. A
statement function is invoked by a function reference in a main
program unit or a subprogram unit; it must precede all executable
statements and follow all specification statements.
- statement function definition
-
A statement that defines a statement function. Its form is the
statement function name (followed by its optional dummy arguments in
parentheses), followed by an equal sign (=), followed by a numeric,
logical, or character expression. See also
statement function.
- statement label
-
An integer, from 1 to 5 digits long, that is used to identify a
statement. For example, statement labels can be used to refer to a
FORMAT statement, or transfer control.
- static variable
-
A variable whose storage is allocated for the entire execution of a
program.
- storage location
-
An addressable unit of main memory.
- storage unit
-
The amount of storage used to represent one real, integer, logical,
or character value. See also numeric storage unit and
character storage unit.
- structure declaration
-
A block of statements that define the fields in a record. The block
begins with a STRUCTURE statement and ends with END STRUCTURE. The
name of the structure must be specified in a RECORD statement.
- subprogram
-
An external function or subroutine that can be invoked from another
program unit to perform a specific task. Contrast with
main program.
- subroutine
-
See subroutine subprogram.
- subroutine subprogram
-
A procedure that can return many values, a single value, or no
value to the calling program unit (through arguments). A subroutine
subprogram begins with a SUBROUTINE (or optional OPTIONS) statement
and is invoked by a CALL statement in another program unit. See
also function subprogram and
statement function.
- subscript
-
An integer value, enclosed in parentheses and used with an array
name, that specifies the position of an array element. See
also array, array name,
array element.
- subscript expressions
-
A list of expressions, enclosed in parentheses, that determine which
element in the array is being referenced. The subscript is appended
to the array name to which it refers.
- symbolic name
-
A unique name used to identify an entity within a Fortran program
unit. A symbolic name identifies one entity in a program unit (such
as a function or subroutine), or it can identify a common block,
record, structure, structure field, array, or variable.
- syntax
-
The formal structure of a statement or command string.
- transfer list
-
The list of statement labels in a computed GO TO statement; the
labels are separated by commas.
- truncation
-
(1) A technique that approximates a numeric value by dropping its
fractional value and using only the integer portion. (2) The process
of removing one or more characters from the left or right of a
number or string.
- type declaration statement
-
A nonexecutable statement specifying the data type of one or more
variables: an INTEGER, REAL, DOUBLE PRECISION, COMPLEX, DOUBLE
COMPLEX, CHARACTER, LOGICAL, or TYPE statement. Also called a type
declaration or type specification.
- unary operator
-
An operator that operates on one operand. For example, the minus
sign in
-A
and the .NOT. operator in .NOT. (J
.GT. K)
.
- underflow
-
An error condition occurring when the result of an arithmetic
operation yields a result that is smaller than the minimum value
in the range of a data type. For example, in unsigned arithmetic,
underflow occurs when a result is negative. See also
denormalized number (Alpha).
- unformatted data
-
Data written to a file by using unformatted I/O statements; for
example, binary numbers.
- unformatted I/O statements
-
A statement that does not contain format specifiers and therefore
does not translate the data being transferred.
- unformatted record
-
A record that is transmitted in internal format between internal and
external storage.
- unit identifier
-
The number that specifies an external unit or internal file. The
number can be any one of the following:
- An integer expression whose value must be zero or positive
- An asterisk (*) that corresponds to the default input or
output unit
- The name of a character scalar memory reference or
character array name reference for an internal file
Also called a device code, or logical unit number.
- variable
-
A value stored in a memory location that may change during the
execution of a program. A variable has a value that is referenced
by a symbolic name (identifier). See also
symbolic name.
- variable-length record type
-
A file format in which records may be of different lengths.
- vector
-
A data structure comprising scalar elements with the same data type
and organized as a simple linear sequence. Contrast with
scalar.