# Glossary

This glossary contains terms that are commonly used in this manual and your user manual or programmer's guide. The terms and short descriptions are informative and are not part of the standard definition of the Fortran 95/90 programming language.

  A - B - C - D - E - F - G - H - I - K - L - M - N - O - P - Q - R - S - T - U - V - W - Z

3f library routines
  On Tru64 UNIX and Linux systems, Compaq Fortran library routines (in reference page section 3f) that handle the various differences between Compaq Fortran 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 programs. For a list of 3f routines, see the `intro(3f)` reference page.
absolute pathname
  On Tru64 UNIX, Linux, and Windows systems, a directory path specified in fixed relationship to the root directory. On Tru64 UNIX and Linux systems, the first character is a slash (/). On Windows systems, the first character is a backslash (\).
actual argument
  A value (a variable, expression, or procedure) passed from a calling program unit to a subprogram.
adjustable array
  An explicit-shape array that is a dummy argument to a subprogram. The term is from FORTRAN 77. See also explicit-shape array.
aggregate reference
  A reference to a record structure field.
allocatable array
  A named array that has the ALLOCATABLE attribute. Once space has been allocated for this type of array, the array has a shape and can be defined (and redefined) or referenced. (It is an error to allocate an allocatable array that is currently allocated.)
alphanumeric
  Pertaining to letters and digits.
alternate key
  On OpenVMS systems, an optional key within the data records in an indexed file, which can be used to build an alternate index.
alternate return
  A subroutine argument that permits control to branch immediately to some position other than the statement following the call. The actual argument in an alternate return is the statement label to which control should be transferred.
ANSI
  The American National Standards Institute. An organization through which accredited organizations create and maintain voluntary industry standards.
argument
  See actual argument and dummy argument.
argument association
  The relationship (or "matching up") between an actual argument and dummy argument during the execution of a procedure reference.
argument keyword
  The name of a dummy (formal) argument. The name is used in a subprogram (routine) definition. It can also be used when the subprogram is invoked to associate dummy arguments with actual arguments, so that they can appear in any order.

  Argument keywords are supplied for many of the intrinsic procedures.

array
  A set of scalar data that all have the same type and kind parameters. An array can be referenced by element (using a subscript), by section (using a section subscript list), or as a whole. An array has a rank (up to 7), bounds, size, and a shape. Contrast with scalar. See also bounds, conformable, shape, size, whole array, and zero-sized array.
array constructor
  A mechanism used to specify a sequence of scalar values that produce a rank-one array.

  To construct an array of rank greater than one, you must apply the RESHAPE intrinsic function to the array constructor.

array element
  A scalar item in an array. An array element is 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 pointer
  A pointer to an array. See also array and pointer.
array section
  A subobject (or portion) of an array. It consists of the set of array elements or substrings of this set. The set (or section subscript list) is specified by subscripts, subscript triplets, and vector subscripts. If the set does not contain at least one subscript triplet or vector subscript, the reference indicates an array element, not an array.
array specification
  A program statement specifying an array name and the number of dimensions the array contains (its rank). An array specification can appear in a DIMENSION or COMMON statement, or in a type declaration statement.
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
  Usually, 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. In the case of Fortran 90 pointers, the storage location is assigned, not the pointer itself.
association
  The relationship that allows an entity to be referenced by different names in one scoping unit or by the same or different names in more than one scoping unit. The principal kinds of association are argument association, host association, pointer association, storage association, and use association. See also argument association, host association, pointer association, storage association, and use association.
assumed-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.
assumed-shape array
  A dummy argument array that assumes the shape of its associated actual argument array.
assumed-size array
  A dummy array whose size (only) is assumed from its associated actual argument. The upper bound of its last dimension is specified by an asterisk (*). All other extents (if any) must be specified.
attribute
  A property of a data object that can be specified in a type declaration statement. These properties determine how the data object can be used in a program.
  Most attributes can be alternatively specified in statements. For example, the DIMENSION statement has the same meaning as the DIMENSION attribute appearing in a type declaration statement.
automatic array
  Is an explicit-shape array that is a local variable in a subprogram. It is not a dummy argument, and has bounds that are nonconstant specification expressions. The bounds (and shape) are determined at entry to the procedure by evaluating the bounds expressions. See also automatic object.
automatic object
  A local data object that is created upon entry to a subprogram and disappears when the execution of the subprogram is completed. There are two kinds of automatic objects: arrays (of any data type) and objects of type CHARACTER. Automatic objects cannot be saved or initialized.

  An automatic object is not a dummy argument, but is declared with a specification expression that is not a constant expression. The specification expression can be the bounds of the array or the length of the character object.

background process
  On Tru64 UNIX and Linux systems, 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
  On OpenVMS systems, 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 (base 2) digits (0 or 1) enclosed by apostrophes or quotation marks and preceded 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
  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 group of constructs or statements that perform a task; the task can be executed once, repeatedly, or not at all.
