# Glossary

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.

Previous Page Next Page Table of Contents