block data program unit
  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. In FORTRAN 77, this was called a block data subprogram.
bottleneck
  The slowest process in an executing program. This process determines the maximum speed of execution.
bounds
  The range of subscript values for elements of an array. The lower bound is the smallest subscript value in a dimension, and the upper bound is the largest subscript value in that dimension. Array bounds can be positive, zero, or negative.

  These bounds are specified in an array specification. See also array specification.

breakpoint
  A critical point in a program, at 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 procedure
  See intrinsic procedure.
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 (') or 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 unit of storage for holding a scalar value of default character type (and character length one) that is not a pointer. One character storage unit corresponds 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.
child process
  A process initiated by another process (the parent). The child process can operate independently from the parent process. See also parent process.
comment
  Text that documents or explains a program. In free source form, a comment begins with an exclamation point (!), unless it appears in a Hollerith or character constant.

  In fixed and tab source form, a comment begins with a letter C or an asterisk (*) in column 1. A comment can also begin with an exclamation point anywhere in a source line (except in a Hollerith or character constant) or in column 6 of a fixed-format line. The comment extends from the exclamation point to the end of the line.

  The compiler does not process comments, but shows them in program listings. See also compiler directive.

common block
  A physical storage area 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. See also blank common and named common block.
compilation unit
  The source file or files that are compiled together to form a single object file, possibly using interprocedural optimization across source files. Only one `f90` command is used for each compilation, but one `f90` command can specify that multiple compilation units be used.
compiler directive
  A structured comment that tells the compiler to perform certain tasks when it compiles a source program unit.
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. The following types of complex constants are available on all systems: COMPLEX (COMPLEX(4)) and DOUBLE COMPLEX (COMPLEX(8)). On OpenVMS, Tru64 UNIX, and Linux systems, COMPLEX(16) is also available.
complex type
  A data type that represents the values of complex numbers. The value is expressed as a complex constant. See also data type.
component
  Part of a derived-type definition. There must be at least one component (intrinsic or derived type) in every derived-type definition.
concatenate
  The combination of two items into one by placing one of the items after the other. In Fortran 95/90, the concatenation operator (//) is used to combine character items. See also character expression.
conformable
  Pertains to dimensionality. Two arrays are conformable if they have the same shape. A scalar is conformable with any array.
conformance
  See shape conformance.
conservative automatic inlining
  The inline expansion of small procedures, with conservative heuristics to limit extra code.
constant
  A data object whose value does not change during the execution of a program; the value is defined at the time of compilation. A constant can be named (using the PARAMETER attribute or statement) or unnamed. An unnamed constant is called a literal constant. The value of a constant can be numeric or logical, or it can be a character string. Contrast with variable.
constant expression
  An expression whose value does not change during program execution.
construct
  A series of statements starting with a DO, CASE, IF, WHERE, or FORALL statement and ending with a corresponding terminal statement.
contiguous
  Pertaining to entities that are adjacent (next to one another) without intervening blanks (spaces); for example, contiguous characters or contiguous areas of storage.
control edit descriptor
  A format descriptor that directly displays text or affects the conversions performed by subsequent data edit descriptors. Except for the slash descriptor, control edit descriptors are nonrepeatable.
control statement
  A statement that alters the normal order of execution by transferring control to another part of a program unit or a subprogram. A control statement can be conditional (such as the IF construct or computed GO TO statement) or unconditional (such as the STOP or GO TO statement).
data abstraction
  A style of programming in which you define types to represent objects in your program, define a set of operations for objects of each type, and restrict the operations to only this set, making the types abstract. The Fortran 95/90 modules, derived types, and defined operators, support this programming paradigm.
data edit descriptor
  A repeatable format descriptor that causes the transfer or conversion of data to or from its internal representation. In FORTRAN 77, this term was called a field descriptor.
data entity
  A data object that has a data type. It is the result of the evaluation of an expression, or the result of the execution of a function reference (the function result).
data item
  A unit of data (or value) to be processed. Includes constants, variables, arrays, character substrings, or records.
data object
  A constant, variable, or subobject of a constant.
data type
  The properties and internal representation that characterize data and functions. Each intrinsic and user-defined data type has a name, a set of operators, a set of values, and a way to show these values in a program. The basic intrinsic data types are integer, real, complex, logical, and character. The data value of an intrinsic data type depends on the value of the type parameter. See also type parameter.
data type declaration
  See type declaration statement.
data type length specifier
  The form *n appended to Compaq Fortran-specific data type names. For example, in REAL*4, the *4 is the data type length specifier.
declaration
  See specification statement.
default character
  The kind for character constants if no kind parameter is specified. Currently, the only kind parameter for character constants is CHARACTER(1), the default character kind.
default complex
  The kind for complex constants if no kind parameter is specified. The default complex kind is affected by compiler options that specify real size. If no compiler option is specified, default complex is COMPLEX(4) (COMPLEX*8). See also default real.
default integer
  The kind for integer constants if no kind parameter is specified. The default integer kind is affected by compiler options that specify integer size. If no compiler option is specified, default integer is INTEGER(4) (INTEGER*4).

  If a compiler option affecting integer size has been specified, the integer has the kind specified, unless it is outside the range of the kind specified by the option. In this case, the kind of the integer is the smallest integer kind which can hold the integer.

default logical
  The kind for logical constants if no kind parameter is specified. The default logical kind is affected by compiler options that specify integer size. If no compiler option is specified, default logical is LOGICAL(4) (LOGICAL*4). See also default integer.
default real
  The kind for real constants if no kind parameter is specified. The default real kind is determined by the compiler option specifying real size. If no compiler option is specified, default real is REAL(4) (REAL*4).

  If a real constant is encountered that is outside the range for the default, an error occurs.

deferred-shape array
  An array pointer (an array with the POINTER attribute) or an allocatable array (an array with the ALLOCATABLE attribute). The size in each dimension is determined by pointer assignment or when the array is allocated.

  The declared bounds are specified by a colon (:).

definable
  A property of variables. A variable is definable if its value can be changed by the appearance of its name or designator on the left of an assignment statement. An example of a variable that is not definable is an allocatable array that has not been allocated.
defined
  For a data object, the property of having or being given a valid value.
defined assignment
  An assignment statement that is not intrinsic, but is defined by a subroutine and an interface block. See also derived type.
defined operation
  An operation that is not intrinsic, but is defined by a function subprogram containing a generic interface block with the specifier OPERATOR. See also interface block.
denormalized number
  A computational floating-point result smaller than the lowest value in the normal range of a data type (the smallest representable normalized number). You cannot write a constant for a denormalized number.
derived type
  A data type that is user-defined and not intrinsic. It requires a type definition to name the type and specify its components (which can be intrinsic or user-defined types). A structure constructor can be used to specify a value of derived type. A component of a structure is referenced using a percent sign (%).

  Operations on objects of derived types (structures) must be defined by a function with an OPERATOR interface. Assignment for derived types can be defined intrinsically, or be redefined by a subroutine with an ASSIGNMENT interface. Structures can be used as procedure arguments and function results, and can appear in input and output lists. Also called a user-defined type. See also record, the first definition.

designator
  A name that references a subobject (part of an object). A designator is the name of the object followed by a selector that selects the subobject. For example, B(3) is a designator for an array element. Also called a subobject designator. See also selector and subobject.
dimension
  A range of values for one subscript or index of an array. An array can have from 1 to 7 dimensions. The number of dimensions is the rank of the array.
dimension bounds
  See bounds.
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 the double-precision constants, see your user manual or programmer's guide. See also denormalized number.
driver program
  On Tru64 UNIX, Linux, and Windows systems, 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 whose name appears in the parenthesized list following the procedure name in a FUNCTION statement, a SUBROUTINE statement, an ENTRY statement, or a statement function statement. A dummy argument takes the value of the corresponding actual argument in the calling program unit (through argument association). Also called a formal argument.
dummy procedure
  Is a dummy argument that is specified as a procedure or appears in a procedure reference. The corresponding actual argument must be a procedure.
edit descriptor
  A descriptor in a format specification. It can be a data edit descriptor, control edit descriptor, or string edit descriptor. See also control edit descriptor, data edit descriptor, and string edit descriptor.
element
  See array element.
elemental
  Pertains to an intrinsic operation, intrinsic procedure, or assignment statement that is independently applied to either of the following:
  - The elements of an array
  - Corresponding elements of a set of conformable arrays and scalars
end-of-file
  The condition that exists when all records in a file open for sequential access have been read.
entity
  A general term referring to any Fortran 95/90 concept; for example, a constant, a variable, a program unit, a statement label, a common block, a construct, an I/O unit and so forth.
environment variable
  A symbolic variable that represents some element of the operating system, such as logical names (on OpenVMS systems) or a path, a filename, or other literal data.
error number
  An integer value denoting an I/O error condition, obtained by using the IOSTAT specifier in an I/O statement.
exceptional values
  For floating-point numbers, values outside the range of normalized numbers, including denormal (subnormal) numbers, infinity, Not-a-Number (NaN) values, zero, and other architecture-defined numbers.
executable construct
  A CASE, DO, IF, WHERE, or FORALL construct.
executable program
  A set of program units that include only one main program.
executable statement
  A statement that specifies an action to be performed or controls one or more computational instructions.
explicit interface
  A procedure interface whose properties are known within the scope of the calling program, and do not have to be assumed. These properties are the names of the procedure and its dummy arguments, the attributes of a procedure (if it is a function), and the attributes and order of the dummy arguments.

  The following have explicit interfaces:

  - Internal and module procedures (explicit by definition)
  - Intrinsic procedures
  - External procedures that have an interface block
  - External procedures that are defined by the scoping unit and are recursive
  - Dummy procedures that have an interface block
explicit-shape array
  An array whose rank and bounds are specified when the array is declared.
expression
  Is either a data reference or a computation, and is formed from operands, operands, and parentheses. The result of an expression is either a scalar value or an array of scalar values.
extension
  See language extension.
extent
  The size of (number of elements in) one dimension of an array.
external file
  A sequence of records that exists in a medium external to the executing program.
external procedure
  A procedure that is contained in an external subprogram. External procedures can be used to share information (such as source files, common blocks, and public data in modules) and can be used independently of other procedures and program units. Also called an external routine.
external subprogram
  A subroutine or function that is not contained in a main program, module, or other subprogram. A module is not a subprogram.
field
  Can be either of the following:
  - A set of contiguous characters, considered as a single item, in a record or line.
  - A substructure of a STRUCTURE declaration.
field descriptor
  See data edit descriptor.
field separator
  The comma (,) or slash (/) that separates edit descriptors in a format specification.
field width
  The total number of characters in the field. See also field, the first definition.
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 95/90 file access modes are sequential and direct. On OpenVMS systems, you can also use a keyed mode of access.
file handle
  On Tru64 UNIX, Linux, and Windows systems, a unique identifier that the system assigns to a file when the file is opened or created. A file handle is valid until the file is closed.
file organization
  The way records in a file are physically arranged on a storage device. Fortran 95/90 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.
foreground process
  On Tru64 UNIX and Linux systems, 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 explicit data arrangement. It is a list within parentheses that can include edit descriptors and field separators. A character expression can also specify format; the expression must evaluate to a valid format specification.
formatted data
  Data written to a file by using formatted I/O statements. Such data contains ASCII representations of binary values.
formatted I/O statement
  An I/O statement specifying a format for data transfer. The format specified can be explicit (specified in a format specification) or implicit (specified using list-directed or namelist formatting). Contrast with unformatted I/O statement. See also list-directed I/O statement and namelist I/O statement.
full pathname
  See absolute pathname.
function
  A series of statements that perform some operation and return a single value (through the function or result name) to the calling program unit. A function is invoked by a function reference in a main program unit or a subprogram unit.

  In Fortran 95/90, a function can be used to define a new operator or extend the meaning of an intrinsic operator symbol. The function is invoked by the appearance of the new or extended operator in the expression (along with the appropriate operands). For example, the symbol * can be defined for logical operands, extending its intrinsic definition for numeric operands. See also function subprogram, statement function, and subroutine.

function reference
  Used in an expression to invoke a function, it consists of the function name and its actual arguments. A function reference returns a value (through the function or result name) which is used to evaluate the calling expression.
function result
  The result value associated with a particular execution or call to a function. This result can be of any data type (including derived type) and can be array-valued. In a FUNCTION statement, the RESULT option can be used to give the result a name different from the function name. This option is required for a recursive function that directly calls itself.
function subprogram
  A sequence of statements beginning with a FUNCTION (or optional OPTIONS) statement that is not in an interface block and ending with the corresponding END statement. See also function.
generic identifier
  A generic name, operator, or assignment specified in an INTERFACE statement that is associated with all of the procedures within the interface block. Also called a generic specification.
global entity
  An entity (a program unit, common block, or external procedure) that can be used with the same meaning throughout the executable program. A global entity has global scope; it is accessible throughout an executable program. See also local entity.
global section
  A data structure (for example, global COMMON) or shareable image section potentially available to all processes in the system.
global symbol
  On OpenVMS systems, a name defined in a source file, object file, or image file, that is available for reference by another source file.
handle
  A value (often, but not always, a 32-bit integer) that identifies some operating system resource, for example, a window or a process. The handle value is returned from an operating system call when the resource is created; your program then passes that value as an argument to subsequent operating system routines to identify which resource is being accessed.

  Your program should consider the handle value a "private" type and not try to interpret it as having any specific meaning (for example, an address).

hexadecimal constant
  A constant that is a string of hexadecimal (base 16) digits (range 0 to 9, or an uppercase or lowercase letter in the range A to F) enclosed by apostrophes or quotation marks and preceded by the letter Z.
High Performance Fortran
  An extended version of Fortran 90 with features supporting parallel programming. Compaq Fortran supports full High Performance Fortran (HPF), and compiles HPF programs for parallel execution.
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 blanks and tabs).
host
  Either the main program or subprogram that contains an internal procedure, or the module that contains a module procedure. The data environment of the host is available to the (internal or module) procedure.
host association
  The process by which a module procedure, internal procedure, or derived-type definition accesses the entities of its host.
implicit interface
  A procedure interface whose properties (the collection of names, attributes, and arguments of the procedure) are not known within the scope of the calling program, and have to be assumed. The information is assumed by the calling program from the properties of the procedure name and actual arguments in the procedure call.
implicit typing
  The mechanism by which the data type for a variable is determined by the beginning letter of the variable name.
index
  Can be any of the following:
  - The variable used as a loop counter in a DO statement.
  - An intrinsic function specifying the starting position of a substring inside a string.
  - 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
  On OpenVMS systems, 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; it can also optionally have one or more alternate key indexes.
initialize
  The assignment of an initial value to a variable.
initialization expression
  A form of constant expression that is used to specify an initial value for an entity.
inlining
  An optimization that replaces a subprogram reference (CALL statement or function invocation) with the replicated code of the subprogram.
input/output (I/O)
  The data that a program reads or writes. Also, devices to read and write data.
inquiry function
  An intrinsic function whose result depends on properties of the principal argument, not the value of the argument.
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.
intent
  An attribute of a dummy argument that is not a pointer or procedure. It indicates whether the argument is used to transfer data into the procedure, out of the procedure, or both.
interactive process
  A process that must periodically get user input to do its work. Contrast with background process or batch process.
interface block
  The sequence of statements starting with an INTERFACE statement and ending with the corresponding END INTERFACE statement.
interface body
  The sequence of statements in an interface block starting with a FUNCTION or SUBROUTINE statement and ending with the corresponding END statement. Also called a procedure interface body.
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.
internal procedure
  A procedure (other than a statement function) that is contained within an internal subprogram. The program unit containing an internal procedure is called the host of the internal procedure. The internal procedure (which appears between a CONTAINS and END statement) is local to its host and inherits the host's environment through host association.
internal subprogram
  A subprogram contained in a main program or another subprogram.
intrinsic
  Describes entities defined by the Fortran 95/90 language (such as data types and procedures). Intrinsic entities can be used freely in any scoping unit.
intrinsic procedure
  A subprogram supplied as part of the Fortran 95/90 library that performs array, mathematical, numeric, character, bit manipulation, and other miscellaneous functions. Intrinsic procedures are automatically available to any Fortran 95/90 program unit (unless specifically overridden by an EXTERNAL statement or a procedure interface block). Also called a built-in or library procedure. See also 3f library routines.
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
  On OpenVMS systems, a value in a file of indexed organization that the system uses 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
  On OpenVMS systems, 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
  On OpenVMS systems, a key used to determine the index to use when sequentially accessing components of an indexed file. See also key, indexed file organization, and sequential access.
kind type parameter
  Indicates the range of an intrinsic data type. For real and complex types, it also indicates precision. If a specific kind parameter is not specified (for example, INTEGER), the kind is the default for that type (for example, default integer). See also default character, default complex, default integer, default logical, and default real.
label
  An integer, from 1 to 5 digits long, that is used to identify a statement. For example, labels can be used to refer to a FORMAT statement or branch target statement.
language extension
  A Compaq Fortran language element or interpretation that is not part of the Fortran 95 standard.
lexical token
  A sequence of one or more characters that have an indivisible interpretation. A lexical token is the smallest meaningful unit (a basic language element) of a Fortran 95/90 statement; for example, constants and statement keywords.
library function
  See intrinsic procedure.
linker
  A system program that creates an executable program from one or more object files (or modules) 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, or Tru64 UNIX, Linux, and Windows executable files.
list-directed I/O statement
  An implicit, formatted I/O statement that uses an asterisk (*) specifier rather than an explicit format specification. See also formatted I/O statement and namelist I/O statement.
listing
  A printed copy of a program.
literal constant
  A constant without a name.
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 systems. Contrast with big endian.
local entity
  An entity that can be used only within the context of a subprogram (its scoping unit); for example, a statement label. A local entity has local scope. See also global entity.
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.
lower bound
  See bounds.
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
  On Tru64 UNIX and Linux systems, an argument to the `make` command containing a sequence of entries that specify dependencies. On Windows systems, a file passed to the NMAKE utility 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 and Linux systems, see `make(1)`. For more information on makefiles on Windows NT and Windows 9* systems, see the help on the NMAKE utility.

many-one array section
  An array section with a vector subscript having two or more elements with the same value.
message file
  An OpenVMS file, or Tru64 UNIX or Linux catalog that contains the diagnostic message text of errors that can occur during program execution (run time).
misaligned data
  Data not aligned on a natural boundary. See also natural boundary.
module
  A program unit that contains specifications and definitions that other program units can access (unless the module entities are declared PRIVATE). Modules are referenced in USE statements.
module procedure
  A subroutine or function defined within a module subprogram (the module procedure's host). The module procedure appears between a CONTAINS and END statement in its host module, and inherits the host module's environment through host association. A module procedure can be declared PRIVATE to the module; it is public by default.
module subprogram
  A subprogram that is contained in a module. (It cannot be an internal subprogram.)
multitasking
  The ability of an operating system to execute several programs (tasks) at once.
multinational character set
  On OpenVMS, Tru64 UNIX, and Linux systems, 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.

  For information on special character sets available on Windows systems, see the online documentation for those systems.

multithreading
  The ability of an operating system to execute different parts of a program, called threads, simultaneously.

  If the system supports parallel processing, multiple processors may be used to execute the threads.

name
  Identifies an entity within a Fortran program unit (such as a variable, function result, common block, named constant, procedure, program unit, namelist group, or dummy argument). In FORTRAN 77, this term was called a symbolic name.
name association
  Pertains to argument, host, or use association. See also argument association, host association, and use association.
named common block
  A common block (one or more contiguous areas of storage) with a name. Common blocks are defined by a COMMON statement.
named constant
  A constant that has a name. In FORTRAN 77, this term was called a symbolic constant.
namelist I/O statement
  An implicit, formatted I/O statement that uses a namelist group specifier rather than an explicit format specifier. See also formatted I/O statement and list-directed I/O statement.
NaN
  Not-a-Number. The condition that results from a floating-point operation that has no mathematical meaning; for example, zero divided by zero.
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) (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 hardware-specific natural boundary; each field is naturally aligned. (For more information, see your user manual or programmer's guide.) Contrast with packed record.
nesting
  The placing of one entity (such as a construct, subprogram, format specification, or loop) inside another entity 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 95/90 statement that describes program attributes, but does not cause any action to be taken when the program is executed.
numeric expression
  A numeric constant, variable, or function value, or combination of these, joined by numeric 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`.
numeric operator
  A symbol designating an arithmetic operation. In Fortran 95/90, the symbols +, -, *, /, and ** are used to designate addition, subtraction, multiplication, division, and exponentiation, respectively.
numeric storage unit
  The unit of storage for holding a non-pointer scalar value of type default real, default integer, or default logical. One numeric storage unit corresponds to 4 bytes of memory.
object
  See data object.
object file
  The binary output of a language processor (such as the assembler or compiler), which can either be executed or used as input to the linker.
octal constant
  A constant that is a string of octal (base 8) digits (range of 0 to 7) enclosed by apostrophes or quotation marks and 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.
operation
  A computation involving one or two operands.
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.
optional argument
  A dummy argument that has the OPTIONAL attribute (or is included in an OPTIONAL statement in the procedure definition). Such an argument does not have to be associated with an actual argument.
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).
parallel processing
  The simultaneous use of more than one processor (CPU) to execute a program.
parameter
  Can be either of the following:
  - In general, any quantity of interest in a given situation; often used in place of the term "argument".
  - A Fortran 95/90 named constant.
parent process
  A process that initiates and controls another process (child). The parent process defines the environment for the child process. Further, the parent process can suspend or terminate without affecting the child process. See also child process.
pathname
  On Tru64 UNIX, Linux, and Windows systems, the path from the root directory to a subdirectory or file. See also root.
pipe
  On Tru64 UNIX, Linux, and Windows systems, 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 (for example, Tru64 UNIX on Alpha processors).
pointer
  Is one of the following:
  - A Fortran 95/90 pointer
    A data object that has the POINTER attribute. A Fortran 95/90 pointer does not contain data, but points to a scalar or array variable where data is stored. To be referenced or defined, it must be "pointer-associated" with a target (have storage space associated with it). If the pointer is an array, it must be pointer-associated to have a shape. See also pointer association.
  - A Compaq Fortran pointer
    A data object that contains the address of its paired variable.
pointer association
  The association of storage space to a Fortran 95/90 pointer by means of a target. A pointer is associated with a target after pointer assignment or the valid execution of an ALLOCATE statement.
precision
  The number of significant digits in a real number. See also double-precision constant, kind type parameter, and single-precision constant.
primary
  The simplest form of an expression. A primary can be any of the following data objects:
  - A constant
  - A constant subobject (parent is a constant)
  - A variable (scalar, structure, array, or pointer; an array cannot be assumed size)
  - An array constructor
  - A structure constructor
  - A function reference
  - An expression in parentheses
primary key
  On OpenVMS systems, the required key within the data records of an indexed file. This key 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, dummy or module procedure, or a statement function. A subprogram can define more than one procedure if it contains an ENTRY statement. See also subprogram.
procedure interface
  The statements that specify the name and characteristics of a procedure, the name and attributes of each dummy argument, and the generic identifier (if any) by which the procedure can be referenced. If these properties are all known to the calling program, the procedure interface is explicit; otherwise it is implicit.
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.
program unit
  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 a signed quadword integer is in the range -2**63 to 2**63-1.
random access
  See direct access.
rank
  The number of dimensions in an array. A scalar has a rank of zero.
rank-one object
  A data structure comprising scalar elements with the same data type and organized as a simple linear sequence. See also scalar.
real constant
  A constant that is a number written with a decimal point, exponent, or both. It can have single precision (REAL(4)) or double precision (REAL(8)). On OpenVMS, Tru64 UNIX, and Linux systems, it can also have quad precision (REAL(16)).
record
  Can be either of the following:
  - 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 in a record structure.
  - One or more data items that are grouped in a structure declaration and specified in a RECORD statement.
record access
  The method used to store and retrieve records in a file.
record 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.
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
  Pertains to a subroutine or function that directly or indirectly references itself.
reference
  Can be any of the following:
  - For a data object, the appearance of its name, designator, or associated pointer where the value of the object is required. When an object is referenced, it must be defined.
  - For a procedure, the appearance of its name, operator symbol, or assignment symbol that causes the procedure to be executed. Procedure reference is also called "calling" or "invoking" a procedure.
  - For a module, the appearance of its name in a USE statement.
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 ==, /=, <, <=, >, and >= (.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 uses these numbered, fixed-length cells to calculate the component's physical position in the file.
relative pathname
  On Tru64 UNIX, Linux, and Windows systems, a directory path expressed in relation to any directory other than the root directory. Contrast with absolute pathname.
root
  On Tru64 UNIX and Linux systems, the top-level directory in the file system; it is represented by a slash (/).

  On Windows systems, the top-level directory on a disk drive; it is represented by a backslash (\). For example, C:\ is the root directory for drive C.

routine
  A subprogram; a function or procedure. See also function, subroutine, and procedure.
run time
  The time during which a computer executes the statements of a program.
saved object
  A variable that retains its association status, allocation status, definition status, and value after execution of a RETURN or END statement in the scoping unit containing the declaration.
scalar
  Pertaining to data items with a rank of zero. A single data object of any intrinsic or derived data type. Contrast with array. See also rank-one object.
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, derived-type component, 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.
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. Scope can be global (throughout an executable program), scoping unit (local to the scoping unit), or statement (within a statement, or part of a statement).
scoping unit
  The part of the program in which a name has meaning. It is one of the following:
  - A program unit or subprogram
  - A derived-type definition
  - A procedure interface body

  Scoping units cannot overlap, though one scoping unit can contain another scoping unit. (The outer scoping unit is called the host scoping unit.)

section subscript
  A subscript list (enclosed in parentheses and appended to the array name) indicating a portion (section) of an array. At least one of the subscripts in the list must be a subscript triplet or vector subscript. The number of section subscripts is the rank of the array. See also array section, subscript, subscript triplet, and vector subscript.
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)`.
selector
  A mechanism for designating the following:
  - Part of a data object (an array element or section, a substring, a derived type, or a structure component)
  - The set of values for which a CASE block is executed
sequence
  A set ordered by a one-to-one correspondence with the numbers 1 through n, where n is the total number of elements in the sequence. A sequence can be empty (contain no elements).
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.
shape
  The rank and extents of an array. Shape can be represented by a rank-one array (vector) whose elements are the extents in each dimension.
shape conformance
  Pertains to the rule concerning operands of binary intrinsic operations in expressions: to be in shape conformance, the two operands must both be arrays of the same shape, or one or both of the operands must be scalars.
short field termination
  The use of a comma (,) to terminate the field of a numeric data edit descriptor. This technique overrides the field width (w) specification in the data edit descriptor and therefore avoids padding of the input field. The comma can only terminate fields less than w characters long. See also data edit 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 the single-precision constants, see your user manual or programmer's guide. See also denormalized number.
size
  The total number of elements in an array (the product of the extents).
source file
  A program or portion of a program library, such as an object file, or image file.
specification expression
  A restricted expression that is of type integer and has a scalar value. This type of expression appears only in the declaration of array bounds and character lengths.
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 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. In Fortran 95/90, an ampersand (&) can be used to continue a statement from one line to another, and a semicolon (;) can be used to separate several statements on one line.

  There are two main classes of statements: executable and nonexecutable. See also executable statement and nonexecutable statement.

statement function
  A computing procedure defined by a single statement in the same program unit in which the procedure is referenced.
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.

  A statement function definition must precede all executable statements and follow all specification statements. See also statement function.

statement keyword
  A word that begins the syntax of a statement. All program statements (except assignment statements and statement function definitions) begin with a statement keyword. Examples are INTEGER, DO, IF, and WRITE.
statement label
  See label.
static variable
  A variable whose storage is allocated for the entire execution of a program.
storage association
  The relationship between two storage sequences when the storage unit of one is the same as the storage unit of the other. Storage association is provided by the COMMON and EQUIVALENCE statements. For modules, pointers, allocatable arrays, and automatic data objects, the SEQUENCE statement defines a storage order for structures.
storage location
  An addressable unit of main memory.
storage sequence
  A sequence of any number of consecutive storage units. The size of a storage sequence is the number of storage units in the storage sequence. A sequence of storage sequences forms a composite storage sequence. See also storage association and storage unit.
storage unit
  In a storage sequence, the number of storage units needed to represent one real, integer, logical, or character value. See also character storage unit, numeric storage unit, and storage sequence.
stride
  The increment between subscript values that can optionally be specified in a subscript triplet. If it is omitted, it is assumed to be one.
string edit descriptor
  A format descriptor that transfers characters to an output record.
structure
  Can be either of the following:
  - A scalar data object of derived (user-defined) type.
  - An aggregate entity containing one or more fields or components.
structure component
  Can be either of the following:
  - One of the components of a structure.
  - An array whose elements are components of the elements of an array of derived type.
structure constructor
  A mechanism that is used to specify a scalar value of a derived type. A structure constructor is the name of the type followed by a parenthesized list of values for the components of the type.
subobject
  Part of a data object (parent object) that can be referenced and defined separately from other parts of the data object. A subobject can be an array element, an array section, a substring, a derived type, or a structure component. Subobjects are referenced by designators and can be considered to be data objects themselves. See also designator.
subobject designator
  See designator.
subprogram
  A user-written function or subroutine subprogram that can be invoked from another program unit to perform a specific task. Contrast with main program.
subroutine
  A procedure that can return many values, a single value, or no value to the calling program unit (through arguments). A subroutine is invoked by a CALL statement in another program unit.

  In Fortran 95/90, a subroutine can also be used to define a new form of assignment (defined assignment), which is different from those intrinsic to Fortran 95/90. Such assignments are invoked with assignment syntax (using the = symbol) rather than the CALL statement. See also function, statement function, and subroutine subprogram.

subroutine subprogram
  A sequence of statements starting with a SUBROUTINE (or optional OPTIONS) statement and ending with the corresponding END statement. See also subroutine.
subscript
  A scalar integer expression (enclosed in parentheses and appended to the array name) indicating the position of an array element. The number of subscripts is the rank of the array. See also array element.
subscript triplet
  An item in a section subscript list specifying a range of values for the array section. A subscript triplet contains at least one colon and has three optional parts: a lower bound, an upper bound, and a stride. Contrast with vector subscript. See also array section and section subscript.
substring
  A contiguous portion of a scalar character string. Do not confuse this with the substring selector in an array section, where the result is another array section, not a substring.
symbolic name
  See name.
syntax
  The formal structure of a statement or command string.
target
  The named data object associated with a pointer (in the form pointer-object => target). A target is declared in a type declaration statement that contains the TARGET attribute. See also pointer and pointer association.
thread
  Part of a program that can run at the same time as other parts, usually with some form of communication and/or synchronization among the threads. See also multithreading.
transformational function
  An intrinsic function that is not an elemental or inquiry function. A transformational function usually changes an array actual argument into a scalar result or another array, rather than applying the argument element by element.
truncation
  Can be either of the following:
  - A technique that approximates a numeric value by dropping its fractional value and using only the integer portion.
  - 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.
type parameter
  Defines an intrinsic data type. The type parameters are kind and length. The kind type parameter (KIND=) specifies the range for the integer data type, the precision and range for real and complex data types, and the machine representation method for the character and logical data types. The length type parameter (LEN=) specifies the length of a character string. See also kind type parameter.
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.
unformatted data
  Data written to a file by using unformatted I/O statements; for example, binary numbers.
unformatted I/O statement
  An I/O statement that does not contain format specifiers and therefore does not translate the data being transferred. Contrast with formatted I/O statement.
unformatted record
  A record that is transmitted in internal format between internal and external storage.
unit identifier
  The identifier that specifies an external unit or internal file. The identifier can be any one of the following:
  - An integer expression whose value must be zero or positive
  - An asterisk (*) that corresponds to the default (or implicit) I/O 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.

unspecified storage unit
  A unit of storage for holding a pointer or other scalar object of non-default intrinsic type.
upper bound
  See bounds.
use association
  The process by which the entities in a module are made accessible to other scoping units (through a USE statement in the scoping unit).
user-defined type
  See derived type.
variable
  A data object (stored in a memory location) whose value can change during program execution. A variable can be a named data object, an array element, an array section, a structure component, or a substring. Contrast with constant.
variable format expression
  A numeric expression enclosed in angle brackets (< >) that can be used in a FORMAT statement. If necessary, it is converted to integer type before use.
variable-length record type
  A file format in which records may be of different lengths.
vector subscript
  A rank-one array of integer values used as a section subscript to select elements from a parent array. Unlike a subscript triplet, a vector subscript specifies values (within the declared bounds for the dimension) in an arbitrary order. Contrast with subscript triplet. See also array section and section subscript.
whole array
  An array reference (for example, in a type declaration statement) that consists of the array name alone, without subscript notation. Whole array operations affect every element in the array. See also array.
zero-sized array
  An array with at least one dimension that has at least one extent of zero. A zero-sized array has a size of zero and contains no elements. See also array.

Previous Page Next Page Table of Contents