Intel® Fortran

Language Reference

Document Number: 253261-002

World Wide Web: http://developer.intel.com
Disclaimer and Legal Information
Information in this document is provided in connection with Intel products. No license, express or implied, by estoppel or otherwise, to any
intellectual property rights is granted by this document. EXCEPT AS PROVIDED IN INTEL'S TERMS AND CONDITIONS OF SALE
FOR SUCH PRODUCTS, INTEL ASSUMES NO LIABILITY WHATSOEVER, AND INTEL DISCLAIMS ANY EXPRESS OR
IMPLIED WARRANTY, RELATING TO SALE AND/OR USE OF INTEL PRODUCTS INCLUDING LIABILITY OR WARRANTIES
RELATING TO FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABILITY, OR INFRINGEMENT OF ANY PATENT, COPY-
RIGHT OR OTHER INTELLECTUAL PROPERTY RIGHT. Intel products are not intended for use in medical, life saving, or life sustain-
ing applications.
This Reference as well as the software described in it is furnished under license and may only be used or copied in accordance with the
terms of the license. The information in this manual is furnished for informational use only, is subject to change without notice, and should
not be construed as a commitment by Intel Corporation. Intel Corporation assumes no responsibility or liability for any errors or inaccura-
cies that may appear in this document or any software that may be provided in association with this document.
Designers must not rely on the absence or characteristics of any features or instructions marked "reserved" or "undefined." Intel reserves
these for future definition and shall have no responsibility whatsoever for conflicts or incompatibilities arising from future changes to them.
The software described in this Reference may contain software defects which may cause the product to deviate from published specifica-
tions. Current characterized software defects are available on request.
Intel SpeedStep, Intel Thread Checker, Celeron, Dialogic, i386, i486, iCOMP, Intel, Intel logo, Intel386, Intel486, Intel740, IntelDX2,
IntelDX4, IntelSX2, Intel Inside, Intel Inside logo, Intel NetBurst, Intel NetStructure, Intel Xeon, Intel XScale, Itanium, MMX, MMX logo,
Pentium, Pentium II Xeon, Pentium III Xeon, Pentium M, and VTune are trademarks or registered trademarks of Intel Corporation or its
subsidiaries in the United States and other countries.
* Other names and brands may be claimed as the property of others.
Copyright © 2003-2004 Intel Corporation.
Portions © Copyright 2001 Hewlett-Packard Development Company, L.P.

ii
Contents
About This Manual
Product Website and Support .................................................................. xxvi
Related Publications................................................................................. xxvii
Conventions .............................................................................................. xxx
Platform Labels.................................................................................... xxxii

Chapter 1 Overview
Language Standards Conformance .......................................................... 1-2
Language Compatibility............................................................................. 1-2
Fortran 2003 Features............................................................................... 1-2
Improved Features................................................................................ 1-3
Fortran 95 Features................................................................................... 1-3
New Features ....................................................................................... 1-3
Improved Features................................................................................ 1-4
Fortran 90 Features................................................................................... 1-5
New Features ....................................................................................... 1-5
Improved Features................................................................................ 1-7

Chapter 2 Program Structure, Characters, and Source Forms

Program Structure ..................................................................................... 2-1
Statements ........................................................................................... 2-2
Names .................................................................................................. 2-4
Character Sets .......................................................................................... 2-5
Source Forms............................................................................................ 2-6
Free Source Form................................................................................. 2-9

iii
Intel Fortran Language Reference

Fixed and Tab Source Forms.............................................................. 2-11

Fixed-Format Lines ........................................................................ 2-13
Tab-Format Lines ........................................................................... 2-13
Source Code Useable for All Source Forms ....................................... 2-15

Chapter 3 Data Types, Constants, and Variables

Intrinsic Data Types ................................................................................... 3-2
Integer Data Types................................................................................ 3-4
Real Data Types.................................................................................... 3-6
General Rules for Real Constants.................................................... 3-7
REAL(4) Constants .......................................................................... 3-8
REAL(8) or DOUBLE PRECISION Constants ................................. 3-9
REAL(16) Constants ...................................................................... 3-10
Complex Data Types........................................................................... 3-10
General Rules for Complex Constants........................................... 3-11
COMPLEX(4) Constants ................................................................ 3-11
COMPLEX(8) or DOUBLE COMPLEX Constants ......................... 3-12
COMPLEX(16) Constants .............................................................. 3-13
Logical Data Types.............................................................................. 3-14
Character Data Type ........................................................................... 3-14
C Strings in Character Constants................................................... 3-16
Character Substrings .................................................................... 3-17
Derived Data Types ................................................................................. 3-19
Derived-Type Definition....................................................................... 3-20
Default Initialization............................................................................. 3-22
Structure Components........................................................................ 3-23
Structure Constructors........................................................................ 3-26
Binary, Octal, Hexadecimal, and Hollerith Constants .............................. 3-28
Binary Constants ................................................................................ 3-28
Octal Constants .................................................................................. 3-29
Hexadecimal Constants ...................................................................... 3-29
Hollerith Constants ............................................................................. 3-30
Determining the Data Type of Nondecimal Constants ........................ 3-31
Variables.................................................................................................. 3-33

iv
 Contents

Data Types of Scalar Variables ........................................................... 3-34

Specification of Data Type.............................................................. 3-34
Implicit Typing Rules....................................................................... 3-35
Arrays .................................................................................................. 3-35
Whole Arrays .................................................................................. 3-38
Array Elements ............................................................................... 3-38
Array Sections ................................................................................ 3-41
Array Constructors.......................................................................... 3-44

Chapter 4 Expressions and Assignment Statements

Expressions ............................................................................................... 4-1
Numeric Expressions ............................................................................ 4-2
Using Parentheses in Numeric Expressions .................................... 4-4
Data Type of Numeric Expressions .................................................. 4-5
Character Expressions.......................................................................... 4-6
Relational Expressions.......................................................................... 4-7
Logical Expressions .............................................................................. 4-8
Data Types Resulting from Logical Operations ................................ 4-9
Evaluation of Logical Expressions.................................................... 4-9
Defined Operations ............................................................................. 4-10
Summary of Operator Precedence ..................................................... 4-11
Initialization and Specification Expressions ........................................ 4-11
Initialization Expressions ................................................................ 4-12
Specification Expressions .............................................................. 4-13
Assignment Statements........................................................................... 4-15
Intrinsic Assignments .......................................................................... 4-16
Numeric Assignment Statements ................................................... 4-17
Logical Assignment Statements ..................................................... 4-18
Character Assignment Statements................................................. 4-18
Derived-Type Assignment Statements ........................................... 4-19
Array Assignment Statements ........................................................ 4-20
Defined Assignments .......................................................................... 4-21
Pointer Assignments ........................................................................... 4-22
WHERE Statement and Construct ...................................................... 4-23

v
Intel Fortran Language Reference

FORALL Statement and Construct ..................................................... 4-26

Chapter 5 Specification Statements

Type Declaration Statements..................................................................... 5-2
Declaration Statements for Noncharacter Types................................... 5-6
Declaration Statements for Character Types ........................................ 5-8
Declaration Statements for Derived Types.......................................... 5-10
Declaration Statements for Arrays ...................................................... 5-10
Explicit-Shape Specifications ......................................................... 5-11
Assumed-Shape Specifications ..................................................... 5-14
Assumed-Size Specifications......................................................... 5-15
Deferred-Shape Specifications ...................................................... 5-16
ALLOCATABLE Attribute and Statement ................................................. 5-17
AUTOMATIC and STATIC Attributes and Statements.............................. 5-18
COMMON Statement .............................................................................. 5-21
DATA Statement....................................................................................... 5-24
DIMENSION Attribute and Statement ..................................................... 5-27
EQUIVALENCE Statement ...................................................................... 5-29
Making Arrays Equivalent ................................................................... 5-31
Making Substrings Equivalent............................................................. 5-33
EQUIVALENCE and COMMON Interaction ........................................ 5-35
EXTERNAL Attribute and Statement....................................................... 5-38
IMPLICIT Statement ................................................................................ 5-39
INTENT Attribute and Statement............................................................. 5-41
INTRINSIC Attribute and Statement........................................................ 5-43
NAMELIST Statement ............................................................................. 5-45
OPTIONAL Attribute and Statement........................................................ 5-46
PARAMETER Attribute and Statement.................................................... 5-48
POINTER Attribute and Statement.......................................................... 5-50
PRIVATE and PUBLIC Attributes and Statements................................... 5-51
SAVE Attribute and Statement ................................................................ 5-54
TARGET Attribute and Statement............................................................ 5-55
VOLATILE Attribute and Statement ......................................................... 5-57

vi
 Contents

Chapter 6 Dynamic Allocation

ALLOCATE Statement ............................................................................... 6-2
Allocation of Allocatable Arrays............................................................. 6-3
Allocation of Pointer Targets.................................................................. 6-4
DEALLOCATE Statement .......................................................................... 6-5
Deallocation of Allocatable Arrays......................................................... 6-6
Deallocation of Pointer Targets ............................................................. 6-7
NULLIFY Statement................................................................................... 6-8

Chapter 7 Execution Control

Branch Statements .................................................................................... 7-2
Unconditional GO TO Statement .......................................................... 7-2
Computed GO TO Statement................................................................ 7-3
The ASSIGN and Assigned GO TO Statements ................................... 7-4
ASSIGN Statement .......................................................................... 7-4
Assigned GO TO Statement............................................................. 7-5
Arithmetic IF Statement ........................................................................ 7-6
CALL Statement ........................................................................................ 7-7
CASE Constructs....................................................................................... 7-9
CONTINUE Statement............................................................................. 7-14
DO Constructs ......................................................................................... 7-14
Forms for DO Constructs .................................................................... 7-15
Execution of DO Constructs................................................................ 7-17
Iteration Loop Control..................................................................... 7-17
Nested DO Constructs ................................................................... 7-19
Extended Range............................................................................. 7-21
DO WHILE Statement ......................................................................... 7-23
CYCLE Statement............................................................................... 7-24
EXIT Statement................................................................................... 7-24
END Statement........................................................................................ 7-25
IF Construct and Statement..................................................................... 7-26
IF Construct ........................................................................................ 7-26
IF Statement........................................................................................ 7-31
PAUSE Statement.................................................................................... 7-32

vii
Intel Fortran Language Reference

RETURN Statement ................................................................................ 7-33

STOP Statement...................................................................................... 7-35

Chapter 8 Program Units and Procedures

Main Program ............................................................................................ 8-2
Modules and Module Procedures.............................................................. 8-4
Module References............................................................................... 8-7
USE Statement ..................................................................................... 8-8
Block Data Program Units ....................................................................... 8-10
Functions, Subroutines, and Statement Functions .................................. 8-12
General Rules for Function and Subroutine Subprograms ................. 8-13
Recursive Procedures.................................................................... 8-13
Pure Procedures ............................................................................ 8-14
Elemental Procedures.................................................................... 8-17
Functions ............................................................................................ 8-18
RESULT Keyword........................................................................... 8-23
Function References ...................................................................... 8-23
Subroutines......................................................................................... 8-24
Statement Functions ........................................................................... 8-27
External Procedures ................................................................................ 8-28
Internal Procedures ................................................................................. 8-29
Argument Association.............................................................................. 8-30
Optional Arguments ............................................................................ 8-32
Array Arguments ................................................................................. 8-33
Pointer Arguments .............................................................................. 8-34
Assumed-Length Character Arguments.............................................. 8-35
Character Constant and Hollerith Arguments ..................................... 8-36
Alternate Return Arguments ............................................................... 8-37
Dummy Procedure Arguments............................................................ 8-37
References to Generic Procedures..................................................... 8-38
References to Generic Intrinsic Functions ..................................... 8-39
References to Elemental Intrinsic Procedures ............................... 8-42
References to Non-Fortran Procedures.............................................. 8-43
%REF and %VAL Argument List Functions ................................... 8-43

viii
 Contents

%LOC Function .............................................................................. 8-44

Procedure Interfaces................................................................................ 8-45
Determining When Procedures Require Explicit Interfaces ................ 8-46
Defining Explicit Interfaces.................................................................. 8-46
Defining Generic Names for Procedures ............................................ 8-49
Defining Generic Operators ................................................................ 8-50
Defining Generic Assignment ............................................................. 8-51
CONTAINS Statement ............................................................................. 8-53
ENTRY Statement ................................................................................... 8-53
ENTRY Statements in Function Subprograms.................................... 8-55
ENTRY Statements in Subroutine Subprograms ................................ 8-56

Chapter 9 Intrinsic Procedures

Argument Keywords in Intrinsic Procedures .............................................. 9-3
Overview of Intrinsic Procedures ............................................................... 9-4
Categories of Intrinsic Functions........................................................... 9-4
Intrinsic Subroutines ........................................................................... 9-15
Bit Functions ....................................................................................... 9-16
Descriptions of Intrinsic Procedures ........................................................ 9-18
ABS ..................................................................................................... 9-18
ACHAR................................................................................................ 9-19
ACOS .................................................................................................. 9-20
ACOSD ............................................................................................... 9-20
ACOSH ............................................................................................... 9-21
ADJUSTL ............................................................................................ 9-21
ADJUSTR............................................................................................ 9-22
AIMAG................................................................................................. 9-22
AINT .................................................................................................... 9-23
ALL...................................................................................................... 9-23
ALLOCATED ....................................................................................... 9-24
ANINT ................................................................................................. 9-25
ANY..................................................................................................... 9-25
ASIN.................................................................................................... 9-26
ASIND ................................................................................................. 9-27

ix
Intel Fortran Language Reference

ASINH ................................................................................................. 9-27

ASSOCIATED ..................................................................................... 9-28
ATAN ................................................................................................... 9-29
ATAN2 ................................................................................................. 9-30
ATAN2D............................................................................................... 9-31
ATAND................................................................................................. 9-31
ATANH................................................................................................. 9-32
BADDRESS ........................................................................................ 9-32
BIT_SIZE ............................................................................................ 9-33
BTEST ................................................................................................ 9-33
CACHESIZE (i64 only)........................................................................ 9-34
CEILING ............................................................................................. 9-35
CHAR.................................................................................................. 9-35
CMPLX ............................................................................................... 9-36
CONJG ............................................................................................... 9-37
COS .................................................................................................... 9-37
COSD ................................................................................................. 9-38
COSH ................................................................................................. 9-39
COTAN................................................................................................ 9-39
COTAND ............................................................................................. 9-40
COUNT ............................................................................................... 9-40
CPU_TIME.......................................................................................... 9-41
CSHIFT ............................................................................................... 9-42
DATE................................................................................................... 9-43
DATE_AND_TIME............................................................................... 9-44
DBLE .................................................................................................. 9-46
DCMPLX ............................................................................................. 9-47
DFLOAT .............................................................................................. 9-47
DIGITS ................................................................................................ 9-48
DIM ..................................................................................................... 9-48
DNUM ................................................................................................. 9-49
DOT_PRODUCT................................................................................. 9-50
DPROD ............................................................................................... 9-51
DREAL................................................................................................ 9-51

x
 Contents

DSHIFTL ............................................................................................. 9-52

DSHIFTR............................................................................................. 9-52
EOF..................................................................................................... 9-53
EOSHIFT............................................................................................. 9-54
EPSILON............................................................................................. 9-56
ERF ..................................................................................................... 9-56
ERFC .................................................................................................. 9-57
ERRSNS ............................................................................................. 9-58
EXIT .................................................................................................... 9-59
EXP ..................................................................................................... 9-59
EXPONENT ........................................................................................ 9-60
FLOOR................................................................................................ 9-60
FP_CLASS.......................................................................................... 9-61
FRACTION.......................................................................................... 9-61
FREE................................................................................................... 9-62
GETARG ............................................................................................. 9-62
HUGE.................................................................................................. 9-64
IACHAR............................................................................................... 9-64
IAND.................................................................................................... 9-65
IARGC................................................................................................. 9-65
IARGPTR ............................................................................................ 9-66
IBCHNG .............................................................................................. 9-67
IBCLR.................................................................................................. 9-67
IBITS ................................................................................................... 9-68
IBSET.................................................................................................. 9-69
ICHAR ................................................................................................. 9-70
IDATE .................................................................................................. 9-71
IEOR ................................................................................................... 9-71
ILEN .................................................................................................... 9-72
INDEX ................................................................................................. 9-73
INT ...................................................................................................... 9-73
INT_PTR_KIND................................................................................... 9-75
INUM ................................................................................................... 9-76
IOR...................................................................................................... 9-76

xi
Intel Fortran Language Reference

ISHA ................................................................................................... 9-77

ISHC ................................................................................................... 9-78
ISHFT ................................................................................................. 9-79
ISHFTC ............................................................................................... 9-80
ISHL.................................................................................................... 9-81
ISNAN ................................................................................................. 9-82
JNUM .................................................................................................. 9-82
KIND ................................................................................................... 9-82
LBOUND ............................................................................................. 9-83
LEADZ ................................................................................................ 9-84
LEN..................................................................................................... 9-85
LEN_TRIM .......................................................................................... 9-85
LGE..................................................................................................... 9-86
LGT..................................................................................................... 9-87
LLE ..................................................................................................... 9-87
LLT ...................................................................................................... 9-88
LOC .................................................................................................... 9-89
LOG .................................................................................................... 9-89
LOG10 ................................................................................................ 9-90
LOGICAL ............................................................................................ 9-91
MALLOC ............................................................................................. 9-91
MATMUL ............................................................................................. 9-92
MAX .................................................................................................... 9-93
MAXEXPONENT ................................................................................ 9-95
MAXLOC............................................................................................. 9-95
MAXVAL.............................................................................................. 9-97
MCLOCK ............................................................................................ 9-98
MERGE............................................................................................... 9-98
MIN ..................................................................................................... 9-99
MINEXPONENT ............................................................................... 9-100
MINLOC ............................................................................................ 9-100
MINVAL............................................................................................. 9-102
MM_PREFETCH .............................................................................. 9-103
MOD ................................................................................................. 9-105

xii
 Contents

MODULO .......................................................................................... 9-106

MULT_HIGH (i64 only) ..................................................................... 9-106
MVBITS............................................................................................. 9-107
NARGS ............................................................................................. 9-108
NEAREST ......................................................................................... 9-110
NINT.................................................................................................. 9-110
NOT................................................................................................... 9-111
NULL ................................................................................................. 9-112
PACK................................................................................................. 9-113
POPCNT ........................................................................................... 9-114
POPPAR............................................................................................ 9-114
PRECISION ...................................................................................... 9-114
PRESENT ......................................................................................... 9-115
PRODUCT ........................................................................................ 9-116
QCMPLX ........................................................................................... 9-117
QEXT ................................................................................................ 9-117
QFLOAT ............................................................................................ 9-118
QNUM ............................................................................................... 9-119
QREAL .............................................................................................. 9-119
RADIX ............................................................................................... 9-120
RAN................................................................................................... 9-120
RANDOM_NUMBER......................................................................... 9-121
RANDOM_SEED .............................................................................. 9-122
RANDU ............................................................................................. 9-124
RANGE ............................................................................................. 9-124
REAL................................................................................................. 9-125
REPEAT ............................................................................................ 9-126
RESHAPE ......................................................................................... 9-127
RNUM ............................................................................................... 9-128
RRSPACING ..................................................................................... 9-128
SCALE .............................................................................................. 9-128
SCAN ................................................................................................ 9-129
SECNDS ........................................................................................... 9-130
SELECTED_INT_KIND..................................................................... 9-130

xiii
Intel Fortran Language Reference

SELECTED_REAL_KIND ................................................................. 9-131

SET_EXPONENT ............................................................................. 9-132
SHAPE.............................................................................................. 9-132
SHIFTL ............................................................................................. 9-133
SHIFTR ............................................................................................. 9-133
SIGN ................................................................................................. 9-134
SIN .................................................................................................... 9-135
SIND ................................................................................................. 9-135
SINH ................................................................................................. 9-136
SIZE.................................................................................................. 9-136
SIZEOF ............................................................................................. 9-137
SPACING .......................................................................................... 9-138
SPREAD ........................................................................................... 9-138
SQRT ................................................................................................ 9-139
SUM .................................................................................................. 9-140
SYSTEM_CLOCK............................................................................. 9-141
TAN ................................................................................................... 9-142
TAND ................................................................................................ 9-143
TANH ................................................................................................ 9-143
TIME ................................................................................................. 9-144
TINY.................................................................................................. 9-144
TRAILZ ............................................................................................. 9-145
TRANSFER ...................................................................................... 9-145
TRANSPOSE.................................................................................... 9-146
TRIM ................................................................................................. 9-147
UBOUND .......................................................................................... 9-147
UNPACK ........................................................................................... 9-148
VERIFY ............................................................................................. 9-149
ZEXT................................................................................................. 9-150

Chapter 10 Data Transfer I/O Statements

Records and Files.................................................................................... 10-1
Components of Data Transfer Statements............................................... 10-2
I/O Control List .................................................................................... 10-3

xiv
 Contents

Unit Specifier .................................................................................. 10-4

Format Specifier ............................................................................. 10-5
Namelist Specifier .......................................................................... 10-6
Record Specifier............................................................................. 10-6
I/O Status Specifier ........................................................................ 10-6
Branch Specifiers ........................................................................... 10-7
Advance Specifier .......................................................................... 10-8
Character Count Specifier .............................................................. 10-9
I/O Lists ............................................................................................... 10-9
Simple List Items in I/O Lists ........................................................ 10-10
implied-DO Lists in I/O Lists ......................................................... 10-12
READ Statements.................................................................................. 10-13
Forms for Sequential READ Statements........................................... 10-13
Rules for Formatted Sequential READ Statements...................... 10-15
Rules for List-Directed Sequential READ Statements.................. 10-15
Rules for Namelist Sequential READ Statements ........................ 10-18
Rules for Unformatted Sequential READ Statements .................. 10-23
Forms for Direct-Access READ Statements ..................................... 10-24
Rules for Formatted Direct-Access READ Statements ................ 10-25
Rules for Unformatted Direct-Access READ Statements ............. 10-26
Forms and Rules for Internal READ Statements .............................. 10-26
ACCEPT Statement ............................................................................... 10-28
WRITE Statements ................................................................................ 10-29
Forms for Sequential WRITE Statements ......................................... 10-29
Rules for Formatted Sequential WRITE Statements .................... 10-30
Rules for List-Directed Sequential WRITE Statements ................ 10-31
Rules for Namelist Sequential WRITE Statements ...................... 10-33
Rules for Unformatted Sequential WRITE Statements................. 10-34
Forms for Direct-Access WRITE Statements .................................... 10-35
Rules for Formatted Direct-Access WRITE Statements............... 10-36
Rules for Unformatted Direct-Access WRITE Statements ........... 10-36
Forms and Rules for Internal WRITE Statements............................. 10-36
PRINT and TYPE Statements ............................................................... 10-38
REWRITE Statement............................................................................. 10-39

xv
Intel Fortran Language Reference

Chapter 11 I/O Formatting

Format Specifications .............................................................................. 11-2
Data Edit Descriptors............................................................................... 11-6
Forms for Data Edit Descriptors.......................................................... 11-6
General Rules for Numeric Editing ..................................................... 11-8
Integer Editing..................................................................................... 11-9
I Editing .......................................................................................... 11-9
B Editing....................................................................................... 11-11
O Editing ...................................................................................... 11-12
Z Editing ....................................................................................... 11-13
Real and Complex Editing ................................................................ 11-14
F Editing ....................................................................................... 11-15
E and D Editing ............................................................................ 11-16
EN Editing .................................................................................... 11-19
ES Editing .................................................................................... 11-20
G Editing ...................................................................................... 11-22
Complex Editing ........................................................................... 11-24
Logical Editing (L) ............................................................................. 11-25
Character Editing (A) ........................................................................ 11-26
Default Widths for Data Edit Descriptors .......................................... 11-28
Terminating Short Fields of Input Data ............................................. 11-29
Control Edit Descriptors......................................................................... 11-30
Forms for Control Edit Descriptors.................................................... 11-30
Positional Editing .............................................................................. 11-31
T Editing ....................................................................................... 11-31
TL Editing ..................................................................................... 11-32
TR Editing .................................................................................... 11-32
X Editing....................................................................................... 11-32
Sign Editing....................................................................................... 11-33
SP Editing .................................................................................... 11-33
SS Editing .................................................................................... 11-33
S Editing....................................................................................... 11-33
Blank Editing..................................................................................... 11-33
BN Editing .................................................................................... 11-34

xvi
 Contents

BZ Editing..................................................................................... 11-34
Scale Factor Editing (P) .................................................................... 11-34
Slash Editing (/)................................................................................. 11-36
Colon Editing (:) ................................................................................ 11-37
Dollar Sign ($) and Backslash (\) Editing .......................................... 11-37
Character Count Editing (Q).............................................................. 11-38
Character String Edit Descriptors .......................................................... 11-38
Character Constant Editing ............................................................... 11-39
H Editing............................................................................................ 11-39
Nested and Group Repeat Specifications.............................................. 11-40
Variable Format Expressions ................................................................. 11-41
Printing of Formatted Records............................................................... 11-42
Interaction Between Format Specifications and I/O Lists ...................... 11-43

Chapter 12 File Operation I/O Statements

BACKSPACE Statement .......................................................................... 12-2
CLOSE Statement ................................................................................... 12-3
DELETE Statement ................................................................................. 12-4
ENDFILE Statement ................................................................................ 12-5
INQUIRE Statement ................................................................................ 12-7
ACCESS Specifier .............................................................................. 12-8
ACTION Specifier................................................................................ 12-9
BINARY Specifier (W*32, W*64) ......................................................... 12-9
BLANK Specifier ................................................................................. 12-9
BLOCKSIZE Specifier ....................................................................... 12-10
BUFFERED Specifier........................................................................ 12-10
CARRIAGECONTROL Specifier ....................................................... 12-10
CONVERT Specifier.......................................................................... 12-11
DELIM Specifier ................................................................................ 12-12
DIRECT Specifier.............................................................................. 12-12
EXIST Specifier................................................................................. 12-12
FORM Specifier................................................................................. 12-13
FORMATTED Specifier ..................................................................... 12-13
IOFOCUS Specifier (W*32, W*64).................................................... 12-13

xvii
Intel Fortran Language Reference

MODE Specifier ................................................................................ 12-14

NAME Specifier ................................................................................ 12-14
NAMED Specifier .............................................................................. 12-14
NEXTREC Specifier.......................................................................... 12-15
NUMBER Specifier ........................................................................... 12-15
OPENED Specifier............................................................................ 12-15
ORGANIZATION Specifier ................................................................ 12-16
PAD Specifier .................................................................................... 12-16
POSITION Specifier.......................................................................... 12-16
READ Specifier ................................................................................. 12-17
READWRITE Specifier ..................................................................... 12-17
RECL Specifier ................................................................................. 12-17
RECORDTYPE Specifier .................................................................. 12-18
SEQUENTIAL Specifier .................................................................... 12-18
SHARE Specifier (W*32, W*64) ....................................................... 12-19
UNFORMATTED Specifier................................................................ 12-19
WRITE Specifier ............................................................................... 12-19
OPEN Statement ................................................................................... 12-20
ACCESS Specifier ............................................................................ 12-24
ACTION Specifier ............................................................................. 12-25
ASSOCIATEVARIABLE Specifier ..................................................... 12-25
BLANK Specifier ............................................................................... 12-26
BLOCKSIZE Specifier....................................................................... 12-26
BUFFERCOUNT Specifier................................................................ 12-26
BUFFERED Specifier........................................................................ 12-27
CARRIAGECONTROL Specifier....................................................... 12-28
CONVERT Specifier ......................................................................... 12-28
DEFAULTFILE Specifier.................................................................... 12-30
DELIM Specifier ................................................................................ 12-30
DISPOSE Specifier ........................................................................... 12-31
FILE Specifier ................................................................................... 12-32
FORM Specifier ................................................................................ 12-32
IOFOCUS Specifier (W*32, W*64) ................................................... 12-33
MAXREC Specifier ........................................................................... 12-33

xviii
 Contents

MODE Specifier ................................................................................ 12-33

NAME Specifier................................................................................. 12-33
ORGANIZATION Specifier ................................................................ 12-34
PAD Specifier .................................................................................... 12-34
POSITION Specifier .......................................................................... 12-35
READONLY Specifier........................................................................ 12-35
RECL Specifier.................................................................................. 12-36
RECORDSIZE Specifier.................................................................... 12-37
RECORDTYPE Specifier .................................................................. 12-37
SHARE Specifier (W*32, W*64)........................................................ 12-38
SHARED Specifier ............................................................................ 12-39
STATUS Specifier.............................................................................. 12-39
TITLE Specifier (W*32, W*64) .......................................................... 12-40
TYPE Specifier.................................................................................. 12-40
USEROPEN Specifier ....................................................................... 12-40
REWIND Statement............................................................................... 12-41
UNLOCK Statement .............................................................................. 12-42

Chapter 13 Compilation Control Statements

INCLUDE Statement................................................................................ 13-1
OPTIONS Statement ............................................................................... 13-3

Chapter 14 Directive Enhanced Compilation

Syntax Rules for Compiler Directives ...................................................... 14-1
General Compiler Directives .................................................................... 14-2
Rules for General Directives that Affect DO Loops ............................. 14-4
ALIAS Directive ................................................................................... 14-5
ATTRIBUTES Directive ....................................................................... 14-5
ATTRIBUTES ALIAS ...................................................................... 14-8
ATTRIBUTES ALIGN...................................................................... 14-9
ATTRIBUTES ALLOCATABLE........................................................ 14-9
ATTRIBUTES ALLOW_NULL......................................................... 14-9
ATTRIBUTES ARRAY_VISUALIZER............................................ 14-10
ATTRIBUTES C and STDCALL.................................................... 14-10

xix
Intel Fortran Language Reference

ATTRIBUTES DECORATE........................................................... 14-12

ATTRIBUTES DEFAULT............................................................... 14-12
ATTRIBUTES DLLEXPORT and DLLIMPORT (W*32, W*64) ..... 14-13
ATTRIBUTES EXTERN................................................................ 14-13
ATTRIBUTES IGNORE_LOC....................................................... 14-13
ATTRIBUTES INLINE, NOINLINE, and FORCEDINLINE............ 14-14
ATTRIBUTES NO_ARG_CHECK ................................................ 14-14
ATTRIBUTES NOMIXED_STR_LEN_ARG ................................. 14-15
ATTRIBUTES REFERENCE and VALUE..................................... 14-15
ATTRIBUTES VARYING............................................................... 14-16
DECLARE and NODECLARE Directives.......................................... 14-16
DEFINE and UNDEFINE Directives.................................................. 14-16
DISTRIBUTE POINT Directive.......................................................... 14-18
FIXEDFORMLINESIZE Directive...................................................... 14-19
FREEFORM and NOFREEFORM Directives ................................... 14-20
IDENT Directive ................................................................................ 14-20
IF and IF DEFINED Directives .......................................................... 14-20
INTEGER Directive ........................................................................... 14-22
IVDEP Directive ................................................................................ 14-23
LOOP COUNT Directive ................................................................... 14-25
MESSAGE Directive ......................................................................... 14-26
OBJCOMMENT Directive ................................................................. 14-26
OPTIONS Directive........................................................................... 14-27
PACK Directive.................................................................................. 14-30
PARALLEL and NOPARALLEL Directives ........................................ 14-31
PREFETCH and NOPREFETCH Directives ..................................... 14-32
PSECT Directive ............................................................................... 14-33
REAL Directive.................................................................................. 14-35
STRICT and NOSTRICT Directives................................................. 14-36
SWP and NOSWP Directives (i64 only)............................................ 14-38
TITLE and SUBTITLE Directives ...................................................... 14-39
UNROLL and NOUNROLL Directives............................................... 14-39
VECTOR ALIGNED and VECTOR UNALIGNED Directives (i32 only) .......
14-40

xx
 Contents

VECTOR ALWAYS and NOVECTOR Directives (i32 only)................ 14-41

VECTOR NONTEMPORAL Directive (i32 only)................................ 14-42
OpenMP* Fortran Compiler Directives................................................... 14-42
Data Scope Attribute Clauses ........................................................... 14-44
COPYIN Clause ........................................................................... 14-45
COPYPRIVATE Clause ................................................................ 14-45
DEFAULT Clause.......................................................................... 14-46
FIRSTPRIVATE Clause ................................................................ 14-46
LASTPRIVATE Clause.................................................................. 14-47
PRIVATE Clause........................................................................... 14-47
REDUCTION Clause.................................................................... 14-48
SHARED Clause .......................................................................... 14-49
Conditional Compilation Rules .......................................................... 14-50
Nesting and Binding Rules............................................................... 14-51
ATOMIC Directive.............................................................................. 14-53
BARRIER Directive ........................................................................... 14-54
CRITICAL Directive........................................................................... 14-55
DO Directive...................................................................................... 14-56
FLUSH Directive ............................................................................... 14-59
MASTER Directive ............................................................................ 14-61
ORDERED Directive ......................................................................... 14-61
PARALLEL Directive ......................................................................... 14-63
PARALLEL DO Directive .................................................................. 14-65
PARALLEL SECTIONS Directive ..................................................... 14-66
SECTIONS Directive........................................................................ 14-67
SINGLE Directive ............................................................................. 14-69
THREADPRIVATE Directive............................................................. 14-70

Chapter 15 Scope and Association

Scope....................................................................................................... 15-1
Unambiguous Generic Procedure References ........................................ 15-4
Resolving Procedure References ............................................................ 15-5
References to Generic Names............................................................ 15-5
References to Specific Names............................................................ 15-7

xxi
Intel Fortran Language Reference

References to Nonestablished Names ............................................... 15-8

Association .............................................................................................. 15-9
Name Association............................................................................. 15-10
Argument Association .................................................................. 15-10
Use and Host Association ............................................................ 15-11
Pointer Association ........................................................................... 15-12
Storage Association .......................................................................... 15-13
Storage Units and Storage Sequence.......................................... 15-13
Array Association ......................................................................... 15-15

Appendix A Deleted and Obsolescent Language Features

Deleted Language Features in Fortran 95................................................. A-1
Obsolescent Language Features in Fortran 95 ......................................... A-2
Obsolescent Language Features in Fortran 90 ......................................... A-3

Appendix B Additional Language Features

DEFINE FILE Statement ........................................................................... B-1
ENCODE and DECODE Statements......................................................... B-3
FIND Statement......................................................................................... B-5
INTERFACE TO Statement ....................................................................... B-5
FORTRAN-66 Interpretation of the EXTERNAL Statement ...................... B-6
Alternative Syntax for the PARAMETER Statement .................................. B-8
VIRTUAL Statement .................................................................................. B-9
Alternative Syntax for Octal and Hexadecimal Constants ....................... B-10
Alternative Syntax for a Record Specifier ................................................ B-10
Alternative Syntax for the DELETE Statement ........................................ B-10
Alternative Form for Namelist External Records ..................................... B-11
Integer POINTER Statement .................................................................. B-12
Record Structures.................................................................................... B-13
Structure Declarations ........................................................................ B-14
Type Declarations........................................................................... B-18
Substructure Declarations............................................................. B-18
Union Declarations......................................................................... B-19
RECORD Statement ........................................................................... B-21

xxii
 Contents

References to Record Fields.............................................................. B-22

Aggregate Assignment....................................................................... B-24

Appendix C The ASCII Character Set for Linux Systems

The ASCII Character Set (L*X) ................................................................. C-1

Appendix D Data Representation Models

Model for Integer Data .............................................................................. D-2
Model for Real Data .................................................................................. D-3
Model for Bit Data ..................................................................................... D-4

Appendix E Run-Time Library Routines

Module Routines....................................................................................... E-1
Portability Routines .............................................................................. E-2
National Language Support Routines (W*32, W*64) ........................... E-8
POSIX* Routines................................................................................ E-10
QuickWin Routines (W*32, W*64)...................................................... E-15
Graphics Routines (W*32, W*64)....................................................... E-16
Dialog Routines (W*32)...................................................................... E-21
Miscellaneous Run-Time Routines .................................................... E-22
COM Routines (W*32) ....................................................................... E-23
AUTO Routines (W*32) ...................................................................... E-24
OpenMP* Fortran Routines .................................................................... E-25

Appendix F Summary of Language Extensions

Source Forms ............................................................................................ F-1
Names ....................................................................................................... F-1
Character Sets ........................................................................................... F-1
Intrinsic Data Types ................................................................................... F-2
Constants................................................................................................... F-2
Expressions and Assignment .................................................................... F-2
Specification Statements ........................................................................... F-2
Execution Control....................................................................................... F-3
Compilation Control Statements ................................................................ F-3
Built-In Functions ....................................................................................... F-3

xxiii
Intel Fortran Language Reference

I/O Statements........................................................................................... F-3

I/O Formatting............................................................................................ F-3
File Operation Statements......................................................................... F-4
Compiler Directives ................................................................................... F-5
Intrinsic Procedures................................................................................... F-7
Additional Language Features................................................................... F-9
Run-Time Library Routines...................................................................... F-10

Glossary

Index

xxiv
About This Manual
This manual contains the complete description of the Intel® Fortran programming language,
which includes Fortran 95, Fortran 90, and some Fortran 2000 language features. It contains
information on language syntax and semantics, on adherence to various Fortran standards, and on
extensions to those standards.
It applies to the following:
• Intel Fortran for Linux* on IA-32 systems
• Intel Fortran for Linux on Intel® Itanium® systems
• Intel Visual Fortran on IA-32 and Intel Itanium systems
For details on the features of the compilers and how to improve the run-time performance of
Fortran programs, see your user’s guide.
This manual is intended for experienced applications programmers who have a basic
understanding of Fortran concepts and the Fortran 95/90 language, and are using Intel Fortran in
either a single-platform or multiplatform environment.
Some familiarity with parallel programming concepts and your operating system is helpful. This
manual is not a Fortran or programming tutorial.
This manual is organized as follows:
• Chapter 1, “Overview,” describes language standards, language compatibility, and Fortran
95/90 features.
• Chapter 2, “Program Structure, Characters, and Source Forms,” describes program structure,
the Fortran 95/90 character set, and source forms.
• Chapter 3, “Data Types, Constants, and Variables,” describes intrinsic and derived data types,
constants, variables (scalars and arrays), and substrings.
• Chapter 4, “Expressions and Assignment Statements,” describes Fortran expressions and
assignment statements, which are used to define or redefine variables.
• Chapter 5, “Specification Statements,” describes specification statements, which are used to
declare the attributes of data objects.

xxv
Intel Fortran Language Reference

• Chapter 6, “Dynamic Allocation,” describes statements used in dynamic allocation.

• Chapter 7, “Execution Control,” describes constructs and statements that can transfer control
within a program.
• Chapter 8, “Program Units and Procedures,” describes program units (including modules),
subroutines and functions, and procedure interfaces.
• Chapter 9, “Intrinsic Procedures,” summarizes all intrinsic procedures.
• Chapter 10, “Data Transfer I/O Statements,”describes data transfer input/output (I/O)
statements.
• Chapter 11, “I/O Formatting,” describes the rules for I/O formatting.
• Chapter 12, “File Operation I/O Statements,” describes auxiliary I/O statements you can use
to perform file operations.
• Chapter 13, “Compilation Control Statements,” describes compilation control statements.
• Chapter 14, “Directive Enhanced Compilation,” describes general and parallel compiler
directives.
• Chapter 15, “Scope and Association,” describes scope and association.
• Appendix A, “Deleted and Obsolescent Language Features,” describes deleted features in
Fortran 95 and obsolescent language features in Fortran 95 and Fortran 90.
• Appendix B, “Additional Language Features,” describes some statements and language
features supported for programs written in older versions of Fortran.
• Appendix C, “The ASCII Character Set for Linux Systems,” describes the ASCII character
set available on Linux* systems. For information on character sets available on Windows*
systems, see the online documentation for those systems.
• Appendix D, “Data Representation Models,” describes data representation models for
numeric intrinsic functions.
• Appendix E, “Run-Time Library Routines,” summarizes the many run-time library routines.
• Appendix F, “Summary of Language Extensions,” summarizes Intel Fortran extensions to the
Fortran 95 Standard.
• The Glossary contains abbreviated definitions of some commonly used terms in this manual.

Product Website and Support

For the latest product information, visit the Intel web site:
http://developer.intel.com/software/products/
At this site, you will find comprehensive product information, including:
• Links to each product, where you will find technical information such as white papers and
articles

xxvi
 About This Manual

• Links to user forums

• Links to news and events
To find technical support information, to register your product, or to contact Intel, please visit:
http://www.intel.com/software/products/support

Related Publications
Tutorial information on Fortran 95 and Fortran 90
The following commercially published documents provide reference or tutorial information on
Fortran 95 and Fortran 90:
• Compaq Visual Fortran by N. Lawrence; published by Digital Press*
(Butterworth-Heinemann), ISBN: 1-55558-249-4.
• Digital Visual Fortran Programmer’s Guide by M. Etzel and K. Dickinson; published by
Digital Press* (Butterworth-Heinemann), ISBN: 1-55558-218-4.
• Fortran 90 Explained by M. Metcalf and J. Reid; published by Oxford University Press,
ISBN 0-19-853772-7.
• Fortran 90/95 Explained by M. Metcalf and J. Reid; published by Oxford University Press,
ISBN 0-19-851888-9.
• Fortran 90/95 for Scientists and Engineers by S. Chapman; published by McGraw-Hill,
ISBN 0-07-011938-4.
• Fortran 90 Handbook by J. Adams, W. Brainerd, J. Martin, B. Smith, and J. Wagener;
published by Intertext Publications (McGraw-Hill), ISBN 0-07-000406-4.
• Fortran 90 Programming by T. Ellis, I. Philips, and T. Lahey; published by Addison-Wesley,
ISBN 0201-54446-6.
• Introduction to Fortran 90/95 by Stephen J. Chapman; published by WCB McGraw-Hill,
ISBN 0-07-011969-4.
• Programmer’s Guide to Fortran 90, Second Edition by W. Brainerd, C. Goldberg, and J.
Adams; published by Unicomp, ISBN 0-07-000248-7.
Intel® does not endorse these books or recommend them over other books on the same subjects.

Standard and Specification Documents

The following copyrighted standard and specification documents provide descriptions of many of
the features found in Intel® Fortran:
• American National Standard Programming Language FORTRAN, ANSI X3.9-1978

xxvii
Intel Fortran Language Reference

• American National Standard Programming Language Fortran 90, ANSI X3.198-1992

This Standard is equivalent to: International Standards Organization Programming Language
Fortran, ISO/IEC 1539:1991 (E).
• American National Standard Programming Language Fortran 95, ANSI X3J3/96-007
This Standard is equivalent to: International Standards Organization Programming Language
Fortran, ISO/IEC 1539-1:1997 (E).
• High Performance Fortran Language Specification, Version 1.1, Technical Report
CRPC-TR-92225
• OpenMP Fortran Application Program Interface, Version 1.1, November 1999
• OpenMP Fortran Application Program Interface, Version 2.0, November 2000

Associated Intel Documents

The following Intel documents provide additional information about the Intel® Fortran Compiler,
Intel® architecture, Intel® processors, or tools:
• Intel® Fortran Language Reference
• Intel® Fortran Libraries Reference
• Intel® Visual Fortran Compiler for Windows* Systems Installing and Getting Started
• Intel® Array Visualizer online help reference
• Intel® Array Viewer online help reference
• Using the Intel® License Manager for FLEXlm*
• Intel® C++ Compiler User's Guide
• VTune™ Performance Analyzer online help
• Enhanced Debugger online help
• Intel® Architecture Software Developer's Manual, Volume 1: Basic Architecture, Intel
Corporation, doc. number 243190
• Intel® Architecture Software Developer's Manual, Volume 2: Instruction Set Reference
Manual, Intel Corporation, doc. number 243191
• Intel® Architecture Software Developer's Manual, Volume 3: System Programming, Intel
Corporation, doc. number 243192
• Pentium® Processor Family Developer's Manual
• Intel® Processor Identification with the CPUID Instruction, Intel Corporation, doc. number
241618
• Intel® Itanium® Architecture Manuals
• Intel® Itanium® Architecture Software Conventions & Runtime Architecture Guide
• Intel® Itanium® Assembler User's Guide
• Intel® Itanium® Architecture Assembly Language Reference Guide

xxviii
 About This Manual

Most Intel documents can be found at the Intel web site:

http://developer.intel.com/software/products/

Optimization and Vectorization Terminology and Technology

The following documents provide details on basic optimization and vectorization terminology and
technology:
• Intel® Architecture Optimization Reference Manual
• Dependence Analysis, Utpal Banerjee (A Book Series on Loop Transformations for
Restructuring Compilers). Kluwer Academic Publishers. 1997.
• The Structure of Computers and Computation: Volume I, David J. Kuck. John Wiley and
Sons, New York, 1978.
• Loop Transformations for Restructuring Compilers: The Foundations, Utpal Banerjee (A
Book Series on Loop Transformations for Restructuring Compilers). Kluwer Academic
Publishers. 1993.
• Loop parallelization, Utpal Banerjee (A Book Series on Loop Transformations for
Restructuring Compilers). Kluwer Academic Publishers. 1994.
• High Performance Compilers for Parallel Computers, Michael J. Wolfe. Addison-Wesley,
Redwood City. 1996.
• Supercompilers for Parallel and Vector Computers, H. Zima. ACM Press, New York, 1990.
• An Auto-vectorizing Compiler for the Intel® Architecture, Aart Bik, Paul Grey, Milind
Girkar, and Xinmin Tian. Submitted for publication
• Efficient Exploitation of Parallelism on Pentium® III and Pentium® 4 Processor-Based
Systems, Aart Bik, Milind Girkar, Paul Grey, and Xinmin Tian.
• The Software Vectorization Handbook. Applying Multimedia Extensions for Maximum
Performance, A.J.C. Bik. Intel Press, June, 2004.

Tutorial information on the Intel Fortran Compiler

The following resources provide tutorial help on the Intel Fortran Compiler:
For additional training on the Intel Fortran Compiler, choose a course in the Intel® Software
College - Course Catalog at https://shale.intel.com/SoftwareCollege/CourseCatalog.asp.
For additional technical product information including white papers about Intel compilers, open
the page associated with your product at http://developer.intel.com/software/products/.

xxix
Intel Fortran Language Reference

Conventions
The following table describes the typographic and terminology conventions used in this manual:

Typographic Conventions
Extensions to Fortran 95 This color indicates extensions to the Fortran 95 Standard. These
extensions may or may not be implemented by other compilers that
conform to the language standard.
AUTOMATIC, INTRINSIC, WRITE Uppercase letters indicate Fortran95/90 statements, data types,
directives, and other syntax keywords. Examples of statement
keywords are WRITE, INTEGER, DO, and OPEN.
option, option This italic type indicates an keyword arguments in syntax, new terms,
emphasized text, or a book title. Most new terms are defined in the
Glossary of the Language Reference.
CALL CPU_TIME This courier type indicates a code example, a derived type name, or a
pathname.
CTRL Small capital letters indicate the names of keys and key sequences,
such as CTRL+C.
A plus indicates a combination of keys. For example, CTRL+E means to
hold down the CTRL key while pressing the E key.
{choice1 | choice2} Braces and vertical bars indicate a choice of items. You can usually
only choose one of the items in the braces.
[optional item] In syntax, single square brackets indicate items that are optional. In
code examples, they are used to show arrays.
s[, s]… A horizontal ellipsis (three dots in a row) following an item indicates that
the item preceding the ellipsis can be repeated. In code examples, a
horizontal ellipsis means that not all of the statements are shown.
Adobe Acrobat* An asterisk at the end of a word or name indicates it is a third-party
product trademark.
Terminology Conventions
compiler option This term refers to Linux* options and Windows* options that can be
used on the compiler command line.
cat(1) This format refers to an online reference page; the section number of
the page is shown in parentheses. For example, a reference to
cat(1) indicates that you can find the material on the cat command
in Section 1 of the reference pages. To read online reference pages, use
the man command. Your operating system documentation also includes
reference page descriptions.

xxx
 About This Manual

Intel Fortran This term refers to the name of the common compiler language
supported by the Intel® Visual Fortran Compiler for Windows* and
Intel® Fortran Compiler for Linux* products. For more information on
these compilers, see http://developer.intel.com/software/products/.
Fortran This term refers to language information that is common to ANSI
FORTRAN 77, ANSI/ISO Fortran 95/90, and Intel Fortran.
Fortran 95/90 This term refers to language information that is common to ANSI/ISO
Fortran 95 and ANSI/ISO Fortran 90.
Fortran 95 This term refers to language features of ANSI/ISO Fortran 95.
Fortran 90 This term refers to language features of ANSI/ISO Fortran 90.
Windows systems This term refers to all supported Microsoft* Windows operating systems.
(See also “Platform Labels”.)
Linux systems This term refers to all supported Linux operating systems. (See also
“Platform Labels”.)
integer This term refers to the INTEGER(KIND=1), INTEGER(KIND=2),
INTEGER (INTEGER(KIND=4)), and INTEGER(KIND=8) data types as
a group.
real This term refers to the REAL (REAL(KIND=4)), DOUBLE PRECISION
(REAL(KIND=8)), and REAL(KIND=16) data types as a group.
REAL This term refers to the default data type of objects declared to be REAL.
REAL is equivalent to REAL(KIND=4), unless a compiler option
specifies otherwise.
complex This term refers to the COMPLEX (COMPLEX(KIND=4)), DOUBLE
COMPLEX (COMPLEX(KIND=8)), and COMPLEX(KIND=16) data
types as a group.
logical This term refers to the LOGICAL(KIND=1), LOGICAL(KIND=2),
LOGICAL (LOGICAL(KIND=4)), and LOGICAL(KIND=8) data types as
a group.
<Tab> This symbol indicates a nonprinting tab character.
∆ This symbol indicates a nonprinting blank character.

The following example shows how this manual's typographic conventions are used to indicate the
syntax of the PARAMETER statement:
PARAMETER [(] c = expr [, c = expr]...[)]
This syntax shows that when you use this statement, you must specify the following:
• The keyword PARAMETER.
• An optional left parenthesis.

xxxi
Intel Fortran Language Reference

• One or more c = expr items, where c is a named constant and expr is a value.
If you want to specify more than one c = expr item, a comma must separate the items.
The three dots following the syntax mean you can enter as many of these sequences (a
comma, followed by c = expr) as you like.
• An optional terminating right parenthesis. If you used the optional left parenthesis, you must
use the terminating right parenthesis.
The colored brackets ([ ]) indicate that the parentheses are optional only as an extension to
standard Fortran 95.

Platform Labels
A platform is a combination of operating system and central processing unit (CPU) that provides a
distinct environment in which to use a product (in this case, a language). This manual contains
information for the following language platforms:
Platform1
Language Operating System CPU
Intel® Fortran Linux IA-32
Linux Intel® Itanium®
Microsoft* Windows* 2000 IA-32
Microsoft Windows NT* 4.0 IA-32
Microsoft Windows XP* IA-32
Microsoft Windows XP Intel Itanium
1. For the latest information on the current language platforms, see the online Release Notes.

Information in this manual applies to all supported platforms unless it is otherwise labeled for a
specific platform (or platforms), as follows:
L*X Applies to Linux* on Intel® IA-32 processors and Intel® Itanium® processors.
L*X32 Applies to Linux on Intel IA-32 processors.
L*X64 Applies to Linux on Intel Itanium processors.
W*32 Applies to Microsoft Windows* 2000, Windows XP, and Windows NT* 4.0 on Intel
IA-32 processors.
W*64 Applies to Microsoft Windows XP operating systems on Intel Itanium processors.
i32 Applies to 32-bit operating systems on Intel IA-32 processors.
i64 Applies to 64-bit operating systems on Intel Itanium processors.
For example, the IOFOCUS specifier (for an OPEN statement) is labeled "(W*32, W*64)", so this
specifier is valid only on Windows operating systems.

xxxii
About This Manual

xxxiii
Intel Fortran Language Reference

xxxiv
Overview 1
This chapter discusses Intel® Fortran standards conformance and language compatibility, and
provides an overview of Fortran 95, Fortran 90, and proposed Fortran 2003 features.

Figure 1-1 Graphic Representation of Intel Fortran

Fortran 90

FORTRAN 77 Fortran 95

Fortran
Extensions

Fortran 95 includes Fortran 90 and most features of FORTRAN 77. Fortran 90 is a superset that
includes FORTRAN 77. Intel Fortran fully supports the Fortran 95, Fortran 90, and FORTRAN 77
Standards.

1-1
1 Intel Fortran Language Reference

Language Standards Conformance

Intel Fortran conforms to American National Standard Fortran 95 (ANSI X3J3/96-007)1,
American National Standard Fortran 90 (ANSI X3.198-1992)2, and includes support for some
features in proposed standard Fortran 2003.
The ANSI committee X3J3 is currently answering questions of interpretation of Fortran 95 and
Fortran 90 language features. Any answers given by the ANSI committee that are related to
features implemented in Intel Fortran may result in changes in future releases of the Intel Fortran
compiler, even if the changes produce incompatibilities with earlier releases of Intel Fortran.
Intel Fortran provides a number of extensions to the Fortran 95 Standard. In the language
reference manual, extensions are displayed in this color.
Intel Fortran also includes support for programs that conform to the previous Fortran standards
(ANSI X3.9-1978 and ANSI X3.0-1966), the International Standards Organization standard ISO
1539-1980 (E), the Federal Information Processing Institute standard FIPS 69-1, and the Military
Standard 1753 Language Specification.

See Also
Appendix F, “Summary of Language Extensions”, for a summary of Intel Fortran language
extensions

Language Compatibility
Intel Fortran is highly compatible with Compaq* Fortran and Compaq Fortran 77 on supported
platforms, and it is substantially compatible with PDP-11* and VAX* FORTRAN 77.

See Also
Your user’s guide for specific details on language compatibility, compiler options, and program
conversion considerations

Fortran 2003 Features

This section briefly describes the Fortran 2003 features that have been implemented in Intel®
Fortran.

1. This is the same as International Standards Organization standard ISO/IEC 1539-1:1997 (E).
2. This is the same as International Standards Organization standard ISO/IEC 1539:1991 (E).

1-2
 Overview 1
Improved Features
The following Fortran 2003 features improve previous Fortran features:
• Enhancement to derived-type components, function results, and dummy arguments
Components of derived types can now be allocatable and function results and dummy
arguments can now be allocatable.
For more information, see “Derived-Type Definition”, “Functions”, and “Array Arguments”.

Fortran 95 Features
This section briefly describes the Fortran 95 language features that have been implemented in Intel
Fortran. Some features are new, while others are improvements to previous Fortran features.

New Features
The following Fortran 95 features are new to Fortran:
• The FORALL statement and construct
In Fortran 90, you could build array values element-by-element by using array constructors
and the RESHAPE and SPREAD intrinsics. The Fortran 95 FORALL statement and construct
offer an alternative method.
FORALL allows array elements, array sections, character substrings, or pointer targets to be
explicitly specified as a function of the element subscripts. A FORALL construct allows
several array assignments to share the same element subscript control.
FORALL is a generalization of WHERE. They both allow masked array assignment, but
FORALL uses element subscripts, while WHERE uses the whole array.
For more information, see “FORALL Statement and Construct”.
• PURE user-defined procedures
Pure user-defined procedures do not have side effects, such as changing the value of a
variable in a common block. To specify a pure procedure, use the PURE prefix in the function
or subroutine statement. Pure functions are allowed in specification statements.
For more information, see “Pure Procedures”.
• ELEMENTAL user-defined procedures
An elemental user-defined procedure is a restricted form of pure procedure. An elemental
procedure can be passed an array, which is acted upon one element at a time. To specify an
elemental procedure, use the ELEMENTAL prefix in the function or subroutine statement.
For more information, see “Functions” and “Subroutines”.

1-3
1 Intel Fortran Language Reference

• CPU_TIME intrinsic subroutine

This new intrinsic subroutine returns a processor-dependent approximation of processor time.
For more information, see “CPU_TIME”.
• NULL intrinsic function
In Fortran 90, there was no way to assign a null value to the pointer by using a pointer
assignment operation. A Fortran 90 pointer had to be explicitly allocated, nullified, or
associated with a target during execution before association status could be determined.
Fortran 95 provides the NULL intrinsic function that can be used to nullify a pointer.
For more information, see “NULL”.
• New obsolescent features
Fortran 95 deletes several language features that were obsolescent in Fortran 90, and
identifies new obsolescent features.
Intel Fortran fully supports features deleted in Fortran 95.
For more information, see Appendix A, “Deleted and Obsolescent Language Features”.

Improved Features
The following Fortran 95 features improve previous Fortran features:
• Derived-type structure default initialization
In derived-type definitions, you can now specify default initial values for derived-type
components.
For more information, see “Default Initialization”.
• Pointer initialization
In Fortran 90, there was no way to define the initial value of a pointer. You can now specify
default initialization for a pointer.
For more information, see “Derived-Type Definition” and “Default Initialization”.
• Automatic deallocation of allocatable arrays
Allocatable arrays whose status is allocated upon routine exit are now automatically
deallocated.
For more information, see “Allocation of Allocatable Arrays”.
• Enhanced CEILING and FLOOR intrinsic functions
KIND can now be specified for these intrinsic functions.
For more information, see “CEILING” and “FLOOR”.
• Enhanced MAXLOC and MINLOC intrinsic functions
DIM can now be specified for these intrinsic functions.
For more information, see “MAXLOC” and “MINLOC”.

1-4
 Overview 1
• Enhanced SIGN intrinsic function
When a specific compiler option is specified, the SIGN function can now distinguish between
positive and negative zero if the processor is capable of doing so.
For more information, see “SIGN”.
• Printing of –0.0
When a specific compiler option is specified, a floating-point value of minus zero (–0.0) can
now be printed if the processor can represent it.
• Enhanced WHERE construct
The WHERE construct has been improved to allow nested WHERE constructs and a masked
ELSEWHERE statement. WHERE constructs can now be named.
For more information, see “WHERE Statement and Construct”.
• Generic identifier allowed in END INTERFACE statement
The END INTERFACE statement of an interface block defining a generic routine now can
specify a generic identifier.
For more information, see “Defining Explicit Interfaces”.
• Zero-length formats
On output, when using I, B, O, Z, and F edit descriptors, the specified value of the field width
can be zero. In such cases, the compiler selects the smallest possible positive actual field
width that does not result in the field being filled with asterisks (*).
• Comments allowed in namelist input
Fortran 95 allows comments (beginning with !) in namelist input data.

Fortran 90 Features
This section briefly describes the Fortran 90 language features that have been implemented in Intel
Fortran. Some features are new, while others are improvements to previous Fortran features.

New Features
The following Fortran 90 features are new to Fortran:
• Free source form
Fortran 90 provides a new free source form where line positions have no special meaning.
There are no reserved columns, trailing comments can appear, and blanks have significance
under certain circumstances (for example, P R O G R A M is not allowed as an alternative for
PROGRAM).
For more information, see “Free Source Form”.

1-5
1 Intel Fortran Language Reference

• Modules
Fortran 90 provides a new form of program unit called a module, which is more powerful
than (and overcomes limitations of) FORTRAN 77 block data program units.
A module is a set of declarations that are grouped together under a single, global name.
Modules let you encapsulate a set of related items such as data, procedures, and procedure
interfaces, and make them available to another program unit.
Module items can be made private to limit accessibility, provide data abstraction, and to
create more secure and portable programs.
For more information, see “Modules and Module Procedures”.
• User-defined (derived) data types and operators
Fortran 90 lets you define new data types derived from any combination of the intrinsic data
types and derived types. The derived-type object can be accessed as a whole, or its individual
components can be accessed directly.
You can extend the intrinsic operators (such as + and *) to user-defined data types, and also
define new operators for operands of any type.
For more information, see “Derived Data Types” and “Defining Generic Operators”.
• Array operations and features
In Fortran 90, intrinsic operators and intrinsic functions can operate on array-valued operands
(whole arrays or array sections).
New features for arrays include whole, partial, and masked array assignment (including the
WHERE statement for selective assignment), and array-valued constants and expressions.
You can create user-defined array-valued functions, use array constructors to specify values
of a one-dimensional array, and allocate arrays dynamically (using ALLOCATABLE and
POINTER attributes).
New intrinsic procedures create multidimensional arrays, manipulate arrays, perform
operations on arrays, and support computations involving arrays (for example, SUM sums the
elements of an array).
For more information, see “Arrays” and Chapter 9, “Intrinsic Procedures”.
• Generic user-defined procedures
In Fortran 90, user-defined procedures can be placed in generic interface blocks. This allows
the procedures to be referenced using the generic name of the block.
Selection of a specific procedure within the block is based on the properties of the argument,
the same way as specific intrinsic functions are selected based on the properties of the
argument when generic intrinsic function names are used.
For more information, see “Defining Generic Names for Procedures”.

1-6
 Overview 1
• Pointers
Fortran 90 pointers are mechanisms that allow dynamic access and processing of data. They
allow arrays to be sized dynamically and they allow structures to be linked together.
A pointer can be of any intrinsic or derived type. When a pointer is associated with a target, it
can appear in most expressions and assignments.
For more information, see “POINTER Attribute and Statement” and “Pointer Assignments”.
• Recursion
Fortran 90 procedures can be recursive if the keyword RECURSIVE is specified on the
FUNCTION or SUBROUTINE statement line.
For more information, see Chapter 8, “Program Units and Procedures”.
• Interface blocks
A Fortran 90 procedure can contain an interface block. Interface blocks can be used to do the
following:
— Describe the characteristics of an external or dummy procedure
— Define a generic name for a procedure
— Define a new operator (or extend an intrinsic operator)
— Define a new form of assignment
For more information, see “Procedure Interfaces”.
• Extensibility and redundancy
By using user-defined data types, operators, and meanings, you can extend Fortran to suit
your needs. These new data types and their operations can be packaged in modules, which can
be used by one or more program units to provide data abstraction.
With the addition of new features and capabilities, some old features become redundant and
may eventually be removed from the language. For example, the functionality of the ASSIGN
and assigned GO TO statements can be replaced more effectively by internal procedures. The
use of certain old features of Fortran can result in less than optimal performance on newer
hardware architectures.
For more information, see your user’s guide. For a list of obsolescent features, see
Appendix A, “Deleted and Obsolescent Language Features”.

Improved Features
The following Fortran 90 features improve previous Fortran features:

1-7
1 Intel Fortran Language Reference

• Additional features for source text

Lowercase characters are now allowed in source text. A semicolon can be used to separate
multiple statements on a single source line. Additional characters have been added to the
Fortran character set, and names can have up to 31 characters (including underscores).
For more information, see Chapter 2, “Program Structure, Characters, and Source Forms”.
• Improved facilities for numerical computation
Intrinsic data types can be specified in a portable way by using a kind type parameter
indicating the precision or accuracy required. There are also new intrinsic functions that allow
you to specify numeric precision and inquire about precision characteristics available on a
processor.
For more information, see Chapter 3, “Data Types, Constants, and Variables” and Chapter 9,
“Intrinsic Procedures”.
• Additional input/output features
Fortran 90 provides additional keywords for the OPEN and INQUIRE statements. It also
permits namelist formatting, and nonadvancing (stream) character-oriented input and output.
For more information on formatting, see Chapter 10, “Data Transfer I/O Statements”; on
OPEN and INQUIRE, see Chapter 12, “File Operation I/O Statements”.
• Additional control constructs
Fortran 90 provides a new control construct (CASE) and improves the DO construct. The DO
construct can now use CYCLE and EXIT statements, and can have additional (or no) control
clauses (for example, WHILE). All control constructs (CASE, DO, and IF) can now be
named.
For more information, see Chapter 7, “Execution Control”.
• Additional intrinsic procedures
Fortran 90 provides many more intrinsic procedures than existed in FORTRAN 77. Many of
these new intrinsics support mathematical operations on arrays, including the construction
and transformation of arrays. New bit manipulation and numerical accuracy intrinsics have
been added.
For more information, see Chapter 9, “Intrinsic Procedures”.
• Additional specification statements
The following specification statements are new in Fortran 90:
— The INTENT statement (“INTENT Attribute and Statement”)
— The OPTIONAL statement (“OPTIONAL Attribute and Statement”)
— The Fortran 90 POINTER statement (“POINTER Attribute and Statement”)
— The PUBLIC and PRIVATE statements (“PRIVATE and PUBLIC Attributes and
Statements”)

1-8
 Overview 1
• Additional way to specify attributes
Fortran 90 lets you specify attributes (such as PARAMETER, SAVE, and INTRINSIC) in
type declaration statements, as well as in specification statements.
For more information, see “Type Declaration Statements”.
• Scope and Association
These concepts were implicit in FORTRAN 77, but they are explicitly defined in Fortran 90.
In FORTRAN 77, the term scoping unit applies to a program unit, but Fortran 90 expands the
term to include internal procedures, interface blocks, and derived-type definitions.
For more information, see Chapter 15, “Scope and Association”.

1-9
1 Intel Fortran Language Reference

1-10
Program Structure,
Characters, and Source
Forms 2
This chapter contains information on the following topics:
• An overview of program structure, including general information on statements and names
(see “Program Structure”)
• “Character Sets”
• “Source Forms”

Program Structure
A Fortran program consists of one or more program units. A program unit is usually a sequence of
statements that define the data environment and the steps necessary to perform calculations; it is
terminated by an END statement.
A program unit can be either a main program, an external subprogram, a module, or a block data
program unit. An executable program contains one main program, and, optionally, any number of
the other kinds of program units. Program units can be separately compiled.
An external subprogram is a function or subroutine that is not contained within a main program, a
module, or another subprogram. It defines a procedure to be performed and can be invoked from
other program units of the Fortran program. Modules and block data program units are not
executable, so they are not considered to be procedures. (Modules can contain module procedures,
though, which are executable.)
Modules contain definitions that can be made accessible to other program units: data and type
definitions, definitions of procedures (called module subprograms), and procedure interfaces.
Module subprograms can be either functions or subroutines. They can be invoked by other module
subprograms in the module, or by other program units that access the module.
A block data program unit specifies initial values for data objects in named common blocks. In
Fortran 95/90, this type of program unit can be replaced by a module program unit.

2-1
2 Intel Fortran Language Reference

Main programs, external subprograms, and module subprograms can contain internal
subprograms. The entity that contains the internal subprogram is its host. Internal subprograms
can be invoked only by their host or by other internal subprograms in the same host. Internal
subprograms must not contain internal subprograms.

See Also
Chapter 8, “Program Units and Procedures”, for details on program units and procedures

Statements
Program statements are grouped into two general classes: executable and nonexecutable. An
executable statement specifies an action to be performed. A nonexecutable statement describes
program attributes, such as the arrangement and characteristics of data, as well as editing and
data-conversion information.

Order of Statements in a Program Unit

Figure 2-1 shows the required order of statements in a Fortran program unit. In this figure, vertical
lines separate statement types that can be interspersed. For example, you can intersperse DATA
statements with executable constructs.
Horizontal lines indicate statement types that cannot be interspersed. For example, you cannot
intersperse DATA statements with CONTAINS statements.

2-2
 Program Structure, Characters, and Source Forms 2
Figure 2-1 Required Order of Statements

OPTIONS Statements

PROGRAM, FUNCTION. SUBROUTINE,

MODULE, or BLOCK DATA Statement

USE Statements

IMPLICIT NONE Statements

Comment PARAMETER IMPLICIT

Lines, Statements Statements
INCLUDE NAMELIST,
Statements, FORMAT, Derived−Type Definitions,
and and PARAMETER Interface Blocks,
Directives ENTRY and DATA Type Declaration Statements,
Statements Statements Statement Function Statements,
and Specification Statements

DATA Executable
Statements Statements

CONTAINS Statement

Internal Subprograms
or Module Subprograms

END Statement

ZK−6516A−GE

Note that in this figure, INCLUDE statements, directives, OPTIONS statements, and the order of
NAMELIST statements are language extensions.
PUBLIC and PRIVATE statements are only allowed in the scoping units of modules. In Fortran
95/90, NAMELIST statements can appear only among specification statements. However, Intel®
Fortran allows them to also appear among executable statements.

2-3
2 Intel Fortran Language Reference

Table 2-1 shows other statements restricted from different types of scoping units.

Table 2-1 Statements Restricted in Scoping Units

Scoping Unit Restricted Statements
Main program ENTRY and RETURN statements
1
Module ENTRY, FORMAT, OPTIONAL, and INTENT statements,
statement functions, and executable statements
Block data program unit CONTAINS, ENTRY, and FORMAT statements, interface
blocks, statement functions, and executable statements
Internal subprogram CONTAINS and ENTRY statements
Interface body CONTAINS, DATA, ENTRY, SAVE, and FORMAT
statements, statement functions, and executable
statements
1. The scoping unit of a module does not include any module subprograms that the module contains.

See Also
“Scope” for details on scoping units

Names
Names identify entities within a Fortran program unit (such as variables, function results, common
blocks, named constants, procedures, program units, namelist groups, and dummy arguments). In
FORTRAN 77, names were called "symbolic names".
A name can contain letters, digits, underscores ( _ ), and the dollar sign ($) special character. The
first character must be a letter or a dollar sign.
In Fortran 95/90, a name can contain up to 31 characters. Intel® Fortran allows names up to 63
characters.
The length of a module name (in MODULE and USE statements) may be restricted by your file
system.

NOTE. Be careful when defining names that contain dollar signs. On Linux*
and Windows* systems, a dollar sign can be a symbol for command or symbol
substitution in various shell and utility commands.

In an executable program, the names of the following entities are global and must be unique in the
entire program:

2-4
 Program Structure, Characters, and Source Forms 2
• Program units
• External procedures
• Common blocks
• Modules

Examples
The following examples show valid and invalid names:

Valid
NUMBER
FIND_IT
X

Invalid Explanation
5Q Begins with a numeral.
B.4 Contains a special character other than _ or $.
_WRONG Begins with an underscore.

See Also
“Scope” for details on the scope of names

Character Sets
Intel Fortran supports the following characters:
• The Fortran 95/90 character set which consists of the following:
— All uppercase and lowercase letters (A through Z and a through z)
— The numerals 0 through 9
— The underscore ( _ )
— The following special characters:

Character Name Character Name

∆ or <Tab> Blank (space) or tab : Colon
= Equal sign ! Exclamation point
+ Plus sign " Quotation mark
– Minus sign % Percent sign
* Asterisk & Ampersand

2-5
2 Intel Fortran Language Reference

Character Name Character Name

/ Slash ; Semicolon
( Left parenthesis < Less than
) Right parenthesis > Greater than
, Comma ? Question mark
. Period (decimal point) $ Dollar sign (currency symbol)
’ Apostrophe

• Other printable characters

Printable characters include the tab character (09 hex) and ASCII characters with codes in the
range 20(hex) through 7E(hex). Printable characters that are not in the Fortran 95/90
character set can only appear in comments, character constants, Hollerith constants, character
string edit descriptors, and input/output records.
Uppercase and lowercase letters are treated as equivalent when used to specify program behavior
(except in character constants and Hollerith constants).

See Also
• Appendix C, “The ASCII Character Set for Linux Systems”, for details on the ASCII
character set for Linux systems
• The online documentation for Windows* systems for details on other character sets available
for those systems

Source Forms
Within a program, source code can be in free, fixed, or tab form. Fixed or tab forms must not be
mixed with free form in the same source program, but different source forms can be used in
different source programs.
All source forms allow lowercase characters to be used as an alternative to uppercase characters.
Several characters are indicators in source code (unless they appear within a comment or a
Hollerith or character constant). The following are rules for indicators in all source forms:

2-6
 Program Structure, Characters, and Source Forms 2
• Comment indicator
A comment indicator can precede the first statement of a program unit and appear anywhere
within a program unit. If the comment indicator appears within a source line, the comment
extends to the end of the line.
An all blank line is also a comment line.
Comments have no effect on the interpretation of the program unit.
For more information on comment indicators in free source form, see “Free Source Form”; in
fixed and tab source forms, see “Fixed and Tab Source Forms”.
• Statement separator
More than one statement (or partial statement) can appear on a single source line if a
statement separator is placed between the statements. The statement separator is a semicolon
character (;).
Consecutive semicolons (with or without intervening blanks) are considered to be one
semicolon.
If a semicolon is the last character on a line, or the last character before a comment, it is
ignored.
• Continuation indicator
A statement can be continued for more than one line by placing a continuation indicator on
the line. Intel Fortran allows up to 511 continuation lines in a source program.
Comments can occur within a continued statement, but comment lines cannot be continued.
Within a program unit, the END statement cannot be continued, and no other statement in the
program unit can have an initial line that appears to be the program unit END statement.
For more information on continuation indicators in free source form, see “Free Source Form”;
in fixed and tab source forms, see “Fixed and Tab Source Forms”.
Table 2-2 summarizes characters used as indicators in source forms:

Table 2-2 Indicators in Source Forms

Source Item Indicator1 Source Form Position
Comment ! All forms Anywhere in source code

Comment line ! Free At the beginning of the

source line
!, C, or * Fixed In column 1
Tab In column 1

2-7
2 Intel Fortran Language Reference

Table 2-2 Indicators in Source Forms

Source Item Indicator1 Source Form Position
Continuation line2 & Free At the end of the source line
Any character except Fixed In column 6
zero or blank
Any digit except zero Tab After the first tab

Statement separator ; All forms Between statements on the

same line

Statement label 1 to 5 decimal digits Free Before a statement

Fixed In columns 1 through 5
Tab Before the first tab

A debugging statement3 D Fixed In column 1

Tab In column 1
1. If the character appears in a Hollerith or character constant, it is not an indicator and is ignored.
2. For all forms, up to 511 continuation lines are allowed.
3. Fixed and tab forms only.

Source code can be written so that it is useable for all source forms (see “Source Code Useable for
All Source Forms”).

Statement Labels
A statement label (or statement number) identifies a statement so that other statements can refer to
it, either to get information or to transfer control. A label can precede any statement that is not part
of another statement.
A statement label must be one to five decimal digits long; blanks and leading zeros are ignored.
An all-zero statement label is invalid, and a blank statement cannot be labeled.
Labeled FORMAT and labeled executable statements are the only statements that can be referred
to by other statements. FORMAT statements are referred to only in the format specifier of an I/O
statement or in an ASSIGN statement. Two statements within a scoping unit cannot have the same
label.
See Also
• “Free Source Form” for details on labels in free source form
• “Fixed and Tab Source Forms” for details on labels in fixed and tab source forms

2-8
 Program Structure, Characters, and Source Forms 2
Free Source Form
In free source form, statements are not limited to specific positions on a source line. In Fortran
95/90, a free form source line can contain from 0 to 132 characters. Intel Fortran allows the line to
be of any length.
Blank characters are significant in free source form. The following are rules for blank characters:
• Blank characters must not appear in lexical tokens, except within a character context. For
example, there can be no blanks between the exponentiation operator **. Blank characters
can be used freely between lexical tokens to improve legibility.
• Blank characters must be used to separate names, constants, or labels from adjacent
keywords, names, constants, or labels. For example, consider the following statements:
INTEGER NUM
GO TO 40
20 DO K=1,8
The blanks are required after INTEGER, TO, 20, and DO.
• Some adjacent keywords must have one or more blank characters between them. Others do
not require any; for example, BLOCK DATA can also be spelled BLOCKDATA. The
following list shows which keywords have optional or required blanks:

Optional Blanks Required Blanks

BLOCK DATA CASE DEFAULT
DOUBLE COMPLEX DO WHILE
DOUBLE PRECISION IMPLICIT type-specifier
ELSE IF IMPLICIT NONE
ELSE WHERE INTERFACE ASSIGNMENT
END BLOCK DATA INTERFACE OPERATOR
END DO MODULE PROCEDURE
END FILE RECURSIVE FUNCTION
END FORALL RECURSIVE SUBROUTINE
END FUNCTION RECURSIVE type-specifier FUNCTION
END IF type-specifier FUNCTION
END INTERFACE type-specifier RECURSIVE FUNCTION
END MODULE
END PROGRAM
END SELECT
END SUBROUTINE

2-9
2 Intel Fortran Language Reference

Optional Blanks Required Blanks

END TYPE
END WHERE
GO TO
IN OUT
SELECT CASE

For information on statement separators (;) in all forms, see “Source Code Useable for All Source
Forms”.

Comment Indicator
In free source form, the exclamation point character (!) indicates a comment if it is within a source
line, or a comment line if it is the first character in a source line.

Continuation Indicator
In free source form, the ampersand character (&) indicates a continuation line (unless it appears in
a Hollerith or character constant, or within a comment). The continuation line is the first
noncomment line following the ampersand. Although Fortran 95/90 permits up to 39 continuation
lines in free-form programs, Intel Fortran allows up to 511 continuation lines.
The following shows a continued statement:
TCOSH(Y) = EXP(Y) + & ! The initial statement line
EXP(-Y) ! A continuation line
If the first nonblank character on the next noncomment line is an ampersand, the statement
continues at the character following the ampersand. For example, the preceding example can be
written as follows:
TCOSH(Y) = EXP(Y) + &
& EXP(-Y)
If a lexical token must be continued, the first nonblank character on the next noncomment line
must be an ampersand followed immediately by the rest of the token. For example:
TCOSH(Y) = EXP(Y) + EX&
&P(-Y)
If you continue a character constant, an ampersand must be the first non-blank character of the
continued line; the statement continues with the next character following the ampersand. For
example:
ADVERTISER = "Davis, O’Brien, Chalmers & Peter&
&son"

2-10
 Program Structure, Characters, and Source Forms 2
ARCHITECT = "O’Connor, Emerson, and Davis&
& Associates"
If the ampersand is omitted on the continued line, the statement continues with the first non-blank
character in the continued line. So, in the preceding example, the whitespace before "Associates"
would be included.
The ampersand cannot be the only nonblank character in a line, or the only nonblank character
before a comment; an ampersand in a comment is ignored.

See Also
“Source Code Useable for All Source Forms” for details on the general rules for all source forms

Fixed and Tab Source Forms

In Fortran 95, fixed source form is identified as obsolescent.
In fixed and tab source forms, there are restrictions on where a statement can appear within a line.
By default, a statement can extend to character position 72. In this case, any text following
position 72 is ignored and no warning message is printed. You can specify a compiler option to
extend source lines to character position 132.
Except in a character context, blanks are not significant and can be used freely throughout the
program for maximum legibility.
Some Fortran compilers use blanks to pad short source lines out to 72 characters. By default, Intel
Fortran does not. If portability is a concern, you can use the concatenation operator to prevent
source lines from being padded by other Fortran compilers (see the example in "Continuation
Indicator" below) or you can force short source lines to be padded by using a compiler option.

Comment Indicator
In fixed and tab source forms, the exclamation point character (!) indicates a comment if it is
within a source line. (It must not appear in column 6 of a fixed form line; that column is reserved
for a continuation indicator.)
The letter C (or c), an asterisk (*), or an exclamation point (!) indicates a comment line when it
appears in column 1 of a source line.

Continuation Indicator
In fixed and tab source forms, a continuation line is indicated by one of the following:
• For fixed form: Any character (except a zero or blank) in column 6 of a source line
• For tab form: Any digit (except zero) after the first tab

2-11
2 Intel Fortran Language Reference

The compiler considers the characters following the continuation indicator to be part of the
previous line. Although Fortran 95/90 permits up to 19 continuation lines in a fixed-form program,
Intel Fortran allows up to 511 continuation lines.
If a zero or blank is used as a continuation indicator, the compiler considers the line to be an initial
line of a Fortran statement.
The statement label field of a continuation line must be blank (except in the case of a debugging
statement).
When long character or Hollerith constants are continued across lines, portability problems can
occur. Use the concatenation operator to avoid such problems. For example:
PRINT *, ’This is a very long character constant ’//
+ ’which is safely continued across lines’
Use this same method when initializing data with long character or Hollerith constants. For
example:
CHARACTER*(*) LONG_CONST
PARAMETER (LONG_CONST = ’This is a very long ’//
+ ’character constant which is safely continued ’//
+ ’across lines’)
CHARACTER*100 LONG_VAL
DATA LONG_VAL /LONG_CONST/
Hollerith constants must be converted to character constants before using the concatenation
method of line continuation.

Debugging Statement Indicator

In fixed and tab source forms, the statement label field can contain a statement label, a comment
indicator, or a debugging statement indicator.
The letter D indicates a debugging statement when it appears in column 1 of a source line. The
initial line of the debugging statement can contain a statement label in the remaining columns of
the statement label field.
If a debugging statement is continued onto more than one line, every continuation line must begin
with a D and a continuation indicator.
By default, the compiler treats debugging statements as comments. However, you can specify a
compiler option to force the compiler to treat debugging statements as source text to be compiled.

See Also
• “OPTIONS Statement”

2-12
 Program Structure, Characters, and Source Forms 2
• “Source Forms” for details on the general rules for all source forms, statement separators (;)
in all forms, and statement labels
• Appendix A, “Deleted and Obsolescent Language Features”, for details on obsolescent
features in Fortran 95
• Your user’s guide for details on compiler options

Fixed-Format Lines
In fixed source form, a source line has columns divided into fields for statement labels,
continuation indicators, statement text, and sequence numbers. Each column represents a single
character.
The column positions for each field follow:
Field Column
Statement label 1 through 5
Continuation indicator 6
Statement 7 through 72 (or 132 with a compiler option)
Sequence number 73 through 80
By default, a sequence number or other identifying information can appear in columns 73 through
80 of any fixed-format line in an Intel Fortran program. The compiler ignores the characters in this
field.
If you extend the statement field to position 132, the sequence number field does not exist.

NOTE. If you use the sequence number field, do not use tabs anywhere in the
source line, or the compiler may interpret the sequence numbers as part of the
statement field in your program.

See Also
• “Source Forms” for details on the general rules for all source forms
• “Fixed and Tab Source Forms” for details on the general rules for fixed and tab source forms
Tab-Format Lines
In tab source form, you can specify a statement label field, a continuation indicator field, and a
statement field, but not a sequence number field.
Figure 2-2 shows equivalent source lines coded with tab and fixed source form.

2-13
2 Intel Fortran Language Reference

Figure 2-2 Line Formatting Example

Format using TAB Character Character−per−Column Format

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
C TAB FIRST VALUE C F I R S T V A L U E

10 TAB I = J + 5*K + 1 0 I = J + 5 * K +

TAB 1 L*M 1 L * M

TAB IVAL = I+2 I V A L = I + 2

ZK−0614−GE

The statement label field precedes the first tab character. The continuation indicator field and
statement field follow the first tab character.
The continuation indicator is any nonzero digit. The statement field can contain any Fortran
statement. A Fortran statement cannot start with a digit.
If a statement is continued, a continuation indicator must be the first character (following the first
tab) on the continuation line.
Many text editors and terminals advance the terminal print carriage to a predefined print position
when you press the <Tab> key. However, the Intel Fortran compiler does not interpret the tab
character in this way. It treats the tab character in a statement field the same way it treats a blank
character. In the source listing that the compiler produces, the tab causes the character that follows
to be printed at the next tab stop (usually located at columns 9, 17, 25, 33, and so on).

NOTE. If you use the sequence number field, do not use tabs anywhere in the
source line, or the compiler may interpret the sequence numbers as part of the
statement field in your program.

2-14
 Program Structure, Characters, and Source Forms 2
See Also
• “Source Forms” for details on the general rules for all source forms
• “Fixed and Tab Source Forms” for details on the general rules for fixed and tab source forms

Source Code Useable for All Source Forms

To write source code that is useable for all source forms (free, fixed, or tab), follow these rules:
Blanks Treat as significant (see “Free Source Form”).
Statement labels Place in column positions 1 through 5 (or before the first tab character).
Statements Start in column 7 (or after the first tab character).
Comment indicator Use only !. Place anywhere except in column position 6 (or immediately
after the first tab character).
Continuation indicator Use only &. Place in column position 73 of the initial line and each
continuation line, and in column 6 of each continuation line (no tab
character can precede the ampersand in column 6).
The following example is valid for all source forms:
Column:
12345678... 73
________________________________________________________________________
! Define the user function MY_SIN
DOUBLE PRECISION FUNCTION MY_SIN(X)
MY_SIN = X - X**3/FACTOR(3) + X**5/FACTOR(5) &
& - X**7/FACTOR(7)
CONTAINS
INTEGER FUNCTION FACTOR(N)
FACTOR = 1
DO 10 I = N, 1, -1
10 FACTOR = FACTOR * I
END FUNCTION FACTOR
END FUNCTION MY_SIN

2-15
2 Intel Fortran Language Reference

2-16
Data Types, Constants, and
Variables 3
Each constant, variable, array, expression, or function reference in a Fortran statement has a data
type. The data type of these items can be inherent in their construction, implied by convention, or
explicitly declared.
Each data type has the following properties:
• A name
The names of the intrinsic data types are predefined, while the names of derived types are
defined in derived-type definitions. Data objects (constants, variables, or parts of constants or
variables) are declared using the name of the data type.
• A set of associated values
Each data type has a set of valid values. Integer and real data types have a range of valid
values. Complex and derived types have sets of values that are combinations of the values of
their individual components.
• A way to represent constant values for the data type
A constant is a data object with a fixed value that cannot be changed during program
execution. The value of a constant can be a numeric value, a logical value, or a character
string.
A constant that does not have a name is a literal constant. A literal constant must be of
intrinsic type and it cannot be array-valued.
A constant that has a name is a named constant. A named constant can be of any type,
including derived type, and it can be array-valued. A named constant has the PARAMETER
attribute and is specified in a type declaration statement or PARAMETER statement.
• A set of operations to manipulate and interpret these values
The data type of a variable determines the operations that can be used to manipulate it.
Besides intrinsic operators and operations, you can also define operators and operations.
This chapter contains information on the following topics:
• “Intrinsic Data Types” (This topic also discusses the forms for constants.)

3-1
3 Intel Fortran Language Reference

• “Derived Data Types”

• “Binary, Octal, Hexadecimal, and Hollerith Constants”
• “Variables”

See Also
• “Type Declaration Statements”
• “Defined Operations”
• “Expressions” for details on valid operations for data types
• “PARAMETER Attribute and Statement” for details on named constants and the
PARAMETER attribute
• Your user’s guide for details on ranges for numeric literal constants

Intrinsic Data Types

Intel® Fortran provides the following intrinsic data types:
• INTEGER (see “Integer Data Types”)
There are four kind parameters for data of type integer:
— INTEGER([KIND=]1) or INTEGER*1
— INTEGER([KIND=]2) or INTEGER*2
— INTEGER([KIND=]4) or INTEGER*4
— INTEGER([KIND=]8) or INTEGER*8
• REAL (see “Real Data Types”)
There are three kind parameters for data of type real:
— REAL([KIND=]4) or REAL*4
— REAL([KIND=]8) or REAL*8
— REAL([KIND=]16) or REAL*16
• DOUBLE PRECISION (see “Real Data Types”)
No kind parameter is permitted for data declared with type DOUBLE PRECISION. This data
type is the same as REAL([KIND=]8).
• COMPLEX (see “Complex Data Types”)
There are three kind parameters for data of type complex:
— COMPLEX([KIND=]4) or COMPLEX*8
— COMPLEX([KIND=]8) or COMPLEX*16
— COMPLEX([KIND=]16) or COMPLEX*32

3-2
 Data Types, Constants, and Variables 3
• DOUBLE COMPLEX (see “Complex Data Types”)
No kind parameter is permitted for data declared with type DOUBLE COMPLEX. This data
type is the same as COMPLEX([KIND=]8).
• LOGICAL (see “Logical Data Types”)
There are four kind parameters for data of type logical:
— LOGICAL([KIND=]1) or LOGICAL*1
— LOGICAL([KIND=]2) or LOGICAL*2
— LOGICAL([KIND=]4) or LOGICAL*4
— LOGICAL([KIND=]8) or LOGICAL*8
• CHARACTER (see “Character Data Type”)
There is one kind parameter for data of type character: CHARACTER([KIND=]1).
• BYTE
This is a 1-byte value; the data type is equivalent to INTEGER([KIND=]1).
The intrinsic function KIND can be used to determine the kind type parameter of a representation
method.
For more portable programs, you should not use the forms INTEGER([KIND=]n) or
REAL([KIND=]n). You should instead define a PARAMETER constant using the
SELECTED_INT_KIND or SELECTED_REAL_KIND function, whichever is appropriate. For
example, the following statements define a PARAMETER constant for an INTEGER kind that has
9 digits:
INTEGER, PARAMETER :: MY_INT_KIND = SELECTED_INT_KIND(9)
...
INTEGER(MY_INT_KIND) :: J
...
Note that syntax separator :: is used in type declaration statements.
The following sections describe the intrinsic data types and forms for literal constants for each
type.

See Also
• “Type Declaration Statements”
• “KIND”
• “Declaration Statements for Noncharacter Types” and “Declaration Statements for Character
Types” for details on declaration statements for intrinsic data types
• “Expressions” for details on operations for intrinsic data types
• Table 15-2 for details on storage requirements for intrinsic data types

3-3
3 Intel Fortran Language Reference

Integer Data Types

Integer data types can be specified as follows:
INTEGER
INTEGER([KIND=]n)
INTEGER*n
n
Is kind 1, 2, 4, or 8.
If a kind parameter is specified, the integer has the kind specified. If a kind parameter is not
specified, integer constants are interpreted as follows:
• If the integer constant is within the default integer kind range, the kind is default integer.
Default integer is INTEGER(4). You can change the default behavior by specifying the
compiler option that controls the default integer kind.
• If the integer constant is outside the default integer kind range, the kind of the integer constant
is the smallest integer kind which holds the constant.

Integer Constants
An integer constant is a whole number with no decimal point. It can have a leading sign and is
interpreted as a decimal number.
Integer constants take the following form:
[s]n[n...][ _k]
s
Is a sign; required if negative (–), optional if positive (+).
n
Is a decimal digit (0 through 9). Any leading zeros are ignored.
k
Is the optional kind parameter: 1 for INTEGER(1), 2 for INTEGER(2), 4 for INTEGER(4), or 8
for INTEGER(8). It must be preceded by an underscore ( _ ).
An unsigned constant is assumed to be nonnegative.
Integers are expressed in decimal values (base 10) by default. To specify a constant that is not in
base 10, use the following syntax:
[s][[base] #]nnn...
s
Is an optional plus (+) or minus (–) sign.

3-4
 Data Types, Constants, and Variables 3
base
Is any constant from 2 through 36.
If base is omitted but # is specified, the integer is interpreted in base 16. If both base and # are
omitted, the integer is interpreted in base 10.
For bases 11 through 36, the letters A through Z represent numbers greater than 9. For example,
for base 36, A represents 10, B represents 11, C represents 12, and so on, through Z, which
represents 35. The case of the letters is not significant.

Examples
The following examples show valid and invalid integer (base 10) constants:

Valid
0
-127
+32123
47_2

Invalid Explanation
9999999999999999999 Number too large.
3.14 Decimal point not allowed; this is a valid REAL constant.
32,767 Comma not allowed.
33_3 3 is not a valid kind for integers.
The following integers (most of which are not base 10) are all assigned a value equal to 3,994,575
decimal:
I = 2#1111001111001111001111
m = 7#45644664
J = +8#17171717
K = #3CF3CF
n = +17#2DE110
L = 3994575
index = 36#2DM8F
You can use integer constants to assign values to data. The following table shows assignments to
different data and lists the integer and hexadecimal values in the data:

3-5
3 Intel Fortran Language Reference

Integer Value in Hexadecimal Value in

Fortran Assignment the Data the Data
LOGICAL(1)X
INTEGER(1)X
X = –128 –128 Z'80'
X = 127 127 Z'7F'
X = 255 –1 Z'FF'
LOGICAL(2)X
INTEGER(2)X
X = 255 255 Z'FF'
X = –32768 –32768 Z'8000'
X = 32767 32767 Z'7FFF'
X = 65535 –1 Z'FFFF'

See Also
• “Numeric Expressions” for details on integer constants used in expressions
• Your user’s guide for details on the ranges for integer types and kinds

Real Data Types

Real data types can be specified as follows:
REAL
REAL([KIND=]n)
REAL*n
DOUBLE PRECISION
n
Is kind 4, 8, or 16.
If a kind parameter is specified, the real constant has the kind specified. If a kind parameter is not
specified, the kind is default real. Default real is REAL(4). You can change the default behavior
by specifying the compiler option that controls the default real kind.
DOUBLE PRECISION is REAL(8). No kind parameter is permitted for data declared with type
DOUBLE PRECISION.

3-6
 Data Types, Constants, and Variables 3
General Rules for Real Constants
A real constant approximates the value of a mathematical real number. The value of the constant
can be positive, zero, or negative.
The following is the general form of a real constant with no exponent part:
[s]n[n...][ _k]
A real constant with an exponent part has one of the following forms:
[s]n[n...]E[s]nn...[_k]
[s]n[n...]D[s]nn...
[s]n[n...]Q[s]nn...
s
Is a sign; required if negative (–), optional if positive (+).
n
Is a decimal digit (0 through 9). A decimal point must appear if the real constant has no exponent
part.
k
Is the optional kind parameter: 4 for REAL(4), 8 for REAL(8), or 16 for REAL(16). It must be
preceded by an underscore ( _ ).

Rules and Behavior

Leading zeros (zeros to the left of the first nonzero digit) are ignored in counting significant digits.
For example, in the constant 0.00001234567, all of the nonzero digits, and none of the zeros, are
significant. (See the following sections for the number of significant digits each kind type
parameter typically has).
The exponent represents a power of 10 by which the preceding real or integer constant is to be
multiplied (for example, 1.0E6 represents the value 1.0 * 10**6).
A real constant with no exponent part and no kind type parameter is (by default) a single-precision
(REAL(4)) constant. You can change the default behavior by specifying the compiler option that
controls the default real kind.
If the real constant has no exponent part, a decimal point must appear in the string (anywhere
before the optional kind parameter). If there is an exponent part, a decimal point is optional in the
string preceding the exponent part; the exponent part must not contain a decimal point.
The exponent letter E denotes a single-precision real (REAL(4)) constant, unless the optional kind
parameter specifies otherwise. For example, –9.E2_8 is a double-precision constant (which can
also be written as –9.D2).
The exponent letter D denotes a double-precision real (REAL(8)) constant.

3-7
3 Intel Fortran Language Reference

The exponent letter Q denotes a quad-precision real (REAL(16)) constant.

A minus sign must appear before a negative real constant; a plus sign is optional before a positive
constant. Similarly, a minus sign must appear between the exponent letter (E, D, or Q) and a
negative exponent, whereas a plus sign is optional between the exponent letter and a positive
exponent.
If the real constant includes an exponent letter, the exponent field cannot be omitted, but it can be
zero.
To specify a real constant using both an exponent letter and a kind parameter, the exponent letter
must be E, and the kind parameter must follow the exponent part.

REAL(4) Constants
A single-precision REAL constant occupies four bytes of memory. The number of digits is
unlimited, but typically only the leftmost seven digits are significant.
IEEE* S_floating format is used.

Examples
The following examples show valid and invalid REAL(4) constants:

Valid
3.14159
3.14159_4
621712._4
–.00127
+5.0E3
2E–3_4

Invalid Explanation
1,234,567. Commas not allowed.
325E–47 Too small for REAL; this is a valid DOUBLE PRECISION constant.
–47.E47 Too large for REAL; this is a valid DOUBLE PRECISION constant.
625._6 6 is not a valid kind for reals.
100 Decimal point missing; this is a valid integer constant.
$25.00 Special character not allowed.

See Also
• “General Rules for Real Constants”

3-8
 Data Types, Constants, and Variables 3
• Your user’s guide for details on the format and range of REAL(4) data
• Your user’s guide for details on compiler options affecting Real data

REAL(8) or DOUBLE PRECISION Constants

A REAL(8) or DOUBLE PRECISION constant has more than twice the accuracy of a REAL(4)
number, and greater range.
A REAL(8) or DOUBLE PRECISION constant occupies eight bytes of memory. The number of
digits that precede the exponent is unlimited, but typically only the leftmost 15 digits are
significant.
IEEE T_floating format is used.

Examples
The following examples show valid and invalid REAL(8) or DOUBLE PRECISION constants:

Valid
123456789D+5
123456789E+5_8
+2.7843D00
–.522D–12
2E200_8
2.3_8
3.4E7_8

Invalid Explanation
–.25D0_2 2 is not a valid kind for reals.
+2.7182812846182 No D exponent designator is present; this is a valid single-precision
constant.
123456789.D400 Too large for any double-precision format.
123456789.D–400 Too small for any double-precision format.

See Also
• “General Rules for Real Constants”
• Your user’s guide for details on the format and range of DOUBLE PRECISION (REAL(8))
data
• Your user’s guide for details on compiler options affecting DOUBLE PRECISION data

3-9
3 Intel Fortran Language Reference

REAL(16) Constants
A REAL(16) constant has more than four times the accuracy of a REAL(4) number, and a greater
range.
A REAL(16) constant occupies 16 bytes of memory. The number of digits that precede the
exponent is unlimited, but typically only the leftmost 33 digits are significant.
IEEE X_floating format is used.

Examples
The following examples show valid and invalid REAL(16) constants:

Valid
123456789Q4000
–1.23Q–400
+2.72Q0
1.88_16

Invalid Explanation
1.Q5000 Too large.
1.Q–5000 Too small.

See Also
• “General Rules for Real Constants”
• Your user’s guide for details on the format and range of REAL(16) data

Complex Data Types

Complex data types can be specified as follows:
COMPLEX
COMPLEX([KIND=]n)
COMPLEX*s
DOUBLE COMPLEX
n
Is kind 4, 8, or 16.
s
Is 8, 16, or 32. COMPLEX(4) is specified as COMPLEX*8; COMPLEX(8) is specified as
COMPLEX*16; COMPLEX(16) is specified as COMPLEX*32.

3-10
 Data Types, Constants, and Variables 3
If a kind parameter is specified, the complex constant has the kind specified. If no kind parameter
is specified, the kind of both parts is default real, and the constant is of type default complex.
Default complex is COMPLEX(4). You can change the default behavior by specifying the
compiler option that controls the default real kind.
DOUBLE COMPLEX is COMPLEX(8). No kind parameter is permitted for data declared with
type DOUBLE COMPLEX.

General Rules for Complex Constants

A complex constant approximates the value of a mathematical complex number. The constant is a
pair of real or integer values, separated by a comma, and enclosed in parentheses. The first
constant represents the real part of that number; the second constant represents the imaginary part.
The following is the general form of a complex constant:
(c,c)
c
Is as follows:
• For COMPLEX(4) constants, c is an integer or REAL(4) constant.
• For COMPLEX(8) constants, c is an integer, REAL(4) constant, or DOUBLE PRECISION
(REAL(8)) constant. At least one of the pair must be DOUBLE PRECISION.
• For COMPLEX(16) constants, c is an integer, REAL(4) constant, REAL(8) constant, or
REAL(16) constant. At least one of the pair must be a REAL(16) constant.
Note that the comma and parentheses are required.

COMPLEX(4) Constants
A COMPLEX(4) constant is a pair of integer or single-precision real constants that represent a
complex number.
A COMPLEX(4) constant occupies eight bytes of memory and is interpreted as a complex
number.
If the real and imaginary part of a complex literal constant are both real, the kind parameter value
is that of the part with the greater decimal precision.
The rules for REAL(4) constants apply to REAL(4) constants used in COMPLEX constants. (See
“General Rules for Real Constants” and “REAL(4) Constants” for the rules on forming REAL(4)
constants.)
The REAL(4) constants in a COMPLEX constant have IEEE S_floating format.

Examples
The following examples show valid and invalid COMPLEX(4) constants:

3-11
3 Intel Fortran Language Reference

Valid
(1.7039,–1.70391)
(44.36_4,–12.2E16_4)
(+12739E3,0.)
(1,2)

Invalid Explanation
(–1.23,) Missing second integer or single-precision real constant.
(1.0, 2H12) Hollerith constant not allowed.

See Also
• “General Rules for Complex Constants”
• Your user’s guide for details on the format and range of COMPLEX (COMPLEX(4)) data
• Your user’s guide for details on compiler options affecting REAL data
COMPLEX(8) or DOUBLE COMPLEX Constants
A COMPLEX(8) or DOUBLE COMPLEX constant is a pair of constants that represents a
complex number. One of the pair must be a double-precision real constant, the other can be an
integer, single-precision real, or double-precision real constant.
A COMPLEX(8) or DOUBLE COMPLEX constant occupies 16 bytes of memory and is
interpreted as a complex number.
The rules for DOUBLE PRECISION (REAL(8)) constants also apply to the double precision
portion of COMPLEX(8) or DOUBLE COMPLEX constants. (See “General Rules for Real
Constants” and “REAL(8) or DOUBLE PRECISION Constants” for the rules on forming
DOUBLE PRECISION constants.)
The DOUBLE PRECISION constants in a COMPLEX(8) or DOUBLE COMPLEX constant have
IEEE T_floating format.

Examples
The following examples show valid and invalid COMPLEX(8) or DOUBLE COMPLEX
constants:

Valid
(1.7039,–1.7039D0)
(547.3E0_8,–1.44_8)

3-12
 Data Types, Constants, and Variables 3
(1.7039E0,–1.7039D0)
(+12739D3,0.D0)

Invalid Explanation
(1.23D0,) Missing second constant.
(1D1,2H12) Hollerith constants not allowed.
(1,1.2) Neither constant is DOUBLE PRECISION; this is a valid
single-precision constant.

See Also
• “General Rules for Complex Constants”
• Your user’s guide for details on the format and range of DOUBLE COMPLEX data
• Your user’s guide for details on compiler options affecting DOUBLE PRECISION data
COMPLEX(16) Constants
A COMPLEX(16) constant is a pair of constants that represents a complex number. One of the
pair must be a REAL(16) constant, the other can be an integer, single-precision real,
double-precision real, or REAL(16) constant.
A COMPLEX(16) constant occupies 32 bytes of memory and is interpreted as a complex number.
The rules for REAL(16) constants apply to REAL(16) constants used in COMPLEX constants.
(See “General Rules for Real Constants” and “REAL(16) Constants” for the rules on forming
REAL(16) constants.)
The REAL(16) constants in a COMPLEX constant have IEEE X_floating format.

Examples
The following examples show valid and invalid COMPLEX(16) constants:

Valid
(1.7039,–1.7039Q2)
(547.3E0_16,–1.44)
(+12739Q3,0.Q0)

Invalid Explanation
(1.23Q0,) Missing second constant.
(1D1,2H12) Hollerith constants not allowed.
(1.7039,–1.7039D0) Neither constant is REAL(16); this is a valid double-precision constant.

3-13
3 Intel Fortran Language Reference

See Also
• “General Rules for Complex Constants”
• Your user’s guide for details on the format and range of COMPLEX(16) data
• Your user’s guide for details on compiler options affecting REAL data

Logical Data Types

Logical data types can be specified as follows:
LOGICAL
LOGICAL([KIND=]n)
LOGICAL*n
n
Is kind 1, 2, 4, or 8.
If a kind parameter is specified, the logical constant has the kind specified. If no kind parameter is
specified, the kind of the constant is default logical.

Logical Constants
A logical constant represents only the logical values true or false, and takes one of the following
forms:
.TRUE.[_k]
.FALSE.[_k]
k
Is the optional kind parameter: 1 for LOGICAL(1), 2 for LOGICAL(2), 4 for LOGICAL(4), or 8
for LOGICAL(8). It must be preceded by an underscore ( _ ).
Logical data type ranges correspond to their comparable integer data type ranges. For example, the
LOGICAL(2) range is the same as the INTEGER(2) range.

See Also
Your user’s guide for details on integer data type ranges

Character Data Type

The character data type can be specified as follows:

3-14
 Data Types, Constants, and Variables 3
CHARACTER
CHARACTER([KIND=]n)
CHARACTER([LEN=]len)
CHARACTER([LEN=]len [,[KIND=]n])
CHARACTER(KIND=n [,LEN=len])
CHARACTER*len[,]
n
Is kind 1.
len
Is a string length (not a kind). For more information, see “Declaration Statements for Character
Types”.
If no kind type parameter is specified, the kind of the constant is default character.

Character Constants
A character constant is a character string enclosed in delimiters (apostrophes or quotation marks).
It takes one of the following forms:
[k_]'[ch...]' [C]
[k_]"[ch...]" [C]
k
Is the optional kind parameter: 1 (the default). It must be followed by an underscore ( _ ). Note
that in character constants, the kind must precede the constant.
ch
Is an ASCII character.
C
Is a C string specifier. C strings can be used to define strings with nonprintable characters. For
more information, see “C Strings in Character Constants”.

Rules and Behavior

The value of a character constant is the string of characters between the delimiters. The value does
not include the delimiters, but does include all blanks or tabs within the delimiters.
If a character constant is delimited by apostrophes, use two consecutive apostrophes ('') to place an
apostrophe character in the character constant.
Similarly, if a character constant is delimited by quotation marks, use two consecutive quotation
marks ("") to place a quotation mark character in the character constant.

3-15
3 Intel Fortran Language Reference

The length of the character constant is the number of characters between the delimiters, but two
consecutive delimiters are counted as one character.
The length of a character constant must be in the range of 0 to 2000. Each character occupies one
byte of memory.
If a character constant appears in a numeric context (such as an expression on the right side of an
arithmetic assignment statement), it is considered a Hollerith constant.
A zero-length character constant is represented by two consecutive apostrophes or quotation
marks.

Examples
The following examples show valid and invalid character constants:

Valid
"WHAT KIND TYPE? "
'TODAY''S DATE IS: '
"The average is: "
''

Invalid Explanation
'HEADINGS No trailing apostrophe.
'Map Number: " Beginning delimiter does not match ending delimiter.

See Also
“Declaration Statements for Character Types”

C Strings in Character Constants

String values in the C language are terminated with null characters (CHAR(0)) and can contain
nonprintable characters (such as backspace).
Nonprintable characters are specified by escape sequences. An escape sequence is denoted by
using the backslash (\) as an escape character, followed by a single character indicating the
nonprintable character desired.
This type of string is specified by using a standard string constant followed by the character C.
The standard string constant is then interpreted as a C-language constant. Backslashes are treated
as escapes, and a null character is automatically appended to the end of the string (even if the
string already ends in a null character).

3-16
 Data Types, Constants, and Variables 3
Table 3-1 shows the escape sequences that are allowed in character constants.

Table 3-1 C-Style Escape Sequences

Escape Sequence Represents
\a or \A A bell
\b or \B A backspace
\f or \F A formfeed
\n or \N A new line
\r or \R A carriage return
\t or \T A horizontal tab
\v or \V A vertical tab
\xhh or \Xhh A hexadecimal bit pattern
\ooo An octal bit pattern
\0 A null character
\\ A backslash (\)

If a string contains an escape sequence that isn't in this table, the backslash is ignored.
A C string must also be a valid Fortran string. If the string is delimited by apostrophes,
apostrophes in the string itself must be represented by two consecutive apostrophes ('').
For example, the escape sequence \'string causes a compiler error because Fortran interprets the
apostrophe as the end of the string. The correct form is \''string.
If the string is delimited by quotation marks, quotation marks in the string itself must be
represented by two consecutive quotation marks ("").
The sequences \ooo and \xhh allow any ASCII character to be given as a one- to three-digit octal
or a one- to two-digit hexadecimal character code. Each octal digit must be in the range 0 to 7, and
each hexadecimal digit must be in the range 0 to F. For example, the C strings '\010'C and '\x08'C
both represent a backspace character followed by a null character.
The C string '\\abcd'C is equivalent to the string '\abcd' with a null character appended. The
string ''C represents the ASCII null character.

Character Substrings
A character substring is a contiguous segment of a character string. It takes one of the following
forms:
v ([e1]:[e2])
a (s [,s] . . . ) ([e1]:[e2])

3-17
3 Intel Fortran Language Reference

v
Is a character scalar constant, or the name of a character scalar variable or character structure
component.
e1
Is a scalar integer (or other numeric) expression specifying the leftmost character position of the
substring; the starting point.
e2
Is a scalar integer (or other numeric) expression specifying the rightmost character position of the
substring; the ending point.
a
Is the name of a character array.
s
Is a subscript expression.
Both e1 and e2 must be within the range 1,2, ..., len, where len is the length of the parent character
string. If e1 exceeds e2, the substring has length zero.

Rules and Behavior

Character positions within the parent character string are numbered from left to right, beginning at
1.
If the value of the numeric expression e1 or e2 is not of type integer, it is converted to integer
before use (any fractional parts are truncated).
If e1 is omitted, the default is 1. If e2 is omitted, the default is len. For example, NAMES(1,3)(:7)
specifies the substring starting with the first character position and ending with the seventh
character position of the character array element NAMES(1,3).

Examples
Consider the following example:
CHARACTER*8 C, LABEL
LABEL = ‘XVERSUSY'
C = LABEL(2:7)
LABEL(2:7) specifies the substring starting with the second character position and ending with
the seventh character position of the character variable assigned to LABEL, so C has the value
'VERSUS'.
Consider the following example:

3-18
 Data Types, Constants, and Variables 3
TYPE ORGANIZATION
INTEGER ID
CHARACTER*35 NAME
END TYPE ORGANIZATION

TYPE(ORGANIZATION) DIRECTOR
CHARACTER*25 BRANCH, STATE(50)
The following are valid substrings based on the above example:
BRANCH(3:15) ! parent string is a scalar variable
STATE(20) (1:3) ! parent string is an array element
DIRECTOR%NAME ! parent string is a structure component
Consider the following example:
CHARACTER(*), PARAMETER :: MY_BRANCH = "CHAPTER 204"
CHARACTER(3) BRANCH_CHAP
BRANCH_CHAP = MY_BRANCH(9:11) ! parent string is a character constant
BRANCH_CHAP is a character string of length 3 that has the value '204'.

See Also
• “Arrays”
• “Array Elements”
• “Structure Components”

Derived Data Types

You can create derived data types from intrinsic data types or previously defined derived types.
A derived type is resolved into "ultimate" components that are either of intrinsic type or are
pointers.
The set of values for a specific derived type consists of all possible sequences of component
values permitted by the definition of that derived type. Structure constructors are used to specify
values of derived types.
Nonintrinsic assignment for derived-type entities must be defined by a subroutine with an
ASSIGNMENT interface. Any operation on derived-type entities must be defined by a function
with an OPERATOR interface. Arguments and function values can be of any intrinsic or derived
type.

See Also
• “Structure Components”

3-19
3 Intel Fortran Language Reference

• “Structure Constructors”
• “Derived-Type Assignment Statements”
• “Record Structures”
• “Defining Generic Operators” for details on OPERATOR interfaces
• “Defining Generic Assignment” for details on ASSIGNMENT interfaces

Derived-Type Definition
A derived-type definition specifies the name of a user-defined type and the types of its
components. It takes the following form:
TYPE [ [, access] :: ] name
component-definition
[component-definition] . . .
END TYPE [name]
access
Is the PRIVATE or PUBLIC keyword. The keyword can only be specified if the derived-type
definition is in the specification part of a module.
name
Is the name of the derived type. It must not be the same as the name of any intrinsic type, or the
same as the name of a derived type that can be accessed from a module.
component-definition
Is one or more type declaration statements defining the component of derived type.
The first component definition can be preceded by an optional PRIVATE or SEQUENCE
statement. (Only one PRIVATE or SEQUENCE statement can appear in a given derived-type
definition.)
PRIVATE specifies that the components are accessible only within the defining module, even if
the derived type itself is public.
SEQUENCE cause the components of the derived type to be stored in the same sequence they are
listed in the type definition. If SEQUENCE is specified, all derived types specified in component
definitions must be sequence types.
A component definition takes the following form:
type [ [, attr] ::] component [(a-spec)] [ *char-len] [init-ex]

3-20
 Data Types, Constants, and Variables 3
type
Is a type specifier. It can be an intrinsic type or a previously defined derived type. (If the
POINTER attribute follows this specifier, the type can also be any accessible derived type,
including the type being defined.)
attr
Is an optional POINTER attribute for a pointer component, or an optional DIMENSION or
ALLOCATABLE attribute for an array component. You cannot specify both the ALLOCATABLE
and POINTER attribute. If DIMENSION is specified, it can be followed by an array specification.
Each attribute can only appear once in a given component-definition.
component
Is the name of the component being defined.
a-spec
Is an optional array specification, enclosed in parentheses. If POINTER or ALLOCATABLE is
specified, the array is deferred shape; otherwise, it is explicit shape. In an explicit-shape
specification, each bound must be a constant scalar integer expression. For more information on
array specifications, see “Declaration Statements for Arrays”.
If the array bounds are not specified here, they must be specified following the DIMENSION
attribute.
char-len
Is an optional scalar integer literal constant; it must be preceded by an asterisk (*). This parameter
can only be specified if the component is of type CHARACTER.
init-ex
Is an initialization expression or, for pointer components, =>NULL( ). This is a Fortran 95
feature.
If init-ex is specified, a double colon must appear in the component definition. The equals
assignment symbol (=) can only be specified for nonpointer components.
The initialization expression is evaluated in the scoping unit of the type definition.

Rules and Behavior

If a name is specified following the END TYPE statement, it must be the same name that follows
TYPE in the derived type statement.
A derived type can be defined only once in a scoping unit. If the same derived-type name appears
in a derived-type definition in another scoping unit, it is treated independently.
A component name has the scope of the derived-type definition only. Therefore, the same name
can be used in another derived-type definition in the same scoping unit.

3-21
3 Intel Fortran Language Reference

Two data entities have the same type if they are both declared to be of the same derived type (the
derived-type definition can be accessed from a module or a host scoping unit).
If the entities are in different scoping units, they can also have the same derived type if they are
declared with reference to different derived-type definitions, and if both derived-type definitions
have all of the following:
• The same name
• A SEQUENCE statement (they both have sequence type)
• Components that agree in name, order, and attributes; components cannot be private
See Also
• “Intrinsic Data Types”
• “Arrays”
• “Structure Components”
• “Declaration Statements for Derived Types” for details on how to declare variables of derived
type
• “POINTER Attribute and Statement” for details on pointers
• “Default Initialization”for details on default initialization for derived-type components
• Your user’s guide for details on alignment of derived-type data components

Default Initialization
Default initialization occurs if initialization appears in a derived-type component definition. (This
is a Fortran 95 feature.)
The specified initialization of the component will apply even if the definition is PRIVATE.
Default initialization applies to dummy arguments with INTENT(OUT). It does not imply the
derived-type component has the SAVE attribute.
Explicit initialization in a type declaration statement overrides default initialization.
To specify default initialization of an array component, use a constant expression that includes one
of the following:
• An array constructor
• A single scalar that becomes the value of each array element
Pointers can have an association status of associated, disassociated, or undefined. If no default
initialization status is specified, the status of the pointer is undefined. To specify disassociated
status for a pointer component, use =>NULL( ).

3-22
 Data Types, Constants, and Variables 3
Examples
You do not have to specify initialization for each component of a derived type. For example:
TYPE REPORT
CHARACTER (LEN=20) REPORT_NAME
INTEGER DAY
CHARACTER (LEN=3) MONTH
INTEGER :: YEAR = 1995 ! Only component with default
END TYPE REPORT ! initialization
Consider the following:
TYPE (REPORT), PARAMETER :: NOV_REPORT = REPORT ("Sales", 15, "NOV",1996)
In this case, the explicit initialization in the type declaration statement overrides the YEAR
component of NOV_REPORT.
The default initial value of a component can also be overridden by default initialization specified
in the type definition. For example:
TYPE MGR_REPORT
TYPE (REPORT) :: STATUS = NOV_REPORT
INTEGER NUM
END TYPE MGR_REPORT

TYPE (MGR_REPORT) STARTUP

In this case, the STATUS component of STARTUP gets its initial value from NOV_REPORT,
overriding the initialization for the YEAR component.

Structure Components
A reference to a component of a derived-type structure takes the following form:
parent [%component [(s-list)]]... %component [(s-list)]
parent
Is the name of a scalar or array of derived type. The percent sign (%) is called a component
selector.
component
Is the name of a component of the immediately preceding parent or component.
s-list
Is a list of one or more subscripts. If the list contains subscript triplets or vector subscripts, the
reference is to an array section.

3-23
3 Intel Fortran Language Reference

Each subscript must be a scalar integer (or other numeric) expression with a value that is within
the bounds of its dimension.
The number of subscripts in any s-list must equal the rank of the immediately preceding parent or
component.

Rules and Behavior

Each parent or component (except the rightmost) must be of derived type.
The parent or one of the components can have nonzero rank (be an array). Any component to the
right of a parent or component of nonzero rank must not have the POINTER attribute.
The rank of the structure component is the rank of the part (parent or component) with nonzero
rank (if any); otherwise, the rank is zero. The type and type parameters (if any) of a structure
component are those of the rightmost part name.
The structure component must not be referenced or defined before the declaration of the parent
object.
If the parent object has the INTENT, TARGET, or PARAMETER attribute, the structure
component also has the attribute.

Examples
The following example shows a derived-type definition with two components:
TYPE EMPLOYEE
INTEGER ID
CHARACTER(LEN=40) NAME
END TYPE EMPLOYEE
The following shows how to declare CONTRACT to be of type EMPLOYEE:
TYPE(EMPLOYEE) :: CONTRACT
Note that both examples started with the keyword TYPE. The first (initial) statement of a
derived-type definition is called a derived-type statement, while the statement that declares a
derived- type object is called a TYPE statement.
The following example shows how to reference component ID of parent structure CONTRACT:
CONTRACT%ID
The following example shows a derived type with a component that is a previously defined type:
TYPE DOT
REAL X, Y
END TYPE DOT
....

3-24
 Data Types, Constants, and Variables 3
TYPE SCREEN
TYPE(DOT) C, D
END TYPE SCREEN
The following declares a variable of type SCREEN:
TYPE(SCREEN) M
Variable M has components M%C and M%D (both of type DOT); M%C has components
M%C%X and M%C%Y of type REAL.
The following example shows a derived type with a component that is an array:
TYPE CAR_INFO
INTEGER YEAR
CHARACTER(LEN=15), DIMENSION(10) :: MAKER
CHARACTER(LEN=10) MODEL, BODY_TYPE*8
REAL PRICE
END TYPE
...
TYPE(CAR_INFO) MY_CAR
Note that MODEL has a character length of 10, but BODY_TYPE has a character length of 8. You
can assign a value to a component of a structure; for example:
MY_CAR%YEAR = 1985
The following shows an array structure component:
MY_CAR%MAKER
In the preceding example, if a subscript list (or substring) was appended to MAKER, the reference
would not be to an array structure component, but to an array element or section.
Consider the following:
MY_CAR%MAKER(2) (4:10)
In this case, the component is substring 4 to 10 of the second element of array MAKER.
Consider the following:
TYPE CHARGE
INTEGER PARTS(40)
REAL LABOR
REAL MILEAGE
END TYPE CHARGE

TYPE(CHARGE) MONTH
TYPE(CHARGE) YEAR(12)
Some valid array references for this type follow:

3-25
3 Intel Fortran Language Reference

MONTH%PARTS(I) ! An array element

MONTH%PARTS(I:K) ! An array section
YEAR(I)%PARTS ! An array structure component (a whole array)
YEAR(J)%PARTS(I) ! An array element
YEAR(J)%PARTS(I:K) ! An array section
YEAR(J:K)%PARTS(I) ! An array section
YEAR%PARTS(I) ! An array section
The following example shows a derived type with a pointer component that is of the type being
defined:
TYPE NUMBER
INTEGER NUM
TYPE(NUMBER), POINTER :: START_NUM => NULL()
TYPE(NUMBER), POINTER :: NEXT_NUM => NULL()
END TYPE
A type such as this can be used to construct linked lists of objects of type NUMBER. Note that the
pointers are given the default initialization status of disassociated.
The following example shows a private type:
TYPE, PRIVATE :: SYMBOL
LOGICAL TEST
CHARACTER(LEN=50) EXPLANATION
END TYPE SYMBOL
This type is private to the module. The module can be used by another scoping unit, but type
SYMBOL is not available.

See Also
• “Array Elements” for details on references to array elements
• “Array Sections” for details on references to array sections
• “Modules and Module Procedures” for examples of derived types in modules

Structure Constructors
A structure constructor lets you specify scalar values of a derived type. It takes the following
form:
d-name (expr-list)
d-name
Is the name of the derived type.

3-26
 Data Types, Constants, and Variables 3
expr-list
Is a list of expressions specifying component values. The values must agree in number and order
with the components of the derived type. If necessary, values are converted (according to the rules
of assignment), to agree with their corresponding components in type and kind parameters.

Rules and Behavior

A structure constructor must not appear before its derived type is defined.
If a component of the derived type is an array, the shape in the expression list must conform to the
shape of the component array.
If a component of the derived type is a pointer, the value in the expression list must evaluate to an
object that would be a valid target in a pointer assignment statement. (A constant is not a valid
target in a pointer assignment statement.)
If all the values in a structure constructor are constant expressions, the constructor is a
derived-type constant expression.

Examples
Consider the following derived-type definition:
TYPE EMPLOYEE
INTEGER ID
CHARACTER(LEN=40) NAME
END TYPE EMPLOYEE
This can be used to produce the following structure constructor:
EMPLOYEE(3472, "John Doe")
The following example shows a type with a component of derived type:
TYPE ITEM
REAL COST
CHARACTER(LEN=30) SUPPLIER
CHARACTER(LEN=20) ITEM_NAME
END TYPE ITEM

TYPE PRODUCE
REAL MARKUP
TYPE(ITEM) FRUIT
END TYPE PRODUCE
In this case, you must use an embedded structure constructor to specify the values of that
component; for example:

3-27
3 Intel Fortran Language Reference

PRODUCE(.70, ITEM (.25, "Daniels", "apple"))

See Also
“Pointer Assignments”

Binary, Octal, Hexadecimal, and Hollerith Constants

Binary, octal, hexadecimal, and Hollerith constants are nondecimal constants. They have no
intrinsic data type, but assume a numeric data type depending on their use.
Fortran 95/90 allows unsigned binary, octal, and hexadecimal constants to be used in DATA
statements; the constant must correspond to an integer scalar variable.
In Intel Fortran, binary, octal, hexadecimal, and Hollerith constants can appear wherever numeric
constants are allowed.

Binary Constants
A binary constant is an alternative way to represent a numeric constant. A binary constant takes
one of the following forms:
B'd[d...]'
B"d[d...]"
d
Is a binary (base 2) digit (0 or 1).
You can specify up to 256 binary digits in a binary constant. Leading zeros are ignored.

Examples
The following examples show valid and invalid binary constants:

Valid
B'0101110'
B"1"

Invalid Explanation
B'0112' The character 2 is invalid.
B10011' No apostrophe after the B.
"1000001" No B before the first quotation mark.

3-28
 Data Types, Constants, and Variables 3
Octal Constants
An octal constant is an alternative way to represent numeric constants. An octal constant takes one
of the following forms:
O'd[d...]'
O"d[d...]"
d
Is an octal (base 8) digit (0 through 7).
You can specify up to 256 bits (86 octal digits) in octal constants. Leading zeros are ignored.

Examples
The following examples show valid and invalid octal constants:

Valid
O'07737'
O"1"

Invalid Explanation
O'7782' The character 8 is invalid.
O7772' No apostrophe after the O.
"0737" No O before the first quotation mark.

See Also
“Alternative Syntax for Octal and Hexadecimal Constants”

Hexadecimal Constants
A hexadecimal constant is an alternative way to represent numeric constants. A hexadecimal
constant takes one of the following forms:
Z'd[d...]'
Z"d[d...]"
d
Is a hexadecimal (base 16) digit (0 through 9, or an uppercase or lowercase letter in the range of A
to F).
You can specify up to 256 bits (64 hexadecimal digits) in hexadecimal constants. Leading zeros
are ignored.

3-29
3 Intel Fortran Language Reference

Examples
The following examples show valid and invalid hexadecimal constants:

Valid
Z'AF9730'
Z"FFABC"
Z'84'

Invalid Explanation
Z'999.' Decimal not allowed.
"ZF9" No quotation mark after the Z.

See Also
“Alternative Syntax for Octal and Hexadecimal Constants”

Hollerith Constants
A Hollerith constant is a string of printable ASCII characters preceded by the letter H. Before the
H, there must be an unsigned, nonzero default integer constant stating the number of characters in
the string (including blanks and tabs).
Hollerith constants are strings of 1 to 2000 characters. They are stored as byte strings, one
character per byte.

Examples
The following examples show valid and invalid Hollerith constants:
Valid
16HTODAY'S DATE IS:
1HB
4H ABC

Invalid Explanation
3HABCD Wrong number of characters.
0H Hollerith constants must contain at least one character.

3-30
 Data Types, Constants, and Variables 3
Determining the Data Type of Nondecimal Constants
Binary, octal, hexadecimal, and Hollerith constants have no intrinsic data type. These constants
assume a numeric data type depending on their use.
When the constant is used with a binary operator (including the assignment operator), the data
type of the constant is the data type of the other operand. For example:

Statement Data Type of Constant Length of Constant1

INTEGER(2) ICOUNT
INTEGER(4) jCOUNT
INTEGER(4) N
REAL(8) DOUBLE
REAL(4) RAFFIA, RALPHA
RAFFIA = B'1001100111111010011' REAL(4) 4
RAFFIA = Z'99AF2' REAL(4) 4
RALPHA = 4HABCH REAL(4) 4
DOUBLE = B'1111111111100110011010' REAL(8) 8
DOUBLE = Z'FFF99A' REAL(8) 8
DOUBLE = 8HABCDEFGH REAL(8) 8
JCOUNT = ICOUNT + B'011101110111' INTEGER(2) 2
JCOUNT = ICOUNT + O'777' INTEGER(2) 2
JCOUNT = ICOUNT + 2HXY INTEGER(2) 2
IF (N .EQ. B'1010100') GO TO 10 INTEGER(4) 4
IF (N .EQ. O'123') GO TO 10 INTEGER(4) 4
IF (N .EQ. 1HZ) GO TO 10 INTEGER(4) 4
1. In bytes.

When a specific data type (generally integer) is required, that type is assumed for the constant. For
example:

Statement Data Type of Constant Length of Constant1

Y(1X) = Y (O'15') + 3 INTEGER(4) 4
Y(1X) = Y (1HA) + 3 INTEGER(4) 4
1. In bytes.

When a nondecimal constant is used as an actual argument, the following occurs:

3-31
3 Intel Fortran Language Reference

• For binary, octal, and hexadecimal constants, INTEGER(8) is assumed on Intel® Itanium®
processors. On IA-32 processors, INTEGER(4) is used.
• For Hollerith constants, no data type is assumed.
For example:

Statement Data Type of Constant Length of Constant1

CALL APAC (Z'34BC2') INTEGER(4) 4
CALL APAC (9HABCDEFGHI) None 9
1. In bytes.

When a binary, octal, or hexadecimal constant is used in any other context, the default integer data
type is assumed (default integer can be affected by compiler options). In the following examples,
default integer is INTEGER(4):

Statement Data Type of Constant Length of Constant1

IF (Z'AF77') 1,2,3 INTEGER(4) 4
IF (2HAB) 1,2,3 INTEGER(4) 4
I = O'7777' – Z'A39' 2 INTEGER(4) 4
I = 1HC – 1HA INTEGER(4) 4
J = .NOT. O'73777' INTEGER(4) 4
J = .NOT. 1HB INTEGER(4) 4
1. In bytes.
2. When two typeless constants are used in an operation, they both take default integer type.

When nondecimal constants are not the same length as the length implied by a data type, the
following occurs:
• Binary, octal, and hexadecimal constants
These constants can specify up to 16 bytes of data. When the length of the constant is less
than the length implied by the data type, the leftmost digits have a value of zero.
When the length of the constant is greater than the length implied by the data type, the
constant is truncated on the left. An error results if any nonzero digits are truncated.
Table 15-2 lists the number of bytes that each data type requires.
• Hollerith constants
When the length of the constant is less than the length implied by the data type, blanks are
appended to the constant on the right.

3-32
 Data Types, Constants, and Variables 3
When the length of the constant is greater than the length implied by the data type, the
constant is truncated on the right. If any characters other than blank characters are truncated,
an error occurs.
Each Hollerith character occupies one byte of memory.

See Also
Your user’s guide for details on compiler options

Variables
A variable is a data object whose value can be changed at any point in a program. A variable can
be any of the following:
• A scalar
A scalar is a single object that has a single value; it can be of any intrinsic or derived
(user-defined) type.
• An array
An array is a collection of scalar elements of any intrinsic or derived type. All elements must
have the same type and kind parameters.
• A subobject designator
A subobject is part of an object. The following are subobjects:
An array element A structure component
An array section A character substring
For example, B(3) is a subobject (array element) designator for array B. A subobject cannot
be a variable if its parent object is a constant.
The name of a variable is associated with a single storage location.
Variables are classified by data type, as constants are. The data type of a variable indicates the type
of data it contains, including its precision, and implies its storage requirements. When data of any
type is assigned to a variable, it is converted to the data type of the variable (if necessary).
A variable is defined when you give it a value. A variable can be defined before program
execution by a DATA statement or a type declaration statement. During program execution,
variables can be defined or redefined in assignment statements and input statements, or undefined
(for example, if an I/O error occurs). When a variable is undefined, its value is unpredictable.
When a variable becomes undefined, all variables associated by storage association also become
undefined.

3-33
3 Intel Fortran Language Reference

See Also
• “Arrays”
• “Type Declaration Statements”
• “DATA Statement”
• “Data Type of Numeric Expressions”
• “Storage Association” for details on storage association of variables

Data Types of Scalar Variables

The data type of a scalar variable can be explicitly declared in a type declaration statement. If no
type is declared, the variable has an implicit data type based on predefined typing rules or
definitions in an IMPLICIT statement.
An explicit declaration of data type takes precedence over any implicit type. Implicit type
specified in an IMPLICIT statement takes precedence over predefined typing rules.

Specification of Data Type

Type declaration statements explicitly specify the data type of scalar variables. For example, the
following statements associate VAR1 with an 8-byte complex storage location, and VAR2 with an
8-byte double-precision storage location:
COMPLEX VAR1
DOUBLE PRECISION VAR2
You can explicitly specify the data type of a scalar variable only once.
If no explicit data type specification appears, any variable with a name that begins with the letter
in the range specified in the IMPLICIT statement becomes the data type of the variable.
Character type declaration statements specify that given variables represent character values with
the length specified. For example, the following statements associate the variable names INLINE,
NAME, and NUMBER with storage locations containing character data of lengths 72, 12, and 9,
respectively:
CHARACTER*72 INLINE
CHARACTER NAME*12, NUMBER*9
In single subprograms, assumed-length character arguments can be used to process character
strings with different lengths. The assumed-length character argument has its length specified with
an asterisk, for example:
CHARACTER*(*) CHARDUMMY
The argument CHARDUMMY assumes the length of the actual argument.

3-34
 Data Types, Constants, and Variables 3
See Also
• “Type Declaration Statements”
• “Declaration Statements for Character Types”
• “Assumed-Length Character Arguments”
• “IMPLICIT Statement”
Implicit Typing Rules
By default, all scalar variables with names beginning with I, J, K, L, M, or N are assumed to be
default integer variables. Scalar variables with names beginning with any other letter are assumed
to be default real variables. For example:

Real Variables Integer Variables

ALPHA JCOUNT
BETA ITEM_1
TOTAL_NUM NTOTAL

Names beginning with a dollar sign ($) are implicitly INTEGER.

You can override the default data type implied in a name by specifying data type in either an
IMPLICIT statement or a type declaration statement.

See Also
• “Type Declaration Statements”
• “IMPLICIT Statement”

Arrays
An array is a set of scalar elements that have the same type and kind parameters. Any object that is
declared with an array specification is an array. Arrays can be declared by using a type declaration
statement, or by using a DIMENSION, COMMON, ALLOCATABLE, POINTER, or TARGET
statement.
An array can be referenced by element (using subscripts), by section (using a section subscript
list), or as a whole. A subscript list (appended to the array name) indicates which array element or
array section is being referenced.
A section subscript list consists of subscripts, subscript triplets, or vector subscripts. At least one
subscript in the list must be a subscript triplet or vector subscript.
When an array name without any subscripts appears in an intrinsic operation (for example,
addition), the operation applies to the whole array (all elements in the array).

3-35
3 Intel Fortran Language Reference

An array has the following properties:

• Data type
An array can have any intrinsic or derived type. The data type of an array (like any other
variable) is specified in a type declaration statement or implied by the first letter of its name.
All elements of the array have the same type and kind parameters. If a value assigned to an
individual array element is not the same as the type of the array, it is converted to the array's
type.
• Rank
The rank of an array is the number of dimensions in the array. An array can have up to seven
dimensions. A rank-one array represents a column of data (a vector), a rank-two array
represents a table of data arranged in columns and rows (a matrix), a rank-three array
represents a table of data on multiple pages (or planes), and so forth.
• Bounds
Arrays have a lower and upper bound in each dimension. These bounds determine the range
of values that can be used as subscripts for the dimension. The value of either bound can be
positive, negative, or zero.
The bounds of a dimension are defined in an array specification.
• Size
The size of an array is the total number of elements in the array (the product of the array's
extents).
The extent is the total number of elements in a particular dimension. It is determined as
follows: upper bound – lower bound + 1. If the value of any of an array's extents is zero, the
array has a size of zero.
• Shape
The shape of an array is determined by its rank and extents, and can be represented as a
rank-one array (vector) where each element is the extent of the corresponding dimension.
Two arrays with the same shape are said to be conformable. A scalar is conformable to an
array of any shape.
The name and rank of an array must be specified when the array is declared. The extent of each
dimension can be constant, but does not need to be. The extents can vary during program
execution if the array is a dummy argument array, an automatic array, an array pointer, or an
allocatable array.
A whole array is referenced by the array name. Individual elements in a named array are
referenced by a scalar subscript or list of scalar subscripts (if there is more than one dimension). A
section of a named array is referenced by a section subscript.

3-36
 Data Types, Constants, and Variables 3
Examples
The following are examples of valid array declarations:
DIMENSION A(10, 2, 3) ! DIMENSION statement
ALLOCATABLE B(:, :) ! ALLOCATABLE statement
POINTER C(:, :, :) ! POINTER statement
REAL, DIMENSION (2, 5) :: D ! Type declaration with DIMENSION attribute
Consider the following array declaration:
INTEGER L(2:11,3)
The properties of array L are as follows:

Data type: INTEGER

Rank: 2 (two dimensions)
Bounds: First dimension: 2 to 11
Second dimension: 1 to 3
Size: 30; the product of the extents: 10 x 3
Shape: (/10,3/) (or 10 by 3); a vector of the extents 10 and 3

The following example shows other valid ways to declare this array:
DIMENSION L(2:11,3)
INTEGER, DIMENSION(2:11,3) :: L
COMMON L(2:11,3)
The following example shows references to array elements, array sections, and a whole array:
REAL B(10) ! Declares a rank-one array with 10 elements
INTEGER C(5,8) ! Declares a rank-two array with 5 elements in
! dimension one and 8 elements in dimension two
...
B(3) = 5.0 ! Reference to an array element
B(2:5) = 1.0 ! Reference to an array section consisting of
! elements: B(2), B(3), B(4), B(5)
...
C(4,8) = I ! Reference to an array element
C(1:3,3:4) = J ! Reference to an array section consisting of
! elements: C(1,3) C(1,4)
! C(2,3) C(2,4)
! C(3,3) C(3,4)

3-37
3 Intel Fortran Language Reference

B = 99 ! Reference to a whole array consisting of

! elements: B(1), B(2), B(3), B(4), B(5),
! B(6), B(7), B(8), B(9), and B(10)

See Also
• “DIMENSION Attribute and Statement”
• “Intrinsic Data Types”
• “Derived Data Types”
• “Whole Arrays”
• “Array Elements”
• “Array Sections”
• “Declaration Statements for Arrays” for details on array specifications
• Table 9-2 for details on intrinsic functions that perform array operations
Whole Arrays
A whole array is a named array; it is either a named constant or a variable. It is referenced by
using the array name (without any subscripts).
If a whole array appears in a nonexecutable statement, the statement applies to the entire array. For
example:
INTEGER, DIMENSION(2:11,3) :: L ! Specifies the type and
! dimensions of array L
If a whole array appears in an executable statement, the statement applies to all of the elements in
the array. For example:
L = 10 ! The value 10 is assigned to all the
! elements in array L
WRITE *, L ! Prints all the elements in array L

Array Elements
An array element is one of the scalar data items that make up an array. A subscript list (appended
to the array or array component) determines which element is being referred to. A reference to an
array element takes the following form:
array(subscript-list)
array
Is the name of the array.

3-38
 Data Types, Constants, and Variables 3
subscript-list
Is a list of one or more subscripts separated by commas. The number of subscripts must equal the
rank of the array.
Each subscript must be a scalar integer (or other numeric) expression with a value that is within
the bounds of its dimension.

Rules and Behavior

Each array element inherits the type, kind type parameter, and certain attributes (INTENT,
PARAMETER, and TARGET) of the parent array. An array element cannot inherit the POINTER
attribute.
If an array element is of type character, it can be followed by a substring range in parentheses; for
example:
ARRAY_D(1,2) (1:3) ! Elements are substrings of length 3
However, by convention, such an object is considered to be a substring rather than an array
element.
The following are some valid array element references for an array declared as REAL B(10,20):
B(1,3), B(10,10), and B(5,8).
For information on forms for array specifications, see “Declaration Statements for Arrays”.

Array Element Order

The elements of an array form a sequence known as array element order. The position of an
element in this sequence is its subscript order value.
The elements of an array are stored as a linear sequence of values. A one-dimensional array is
stored with its first element in the first storage location and its last element in the last storage
location of the sequence. A multidimensional array is stored so that the leftmost subscripts vary
most rapidly. This is called the order of subscript progression.
Figure 3-1 shows array storage in one, two, and three dimensions

3-39
3 Intel Fortran Language Reference

Figure 3-1 Array Storage

One−Dimensional Array BRC (6)

1 BRC(1) 2 BRC(2) 3 BRC(3) 4 BRC(4) 5 BRC(5) 6 BRC(6)

Memory Positions

Two−Dimensional Array BAN (3,4)

1 BAN(1,1) 4 BAN(1,2) 7 BAN(1,3) 10 BAN(1,4)

2 BAN(2,1) 5 BAN(2,2) 8 BAN(2,3) 11 BAN(2,4)
3 BAN(3,1) 6 BAN(3,2) 9 BAN(3,3) 12 BAN(3,4)

Memory Positions

Three−Dimensional Array BOS (3,3,3)

19 BOS(1,1,3) 22 BOS(1,2,3) 25 BOS(1,3,3)

20 BOS(2,1,3) 23 BOS(2,2,3) 26 BOS(2,3,3)

10 BOS(1,1,2) 13 BOS(3,1,3) 16
21 BOS(1,2,2) BOS(3,2,3)
24 BOS(1,3,2) 27 BOS(3,3,3)

11 BOS(2,1,2) 14 BOS(2,2,2) 17 BOS(2,3,2)

1 BOS(1,1,1) 412 BOS(1,2,1)

BOS(3,1,2) 715 BOS(1,3,1)
BOS(3,2,2) 18 BOS(3,3,2)

2 BOS(2,1,1) 5 BOS(2,2,1) 8 BOS(2,3,1)

3 BOS(3,1,1) 6 BOS(3,2,1) 9 BOS(3,3,1)

Memory Positions
ZK−0616−GE

For example, in two-dimensional array BAN, element BAN(1,2) has a subscript order value of 4;
in three-dimensional array BOS, element BOS(1,1,1) has a subscript order value of 1.

3-40
 Data Types, Constants, and Variables 3
In an array section, the subscript order of the elements is their order within the section itself. For
example, if an array is declared as B(20), the section B(4:19:4) consists of elements B(4), B(8),
B(12), and B(16). The subscript order value of B(4) in the array section is 1; the subscript order
value of B(12) in the section is 3.

See Also
• “Character Substrings”
• “Array Association”
• “Structure Components” for details on arrays as structure components
• “Storage Association” for details on storage sequence association
Array Sections
An array section is a portion of an array that is an array itself. It is an array subobject. A section
subscript list (appended to the array or array component) determines which portion is being
referred to. A reference to an array section takes the following form:
array(sect-subscript-list)
array
Is the name of the array.
sect-subscript-list
Is a list of one or more section subscripts (subscripts, subscript triplets, or vector subscripts)
indicating a set of elements along a particular dimension.
At least one of the items in the section subscript list must be a subscript triplet or vector subscript.
A subscript triplet specifies array elements in increasing or decreasing order at a given stride. A
vector subscript specifies elements in any order.
Each subscript and subscript triplet must be a scalar integer (or other numeric) expression. Each
vector subscript must be a rank-one integer expression.

Rules and Behavior

If no section subscript list is specified, the rank and shape of the array section is the same as the
parent array.
Otherwise, the rank of the array section is the number of vector subscripts and subscript triplets
that appear in the list. Its shape is a rank-one array where each element is the number of integer
values in the sequence indicated by the corresponding subscript triplet or vector subscript.
If any of these sequences is empty, the array section has a size of zero. The subscript order of the
elements of an array section is that of the array object that the array section represents.

3-41
3 Intel Fortran Language Reference

Each array section inherits the type, kind type parameter, and certain attributes (INTENT,
PARAMETER, and TARGET) of the parent array. An array section cannot inherit the POINTER
attribute.
If an array (or array component) is of type character, it can be followed by a substring range in
parentheses. Consider the following declaration:
CHARACTER(LEN=15) C(10,10)
In this case, an array section referenced as C(:,:) (1:3) is an array of shape (10,10), whose elements
are substrings of length 3 of the corresponding elements of C.
The following shows valid references to array sections. Note that the syntax (/.../) denotes an
array constructor (see “Array Constructors”):
REAL, DIMENSION(20) :: B
...
PRINT *, B(2:20:5) ! The section consists of elements
! B(2), B(7), B(12), and B(17)
K = (/3, 1, 4/)
B(K) = 0.0 ! Section B(K) is a rank-one array with shape (3) and
! size 3. (0.0 is assigned to B(1), B(3), and B(4).)

Subscript Triplets
A subscript triplet is a set of three values representing the lower bound of the array section, the
upper bound of the array section, and the increment (stride) between them. It takes the following
form:
[first-bound] : [last-bound] [:stride]
first-bound
Is a scalar integer (or other numeric) expression representing the first value in the subscript
sequence. If omitted, the declared lower bound of the dimension is used.
last-bound
Is a scalar integer (or other numeric) expression representing the last value in the subscript
sequence. If omitted, the declared upper bound of the dimension is used.
When indicating sections of an assumed-size array, this subscript must be specified.
stride
Is a scalar integer (or other numeric) expression representing the increment between successive
subscripts in the sequence. It must have a nonzero value. If it is omitted, it is assumed to be 1.
The stride has the following effects:

3-42
 Data Types, Constants, and Variables 3
• If the stride is positive, the subscript range starts with the first subscript and is incremented by
the value of the stride, until the largest value less than or equal to the second subscript is
attained.
For example, if an array has been declared as B(6,3,2), the array section specified as
B(2:4,1:2,2) is a rank-two array with shape (3,2) and size 6. It consists of the following six
elements:
B(2,1,2) B(2,2,2)
B(3,1,2) B(3,2,2)
B(4,1,2) B(4,2,2)
If the first subscript is greater than the second subscript, the range is empty.
• If the stride is negative, the subscript range starts with the value of the first subscript and is
decremented by the absolute value of the stride, until the smallest value greater than or equal
to the second subscript is attained.
For example, if an array has been declared as A(15), the array section specified as A(10:3:-2)
is a rank-one array with shape (4) and size 4. It consists of the following four elements:
A(10)
A(8)
A(6)
A(4)
If the second subscript is greater than the first subscript, the range is empty.
If a range specified by the stride is empty, the array section has a size of zero.
A subscript in a subscript triplet need not be within the declared bounds for that dimension if all
values used to select the array elements are within the declared bounds. For example, if an array
has been declared as A(15), the array section specified as A(4:16:10) is valid. The section is a
rank-one array with shape (2) and size 2. It consists of elements A(4) and A(14).
If the subscript triplet does not specify bounds or stride, but only a colon (:), the entire declared
range for the dimension is used.

Vector Subscripts
A vector subscript is a one-dimensional (rank one) array of integer values (within the declared
bounds for the dimension) that selects a section of a whole (parent) array. The elements in the
section do not have to be in order and the section can contain duplicate values.
For example, A is a rank-two array of shape (4,6). B and C are rank- one arrays of shape (2) and
(3), respectively, with the following values:
B = (/1,4/) ! Syntax (/.../) denotes an array constructor
C = (/2,1,1/) ! Will result in a many-one array section

3-43
3 Intel Fortran Language Reference

Array section A(3,B) consists of elements A(3,1) and A(3,4). Array section A(C,1) consists of
elements A(2,1), A(1,1), and A(1,1). Array section A(B,C) consists of the following elements:
A(1,2) A(1,1) A(1,1)
A(4,2) A(4,1) A(4,1)
An array section with a vector subscript that has two or more elements with the same value is
called a many-one array section. A many-one section must not appear on the left of the equal sign
in an assignment statement, or as an input item in a READ statement.
The following assignments to C also show examples of vector subscripts:
INTEGER A(2), B(2), C(2)
...
B = (/1,2/)
C(B) = A(B)
C = A((/1,2/))
An array section with a vector subscript must not be any of the following:
• An internal file
• An actual argument associated with a dummy array that is defined or redefined (if the
INTENT attribute is specified, it must be INTENT(IN))
• The target in a pointer assignment statement
If the sequence specified by the vector subscript is empty, the array section has a size of zero.

See Also
• “INTENT Attribute and Statement”
• “PARAMETER Attribute and Statement”
• “TARGET Attribute and Statement”
• “Character Substrings”
• “Array Constructors”
• “Structure Components” for details on array sections as structure components
Array Constructors
An array constructor can be used to create and assign values to rank-one arrays (and array
constants). An array constructor takes the following form:
(/ac-value-list/)
ac-value-list
Is a list of one or more expressions or implied-DO loops. Each ac-value must have the same type
and kind parameters, and be separated by commas.

3-44
 Data Types, Constants, and Variables 3
An implied-DO loop in an array constructor takes the following form:
(ac-value-list, do-variable = expr1, expr2 [, expr3])
do-variable
Is the name of a scalar integer variable. Its scope is that of the implied-DO loop.
expr
Is a scalar integer expression. The expr1 and expr2 specify a range of values for the loop; expr3
specifies the stride. The expr3 must be a nonzero value; if it is omitted, it is assumed to be 1.

Rules and Behavior

The array constructed has the same type as the ac-value-list expressions.
If the sequence of values specified by the array constructor is empty (there are no expressions or
the implied-DO loop produces no values), the rank-one array has a size of zero.
An ac-value is interpreted as follows:

Form of ac-value Result

A scalar expression Its value is an element of the new array.
An array expression The values of the elements in the expression (in array element
order) are the corresponding sequence of elements in the new
array.
An implied-DO loop It is expanded to form a list of array elements under control of the
DO variable (like a DO construct).

The following shows the three forms of an ac-value:

C1 = (/4,8,7,6/) ! A scalar expression
C2 = (/B(I, 1:5), B(I:J, 7:9)/) ! An array expression
C3 = (/(I, I=1, 4)/) ! An implied-DO loop
You can also mix these forms, for example:
C4 = (/4, A(1:5), (I, I=1, 4), 7/)
If every expression in an array constructor is a constant expression, the array constructor is a
constant expression.
If the expressions are of type character, Fortran 95/90 requires each expression to have the same
character length.
However, Intel Fortran allows the character expressions to be of different character lengths. The
length of the resultant character array is the maximum of the lengths of the individual character
expressions. For example:
print *,len ( (/'a','ab','abc','d'/) )

3-45
3 Intel Fortran Language Reference

print *,'++'//(/'a','ab','abc','d'/)//'--'
This causes the following to be displayed:
3
++a --++ab --++abc--++d --
If an implied-DO loop is contained within another implied-DO loop (nested), they cannot have the
same DO variable (do-variable).
To define arrays of more than one dimension, use the RESHAPE intrinsic function.
The following are alternative forms for array constructors:
• Square brackets (instead of parentheses and slashes) to enclose array constructors; for
example, the following two array constructors are equivalent:
INTEGER C(4)
C = (/4,8,7,6/)
C = [4,8,7,6]
• A colon-separated triplet (instead of an implied-DO loop) to specify a range of values and a
stride; for example, the following two array constructors are equivalent:
INTEGER D(3)
D = (/1:5:2/) ! Triplet form
D = (/(I, I=1, 5, 2)/) ! implied-DO loop form

Examples
The following example shows an array constructor using an implied-DO loop:
INTEGER ARRAY_C(10)
ARRAY_C = (/(I, I=30, 48, 2)/)
The values of ARRAY_C are the even numbers 30 through 48.
The following example shows an array constructor of derived type that uses a structure
constructor:
TYPE EMPLOYEE
INTEGER ID
CHARACTER(LEN=30) NAME
END TYPE EMPLOYEE
TYPE(EMPLOYEE) CC_4T(4)
CC_4T = (/EMPLOYEE(2732,"JONES"), EMPLOYEE(0217,"LEE"), &
EMPLOYEE(1889,"RYAN"), EMPLOYEE(4339,"EMERSON")/)
The following example shows how the RESHAPE intrinsic function can be used to create a
multidimensional array:

3-46
 Data Types, Constants, and Variables 3
E = (/2.3, 4.7, 6.6/)
D = RESHAPE(SOURCE = (/3.5, (/2.0, 1.0/), E/), SHAPE = (/2,3/))
D is a rank-two array with shape (2,3) containing the following elements:
3.5 1.0 4.7
2.0 2.3 6.6

See Also
• “DO Constructs”
• “RESHAPE”
• “Subscript Triplets”
• “Derived Data Types”
• “Structure Constructors”
• “Array Elements” for details on array element order
• “Array Assignment Statements” for details on another way to assign values to arrays
• “Declaration Statements for Arrays” for details on array specifications

3-47
3 Intel Fortran Language Reference

3-48
Expressions and
Assignment Statements 4
This chapter contains information on the following topics:
• “Expressions”
• “Assignment Statements”

Expressions
An expression represents either a data reference or a computation, and is formed from operators,
operands, and parentheses. The result of an expression is either a scalar value or an array of scalar
values.
If the value of an expression is of intrinsic type, it has a kind type parameter. (If the value is of
intrinsic type CHARACTER, it also has a length parameter.) If the value of an expression is of
derived type, it has no kind type parameter.
An operand is a scalar or array. An operator can be either intrinsic or defined. An intrinsic operator
is known to the compiler and is always available to any program unit. A defined operator is
described explicitly by a user in a function subprogram and is available to each program unit that
uses the subprogram.
The simplest form of an expression (a primary) can be any of the following:
• A constant; for example, 4.2
• A subobject of a constant; for example, 'LMNOP' (2:4)
• A variable; for example, VAR_1
• A structure constructor; for example, EMPLOYEE(3472, "JOHN DOE")
• An array constructor; for example, (/12.0,16.0/)
• A function reference; for example, COS(X)
• Another expression in parentheses; for example, (I+5)

4-1
4 Intel Fortran Language Reference

Any variable or function reference used as an operand in an expression must be defined at the time
the reference is executed. If the operand is a pointer, it must be associated with a target object that
is defined. An integer operand must be defined with an integer value rather than a statement label
value. All of the characters in a character data object reference must be defined.
When a reference to an array or an array section is made, all of the selected elements must be
defined. When a structure is referenced, all of the components must be defined.
In an expression that has intrinsic operators with an array as an operand, the operation is
performed on each element of the array. In expressions with more than one array operand, the
arrays must be conformable (they must have the same shape). The operation is applied to
corresponding elements of the arrays, and the result is an array of the same shape (the same rank
and extents) as the operands.
In an expression that has intrinsic operators with a pointer as an operand, the operation is
performed on the value of the target associated with the pointer.
For defined operators, operations on arrays and pointers are determined by the procedure defining
the operation.
A scalar is conformable with any array. If one operand of an expression is an array and another
operand is a scalar, it is as if the value of the scalar were replicated to form an array of the same
shape as the array operand. The result is an array of the same shape as the array operand.
The following sections describe numeric, character, relational, and logical expressions; defined
operations; a summary of operator precedence; and initialization and specification expressions.

See Also
• “Arrays”
• “Derived Data Types”
• “Defining Generic Operators” for details on function subprograms that define operators
• “POINTER Attribute and Statement” for details on pointers

Numeric Expressions
Numeric expressions express numeric computations, and are formed with numeric operands and
numeric operators. The evaluation of a numeric operation yields a single numeric value.
The term numeric includes logical data, because logical data is treated as integer data when used in
a numeric context. The default for .TRUE. is –1; .FALSE. is 0. The default can change if a
specific compiler option is used.
Numeric operators specify computations to be performed on the values of numeric operands. The
result is a scalar numeric value or an array whose elements are scalar numeric values. The
following are numeric operators:

4-2
 Expressions and Assignment Statements 4

Operator Function
** Exponentiation
* Multiplication
/ Division
+ Addition or unary plus (identity)
– Subtraction or unary minus (negation)

Unary operators operate on a single operand. Binary operators operate on a pair of operands. The
plus and minus operators can be unary or binary. When they are unary operators, the plus or minus
operators precede a single operand and denote a positive (identity) or negative (negation) value,
respectively. The exponentiation, multiplication, and division operators are binary operators.
Valid numeric operations must have results that are defined by the arithmetic used by the
processor. For example, raising a negative-valued base to a real power is invalid.
Numeric expressions are evaluated in an order determined by a precedence associated with each
operator, as follows (see also “Summary of Operator Precedence”):

Operator Precedence
** Highest
* and / .
Unary + and – .
Binary + and – Lowest

Operators with equal precedence are evaluated in left-to-right order. However, exponentiation is
evaluated from right to left. For example, A**B**C is evaluated as A**(B**C). B**C is
evaluated first, then A is raised to the resulting power.
Normally, two operators cannot appear together. However, Intel® Fortran allows two consecutive
operators if the second operator is a plus or minus.

Examples
In the following example, the exponentiation operator is evaluated first because it takes
precedence over the multiplication operator:
A**B*C is evaluated as (A**B)*C
Ordinarily, the exponentiation operator would be evaluated first in the following example.
However, because Intel Fortran allows the combination of the exponentiation and minus operators,
the exponentiation operator is not evaluated until the minus operator is evaluated:

4-3
4 Intel Fortran Language Reference

A**-B*C is evaluated as A**(-(B*C))

Note that the multiplication operator is evaluated first, since it takes precedence over the minus
operator.
When consecutive operators are used with constants, the unary plus or minus before the constant is
treated the same as any other operator. This can produce unexpected results. In the following
example, the multiplication operator is evaluated first, since it takes precedence over the minus
operator:
X/-15.0*Y is evaluated as X/-(15.0*Y)

Using Parentheses in Numeric Expressions

You can use parentheses to force a particular order of evaluation. When part of an expression is
enclosed in parentheses, that part is evaluated first. The resulting value is used in the evaluation of
the remainder of the expression.
In the following examples, the numbers below the operators indicate a possible order of
evaluation. Alternative evaluation orders are possible in the first three examples because they
contain operators of equal precedence that are not enclosed in parentheses. In these cases, the
compiler is free to evaluate operators of equal precedence in any order, as long as the result is the
same as the result gained by the algebraic left-to-right order of evaluation.
4 + 3 * 2 - 6/2 = 7
^ ^ ^ ^
2 1 4 3

(4 + 3) * 2 - 6/2 = 11
^ ^ ^ ^
1 2 4 3

(4 + 3 * 2 - 6)/2 = 2
^ ^ ^ ^
2 1 3 4

((4 + 3) * 2 - 6)/2 = 4
^ ^ ^ ^
1 2 3 4
Expressions within parentheses are evaluated according to the normal order of precedence. In
expressions containing nested parentheses, the innermost parentheses are evaluated first.
Nonessential parentheses do not affect expression evaluation, as shown in the following example:
4 + (3 * 2) - (6/2)

4-4
 Expressions and Assignment Statements 4
However, using parentheses to specify the evaluation order is often important in high-accuracy
numerical computations. In such computations, evaluation orders that are algebraically equivalent
may not be computationally equivalent when processed by a computer (because of the way
intermediate results are rounded off).
Parentheses can be used in argument lists to force a given argument to be treated as an expression,
rather than as the address of a memory item.

Data Type of Numeric Expressions

If every operand in a numeric expression is of the same data type, the result is also of that type.
If operands of different data types are combined in an expression, the evaluation of that expression
and the data type of the resulting value depend on the ranking associated with each data type. The
following table shows the ranking assigned to each data type:

Data Type Ranking

LOGICAL(1) and BYTE Lowest
LOGICAL(2) .
LOGICAL(4) .
LOGICAL(8) .
INTEGER(1) .
INTEGER(2) .
INTEGER(4) .
INTEGER(8) .
REAL(4) .
1
REAL(8) .
REAL(16) .
COMPLEX(4) .
COMPLEX(8) .
2
COMPLEX(16) Highest
1. DOUBLE PRECISION
2. DOUBLE COMPLEX

The data type of the value produced by an operation on two numeric operands of different data
types is the data type of the highest- ranking operand in the operation. For example, the value
resulting from an operation on an integer and a real operand is of real type. However, an operation
involving a COMPLEX(4) or COMPLEX(8) data type and a DOUBLE PRECISION data type
produces a COMPLEX(8) result.

4-5
4 Intel Fortran Language Reference

The data type of an expression is the data type of the result of the last operation in that expression,
and is determined according to the following conventions:
• Integer operations: Integer operations are performed only on integer operands. (Logical
entities used in a numeric context are treated as integers.) In integer arithmetic, any fraction
resulting from division is truncated, not rounded. For example, the result of 1/4 + 1/4 +
1/4 + 1/4 is 0, not 1.
• Real operations: Real operations are performed only on real operands or combinations of real,
integer, and logical operands. Any integer operands present are converted to real data type by
giving each a fractional part equal to zero. The expression is then evaluated using real
arithmetic. However, in the statement Y = (I /J)*X, an integer division operation is
performed on I and J, and a real multiplication is performed on that result and X.
If one operand is a higher-precision real (REAL(8) or REAL(16)) type, the other operand is
converted to that higher-precision real type before the expression is evaluated.
When a single-precision real operand is converted to a double-precision real operand,
low-order binary digits are set to zero. This conversion does not increase accuracy;
conversion of a decimal number does not produce a succession of decimal zeros. For
example, a REAL variable having the value 0.3333333 is converted to approximately
0.3333333134651184D0. It is not converted to either 0.3333333000000000D0 or
0.3333333333333333D0.
• Complex operations: In operations that contain any complex operands, integer operands are
converted to real type, as previously described. The resulting single-precision or
double-precision operand is designated as the real part of a complex number and the
imaginary part is assigned a value of zero. The expression is then evaluated using complex
arithmetic and the resulting value is of complex type. Operations involving a COMPLEX(4)
or COMPLEX(8) operand and a DOUBLE PRECISION operand are performed as
COMPLEX(8) operations; the DOUBLE PRECISION operand is not rounded.
These rules also generally apply to numeric operations in which one of the operands is a constant.
However, if a real or complex constant is used in a higher-precision expression, additional
precision will be retained for the constant. The effect is as if a DOUBLE PRECISION (REAL(8))
or REAL(16) representation of the constant were given. For example, the expression 1.0D0 +
0.3333333 is treated as if it is 1.0D0 + 0.3333333000000000D0.

Character Expressions
A character expression consists of a character operator (//) that concatenates two operands of type
character. The evaluation of a character expression produces a single value of that type.

4-6
 Expressions and Assignment Statements 4
The result of a character expression is a character string whose value is the value of the left
character operand concatenated to the value of the right operand. The length of a character
expression is the sum of the lengths of the values of the operands. For example, the value of the
character expression ’AB’//’CDE’ is ’ABCDE’, which has a length of five.
Parentheses do not affect the evaluation of a character expression; for example, the following
character expressions are equivalent:
(’ABC’//’DE’)//’F’
’ABC’//(’DE’//’F’)
’ABC’//’DE’//’F’
Each of these expressions has the value ’ ABCDEF’.
If a character operand in a character expression contains blanks, the blanks are included in the
value of the character expression. For example, ’ABC ’//’D E’//’F ’ has a value of
’ABC D EF ’.

Relational Expressions
A relational expression consists of two or more expressions whose values are compared to
determine whether the relationship stated by the relational operator is satisfied. The following are
relational operators:

Operator Relationship
.LT. or < Less than
.LE. or <= Less than or equal to
.EQ. or == Equal to
.NE. or /= Not equal to
.GT. or > Greater than
.GE. or >= Greater than or equal to

The result of the relational expression is .TRUE. if the relation specified by the operator is
satisfied; the result is .FALSE. if the relation specified by the operator is not satisfied.
Relational operators are of equal precedence. Numeric operators and the character operator // have
a higher precedence than relational operators.
In a numeric relational expression, the operands are numeric expressions. Consider the following
example:
APPLE+PEACH > PEAR+ORANGE

4-7
4 Intel Fortran Language Reference

This expression states that the sum of APPLE and PEACH is greater than the sum of PEAR and
ORANGE. If this relationship is valid, the value of the expression is .TRUE.; if not, the value is
.FALSE..
Operands of type complex can only be compared using the equal operator (= = or .EQ.) or the not
equal operator (/= or .NE.). Complex entities are equal if their corresponding real and imaginary
parts are both equal.
In a character relational expression, the operands are character expressions. In character relational
expressions, less than (< or .LT.) means the character value precedes in the ASCII collating
sequence, and greater than (> or .GT.) means the character value follows in the ASCII collating
sequence. For example:
'AB'//'ZZZ' .LT. 'CCCCC'
This expression states that 'ABZZZ' is less than 'CCCCC'. In this case, the relation specified by
the operator is satisfied, so the result is .TRUE..
Character operands are compared one character at a time, in order, starting with the first character
of each operand. If the two character operands are not the same length, the shorter one is padded
on the right with blanks until the lengths are equal; for example:
'ABC' .EQ. 'ABC '
'AB' .LT. 'C'
The first relational expression has the value .TRUE. even though the lengths of the expressions are
not equal, and the second has the value .TRUE. even though 'AB' is longer than 'C'.
A relational expression can compare two numeric expressions of different data types. In this case,
the value of the expression with the lower-ranking data type is converted to the higher-ranking
data type before the comparison is made.

See Also
“Data Type of Numeric Expressions” for details on the ranking of data types

Logical Expressions
A logical expression consists of one or more logical operators and logical, numeric, or relational
operands. The following are logical operators:

Operator Example Meaning

.AND. A .AND. B Logical conjunction: the expression is true if both A and B
are true.
.OR. A .OR. B Logical disjunction (inclusive OR): the expression is true if
either A, B, or both, are true.

4-8
 Expressions and Assignment Statements 4
Operator Example Meaning
.NEQV. A .NEQV. B Logical inequivalence (exclusive OR): the expression is true
if either A or B is true, but false if both are true.
.XOR. A .XOR. B Same as .NEQV.
.EQV. A .EQV. B Logical equivalence: the expression is true if both A and B
are true, or both are false.
.NOT.1 .NOT. A Logical negation: the expression is true if A is false and
false if A is true.
1. .NOT. is a unary operator.

Periods cannot appear consecutively except when the second operator is .NOT. For example, the
following logical expression is valid:
A+B/(A-1) .AND. .NOT. D+B/(D-1)

Data Types Resulting from Logical Operations

Logical operations on logical operands produce single logical values (.TRUE. or .FALSE.) of
logical type.
Logical operations on integers produce single values of integer type. The operation is carried out
bit-by-bit on corresponding bits of the internal (binary) representation of the integer operands.
Logical operations on a combination of integer and logical values also produce single values of
integer type. The operation first converts logical values to integers, then operates as it does with
integers.
Logical operations cannot be performed on other data types.

Evaluation of Logical Expressions

Logical expressions are evaluated according to the precedence of their operators. Consider the
following expression:
A*B+C*ABC == X*Y+DM/ZZ .AND. .NOT. K*B> TT
This expression is evaluated in the following sequence:
(((A*B)+(C*ABC)) == ((X*Y)+(DM/ZZ))) .AND. (.NOT. ((K*B)> TT))
As with numeric expressions, you can use parentheses to alter the sequence of evaluation.
When operators have equal precedence, the compiler can evaluate them in any order, as long as the
result is the same as the result gained by the algebraic left-to-right order of evaluation (except for
exponentiation, which is evaluated from right to left).

4-9
4 Intel Fortran Language Reference

You should not write logical expressions whose results might depend on the evaluation order of
subexpressions. The compiler is free to evaluate subexpressions in any order. In the following
example, either (A(I)+1.0) or B(I)*2.0 could be evaluated first:
(A(I)+1.0) .GT. B(I)*2.0
Some subexpressions might not be evaluated if the compiler can determine the result by testing
other subexpressions in the logical expression. Consider the following expression:
A .AND. (F(X,Y) .GT. 2.0) .AND. B
If the compiler evaluates A first, and A is false, the compiler might determine that the expression
is false and might not call the subprogram F(X,Y).

See Also
“Summary of Operator Precedence” for details on the precedence of numeric, relational, and
logical operators

Defined Operations
When operators are defined for functions, the functions can then be referenced as defined
operations.
The operators are defined by using a generic interface block specifying OPERATOR, followed by
the defined operator (in parentheses).
A defined operation is not an intrinsic operation. However, you can use a defined operation to
extend the meaning of an intrinsic operator.
For defined unary operations, the function must contain one argument. For defined binary
operations, the function must contain two arguments.
Interpretation of the operation is provided by the function that defines the operation.
A Fortran 95/90 defined operator can contain up to 31 letters, and is enclosed in periods (.). Its
name cannot be the same name as any of the following:
• The intrinsic operators (.NOT., .AND., .OR., .XOR., .EQV., .NEQV., .EQ., .NE., .GT., .GE.,
.LT., and .LE.)
• The logical literal constants (.TRUE. or .FALSE.).
An intrinsic operator can be followed by a defined unary operator.
The result of a defined operation can have any type. The type of the result (and its value) must be
specified by the defining function.
The following examples show expressions containing defined operators:
.COMPLEMENT. A
X .PLUS. Y .PLUS. Z

4-10
 Expressions and Assignment Statements 4
M * .MINUS. N

See Also
• “Defining Generic Operators”
• “Summary of Operator Precedence”

Summary of Operator Precedence

Table 4-1 shows the precedence of all intrinsic and defined operators:

Table 4-1 Precedence of Expression Operators

Category Operator Precedence
Defined unary operators Highest
Numeric ** .
Numeric * or / .
Numeric Unary + or – .
Numeric Binary + or – .
Character // .
Relational .EQ., .NE., .LT., .LE., .GT., .GE. = =, .
/=, <, <=, >, >=
Logical .NOT. .
Logical .AND. .
Logical .OR. .
Logical .XOR., .EQV., .NEQV. .
Defined binary operators Lowest

Initialization and Specification Expressions

A constant expression contains intrinsic operations and parts that are all constants. An
initialization expression is a constant expression that is evaluated when a program is compiled. A
specification expression is a scalar, integer expression that is restricted to declarations of array
bounds and character lengths.
Initialization and specification expressions can appear in specification statements, with some
restrictions.

4-11
4 Intel Fortran Language Reference

Initialization Expressions
An initialization expression must evaluate at compile time to a constant. It is used to specify an
initial value for an entity.
In an initialization expression, each operation is intrinsic and each operand is one of the following:
• A constant or subobject of a constant
• An array constructor where each element and the bounds and strides of each implied-DO, are
expressions whose primaries are initialization expressions
• A structure constructor whose components are initialization expressions
• An elemental intrinsic function reference of type integer or character, whose arguments are
initialization expressions of type integer or character
• A reference to one of the following inquiry functions:
BIT_SIZE MINEXPONENT
DIGITS PRECISION
EPSILON RADIX
HUGE RANGE
ILEN SHAPE
KIND SIZE
LBOUND TINY
LEN UBOUND
MAXEXPONENT
• Each function argument must be one of the following:
— An initialization expression
— A variable whose kind type parameter and bounds are not assumed or defined by an
ALLOCATE statement, pointer assignment, or an expression that is not an initialization
expression
• A reference to one of the following transformational functions (each argument must be an
initialization expression): functions:
REPEAT SELECTED_REAL_KIND
RESHAPE TRANSFER
SELECTED_INT_KIND TRIM
• A reference to the transformational function NULL
• An implied-DO variable within an array constructor where the bounds and strides of the
corresponding implied-DO are initialization expressions

4-12
 Expressions and Assignment Statements 4
• Another initialization expression enclosed in parentheses
Each subscript, section subscript, and substring starting and ending point must be an initialization
expression.
In an initialization expression, the exponential operator (**) must have a power of type integer.
If an initialization expression invokes an inquiry function for a type parameter or an array bound
of an object, the type parameter or array bound must be specified in a prior specification statement
(or to the left of the inquiry function in the same statement).

Examples
The following examples show valid and invalid initialization (constant) expressions:

Valid
–1 + 3
SIZE(B) ! B is a named constant
7_2
INT(J, 4) ! J is a named constant
SELECTED_INT_KIND (2)

Invalid Explanation
SUM(A) Not an allowed function.
A/4.1 – K**1.2 Exponential does not have integer power (A and K are named
constants).
HUGE(4.0) Argument is not an integer.

See Also
• “Array Constructors”
• “Structure Constructors”
• “Intrinsic Procedures” for details on intrinsic functions
Specification Expressions
A specification expression is 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.
In a restricted expression, each operation is intrinsic and each operand is one of the following:
• A constant or subobject of a constant
• A variable that is one of the following:

4-13
4 Intel Fortran Language Reference

— A dummy argument that does not have the OPTIONAL or INTENT (OUT) attribute (or
the subobject of such a variable)
— In a common block (or the subobject of such a variable)
— Made accessible by use or host association (or the subobject of such a variable)
• A structure constructor whose components are restricted expressions
• An implied-DO variable within an array constructor where the bounds and strides of the
corresponding implied-DO are restricted expressions
• A reference to one of the following inquiry functions:
BIT_SIZE MINEXPONENT
DIGITS PRECISION
EPSILON RADIX
HUGE RANGE
ILEN SHAPE
KIND SIZE
LBOUND SIZEOF
LEN TINY
MAXEXPONENT UBOUND
Each function argument must be one of the following:
— A restricted expression
— A variable whose properties inquired about are not dependent on the upper bound of the
last dimension of an assumed-size array, are not defined by an expression that is not a
restricted expression, or are not definable by an ALLOCATE or pointer assignment
statement.
• A reference to any other intrinsic function where each argument is a restricted expression.
• A reference to a specification function where each argument is a restricted expression
• An array constructor where each element and the bounds and strides of each implied-DO, are
expressions whose primaries are restricted expressions
• Another restricted expression enclosed in parentheses
Each subscript, section subscript, and substring starting and ending point must be a restricted
expression.
Specification functions can be used in specification expressions to indicate the attributes of data
objects. A specification function is a pure function. It cannot have a dummy procedure argument
or be any of the following:
• An intrinsic function

4-14
 Expressions and Assignment Statements 4
• An internal function
• A statement function
• Defined as RECURSIVE
A variable in a specification expression must have its type and type parameters (if any) specified
in one of the following ways:
• By a previous declaration in the same scoping unit
• By the implicit typing rules currently in effect for the scoping unit
• By host or use association
If a variable in a specification expression is typed by the implicit typing rules, its appearance in
any subsequent type declaration statement must confirm the implied type and type parameters.
If a specification expression invokes an inquiry function for a type parameter or an array bound of
an object, the type parameter or array bound must be specified in a prior specification statement
(or to the left of the inquiry function in the same statement).
In a specification expression, the number of arguments for a function reference is limited to 255.

Examples
The following shows valid specification expressions:
MAX(I) + J ! I and J are scalar integer variables
UBOUND(ARRAY_B,20) ! ARRAY_B is an assumed-shape dummy array

See Also
• “Array Constructors”
• “Implicit Typing Rules”
• “Structure Constructors”
• “Use and Host Association”
• “Pure Procedures”
• Chapter 9, “Intrinsic Procedures”, for details on intrinsic functions

Assignment Statements
An assignment statement causes variables to be defined or redefined. This section describes the
following kinds of assignment statements: intrinsic, defined, pointer, masked array (WHERE), and
element array (FORALL).
The ASSIGN statement assigns a label to an integer variable. It is discussed in “The ASSIGN and
Assigned GO TO Statements”.

4-15
4 Intel Fortran Language Reference

Intrinsic Assignments
Intrinsic assignment is used to assign a value to a nonpointer variable. In the case of pointers,
intrinsic assignment is used to assign a value to the target associated with the pointer variable. The
value assigned to the variable (or target) is determined by evaluation of the expression to the right
of the equal sign.
An intrinsic assignment statement takes the following form:
variable = expression
variable
Is the name of a scalar or array of intrinsic or derived type (with no defined assignment). The array
cannot be an assumed-size array, and neither the scalar nor the array can be declared with the
PARAMETER or INTENT(IN) attribute.
expression
Is of intrinsic type or the same derived type as variable. Its shape must conform with variable. If
necessary, it is converted to the same type and kind as variable.

Rules and Behavior

Before a value is assigned to the variable, the expression part of the assignment statement and any
expressions within the variable are evaluated. No definition of expressions in the variable can
affect or be affected by the evaluation of the expression part of the assignment statement.

NOTE. When the run-time system assigns a value to a scalar integer or

character variable and the variable is shorter than the value being assigned,
the assigned value may be truncated and significant bits (or characters) lost.
This truncation can occur without warning, and can cause the run- time system
to pass incorrect information back to the program.

If the variable is a pointer, it must be associated with a definable target. The shape of the target and
expression must conform and their type and kind parameters must match.
The following sections discuss numeric, logical, character, derived- type, and array intrinsic
assignment.

See Also
• “Arrays”
• “Derived Data Types”
• “Defining Generic Assignment” for details on subroutine subprograms that define assignment

4-16
 Expressions and Assignment Statements 4
• “POINTER Attribute and Statement” for details on pointers

Numeric Assignment Statements

For numeric assignment statements, the variable and expression must be numeric type.
The expression must yield a value that conforms to the range requirements of the variable. For
example, a real expression that produces a value greater than 32767 is invalid if the entity on the
left of the equal sign is an INTEGER(2) variable.
Significance can be lost if an INTEGER(4) value, which can exactly represent values of
approximately the range –2*10**9 to +2*10**9, is converted to REAL(4) (including the real part
of a complex constant), which is accurate to only about seven digits.
If the variable has the same data type as that of the expression on the right, the statement assigns
the value directly. If the data types are different, the value of the expression is converted to the
data type of the variable before it is assigned.
Table 4-2 summarizes the data conversion rules for numeric assignment statements.

Table 4-2 Conversion Rules for Numeric Assignment Statements

Expression (E)
Scalar Memory
Reference (V) Integer, Logical, or Real Complex
Integer or Logical V=INT(E) V=INT(REAL(E))
Imaginary part of E is not used.
REAL V=REAL(E) V=REAL(REAL(E))
(KIND=4) Imaginary part of E is not used.
REAL V=DBLE(E) V=DBLE(REAL(E))
(KIND=8) Imaginary part of E is not used.
REAL V=QEXT(E) V=QEXT(REAL(E))
(KIND=16) Imaginary part of E is not used.
COMPLEX V=CMPLX(REAL(E), 0.0) V=CMPLX(REAL(REAL(E)), REAL(AIMAG(E)))
(KIND=4)
COMPLEX V=CMPLX(DBLE(E), 0.0) V=CMPLX(DBLE(REAL(E)), DBLE(AIMAG(E)))
(KIND=8)
COMPLEX V=CMPLX(QEXT(E), 0.0) V=CMPLX(QEXT(REAL(E)), QEXT(AIMAG(E)))
(KIND=16)

4-17
4 Intel Fortran Language Reference

Examples
The following examples show valid and invalid numeric assignment statements:

Valid
BETA = -1./(2.*X)+A*A /(4.*(X*X))
PI = 3.14159
SUM = SUM + 1.
ARRAY_A = ARRAY_B + ARRAY_C + SCALAR_I ! Valid if all arrays conform in shape.
Invalid Explanation
3.14 = A – B Entity on the left must be a variable.
ICOUNT = A//B(3:7) Implicitly typed data types do not match.
SCALAR_I = ARRAY_A(:) Shapes do not match.

See Also
• “INT”
• “REAL”
• “DBLE”
• “QEXT”
• “CMPLX”
• “AIMAG”
Logical Assignment Statements
For logical assignment statements, the variable must be of logical type and the expression can be
of logical or numeric type.
If necessary, the expression is converted to the same type and kind as the variable.

Examples
The following examples show valid logical assignment statements:
PAGEND = .FALSE.
PRNTOK = LINE .LE. 132 .AND. .NOT. PAGEND
ABIG = A.GT.B .AND. A.GT.C .AND. A.GT.D
LOGICAL_VAR = 123 ! Moves binary value of 123 to LOGICAL_VAR

Character Assignment Statements

For character assignment statements, the variable and expression must be of character type and
have the same kind parameter.

4-18
 Expressions and Assignment Statements 4
The variable and expression can have different lengths. If the length of the expression is greater
than the length of the variable, the character expression is truncated on the right. If the length of
the expression is less than the length of the variable, the character expression is filled on the right
with blank characters.
If you assign a value to a character substring, you do not affect character positions in any part of
the character scalar variable not included in the substring. If a character position outside of the
substring has a value previously assigned, it remains unchanged. If the character position is
undefined, it remains undefined.

Examples
The following examples show valid and invalid character assignment statements. (In the valid
examples, all variables are of type character.)

Valid
FILE = 'PROG2'
REVOL(1) = 'MAR'//'CIA'
LOCA(3:8) = 'PLANT5'
TEXT(I,J+1)(2:N-1) = NAME/ /X
Invalid Explanation
'ABC'= CHARS Left element must be a character variable, array element, or
substring reference.
CHARS = 25 Expression does not have a character data type.
STRING = 5HBEGIN Expression does not have a character data type. (Hollerith
constants are numeric, not character.)

Derived-Type Assignment Statements

In derived-type assignment statements, the variable and expression must be of the same derived
type. There must be no accessible interface block with defined assignment for objects of this
derived type.
The derived-type assignment is performed as if each component of the expression is assigned to
the corresponding component of the variable. Pointer assignment is performed for pointer
components, and intrinsic assignment is performed for nonpointer components.

Examples
The following example shows derived-type assignment:

4-19
4 Intel Fortran Language Reference

TYPE DATE
LOGICAL(1) DAY, MONTH
INTEGER(2) YEAR
END TYPE DATE

TYPE(DATE) TODAY, THIS_WEEK(7)

TYPE APPOINTMENT
...
TYPE(DATE) APP_DATE
END TYPE

TYPE(APPOINTMENT) MEETING
DO I = 1,7
CALL GET_DATE(TODAY)
THIS_WEEK(I) = TODAY
END DO
MEETING%APP_DATE = TODAY

See Also
• “Derived Data Types”
• “Pointer Assignments”
Array Assignment Statements
Array assignment is permitted when the array expression on the right has the same shape as the
array variable on the left, or the expression on the right is a scalar.
If the expression is a scalar, and the variable is an array, the scalar value is assigned to every
element of the array.
If the expression is an array, the variable must also be an array. The array element values of the
expression are assigned (element by element) to corresponding elements of the array variable.
A many-one array section is a vector-valued subscript that has two or more elements with the
same value. In intrinsic assignment, the variable cannot be a many-one array section because the
result of the assignment is undefined.

Examples
In the following example, X and Y are arrays of the same shape:
X = Y

4-20
 Expressions and Assignment Statements 4
The corresponding elements of Y are assigned to those of X element by element; the first element
of Y is assigned to the first element of X, and so forth. The processor can perform the
element-by-element assignment in any order.
The following example shows a scalar assigned to an array:
B(C+1:N, C) = 0
This sets the elements B (C+1,C), B (C+2,C),...B (N,C) to zero.
The following example causes the values of the elements of array A to be reversed:
REAL A(20) ... A(1:20) = A(20:1:-1)

See Also
• “Arrays”
• “WHERE Statement and Construct” for details on masked array assignment
• “FORALL Statement and Construct” for details on element array assignment

Defined Assignments
Defined assignment specifies an assignment operation. It is defined by a subroutine subprogram
containing a generic interface block with the specifier ASSIGNMENT(=). The subroutine is
specified by a SUBROUTINE or ENTRY statement that has two nonoptional dummy arguments.
Defined elemental assignment is indicated by specifying ELEMENTAL in the SUBROUTINE
statement.
The dummy arguments represent the variable and expression, in that order. The rank (and shape, if
either or both are arrays), type, and kind parameters of the variable and expression in the
assignment statement must match those of the corresponding dummy arguments.
The dummy arguments must not both be numeric, or of type logical or character with the same
kind parameter.
If the variable in an elemental assignment is an array, the defined assignment is performed
element-by-element, in any order, on corresponding elements of the variable and expression. If the
expression is scalar, it is treated as if it were an array of the same shape as the variable with every
element of the array equal to the scalar value of the expression.

See Also
• “Derived Data Types”
• “Subroutines” for details on subroutine subprograms
• “Defining Generic Assignment” for details on subroutine subprograms that define assignment
• “Numeric Expressions” and “Character Expressions” for details on intrinsic operations

4-21
4 Intel Fortran Language Reference

Pointer Assignments
In ordinary assignment involving pointers, the pointer is an alias for its target. In pointer
assignment, the pointer is associated with a target. If the target is undefined or disassociated, the
pointer acquires the same status as the target. The pointer assignment statement has the following
form:
pointer-object => target
pointer-object
Is a variable name or structure component declared with the POINTER attribute.
target
Is a variable or expression. Its type and kind parameters, and rank must be the same as
pointer-object. It cannot be an array section with a vector subscript.

Rules and Behavior

If the target is a variable, it must have the POINTER or TARGET attribute, or be a subobject
whose parent object has the TARGET attribute.
If the target is an expression, the result must be a pointer.
If the target is not a pointer (it has the TARGET attribute), the pointer object is associated with the
target.
If the target is a pointer (it has the POINTER attribute), its status determines the status of the
pointer object, as follows:
• If the pointer is associated, the pointer object is associated with the same object as the target.
• If the pointer is disassociated, the pointer object becomes disassociated.
• If the pointer is undefined, the pointer object becomes undefined.
A pointer must not be referenced or defined unless it is associated with a target that can be
referenced or defined.
When pointer assignment occurs, any previous association between the pointer object and a target
is terminated.
Pointers can also be assigned for a pointer structure component by execution of a derived-type
intrinsic assignment statement or a defined assignment statement.
Pointers can also become associated by using the ALLOCATE statement to allocate the pointer.
Pointers can become disassociated by deallocation, nullification of the pointer (using the
DEALLOCATE or NULLIFY statements), or by reference to the NULL intrinsic function.

Examples
The following are examples of pointer assignments:

4-22
 Expressions and Assignment Statements 4
HOUR => MINUTES(1:60) ! target is an array
M_YEAR => MY_CAR%YEAR ! target is a structure component
NEW_ROW%RIGHT => CURRENT_ROW ! pointer object is a structure component
PTR => M ! target is a variable
POINTER_C => NULL () ! reference to NULL intrinsic
The following example shows a target as a pointer:
INTEGER, POINTER :: P, N
INTEGER, TARGET :: M
INTEGER S
M = 14
N => M ! N is associated with M
P => N ! P is associated with M through N
S = P + 5
The value assigned to S is 19 (14 + 5).

See Also
• “Arrays”
• “Defined Assignments”
• “NULL”
• “POINTER Attribute and Statement” for details on pointers
• Chapter 6, “Dynamic Allocation”, for details on the ALLOCATE, DEALLOCATE, and
NULLIFY statements
• “Intrinsic Assignments” for details on derived-type intrinsic assignments

WHERE Statement and Construct

The WHERE statement and construct let you use masked array assignment, which performs an
array operation on selected elements. This kind of assignment applies a logical test to an array on
an element-by-element basis.
The WHERE statement takes the following form:
WHERE (mask-expr1) assign-stmt
The WHERE construct takes the following form:
[name:] WHERE (mask-expr1)
[where-body-stmt]...
[ELSE WHERE (mask-expr2) [name]
[where-body-stmt]...]

4-23
4 Intel Fortran Language Reference

[ELSE WHERE [name]

[where-body-stmt]...]
END WHERE [name]
mask-expr1, mask-expr2
Are logical array expressions (called mask expressions).
assign-stmt
Is an assignment statement of the form: array variable = array expression.
name
Is the name of the WHERE construct.
where-body-stmt
Is one of the following:
• An assign-stmt
The assignment can be a defined assignment only if the routine implementing the defined
assignment is elemental.
• A WHERE statement or construct
Rules and Behavior
If a construct name is specified in a WHERE statement, the same name must appear in the
corresponding END WHERE statement. The same construct name can optionally appear in any
ELSE WHERE statement in the construct. (ELSE WHERE cannot specify a different name.)
In each assignment statement, the mask expression, the variable being assigned to, and the
expression on the right side, must all be conformable. Also, the assignment statement cannot be a
defined assignment.
Only the WHERE statement (or the first line of the WHERE construct) can be labeled as a branch
target statement.
The following is an example of a WHERE statement:
INTEGER A, B, C
DIMENSION A(5), B(5), C(5)
DATA A /0,1,1,1,0/
DATA B /10,11,12,13,14/
C = -1

WHERE(A .NE. 0) C = B / A
The resulting array C contains: –1,11,12,13, and –1.

4-24
 Expressions and Assignment Statements 4
The assignment statement is only executed for those elements where the mask is true. Think of the
mask expression as being evaluated first into a logical array that has the value true for those
elements where A is positive. This array of trues and falses is applied to the arrays A, B and C in
the assignment statement. The right side is only evaluated for elements for which the mask is true;
assignment on the left side is only performed for those elements for which the mask is true. The
elements for which the mask is false do not get assigned a value.
In a WHERE construct, the mask expression is evaluated first and only once. Every assignment
statement following the WHERE is executed as if it were a WHERE statement with "mask-expr1"
and every assignment statement following the ELSE WHERE is executed as if it were a WHERE
statement with ".NOT. mask-expr1". If ELSE WHERE specifies "mask-expr2", it is executed as
"(.NOT. mask-expr1) .AND. mask-expr2" during the processing of the ELSE WHERE statement.
You should be careful if the statements have side effects, or modify each other or the mask
expression.
The following is an example of the WHERE construct:
DIMENSION PRESSURE(1000), TEMP(1000), PRECIPITATION(1000)
WHERE(PRESSURE .GE. 1.0)
PRESSURE = PRESSURE + 1.0
TEMP = TEMP - 10.0
ELSEWHERE
PRECIPITATION = .TRUE.
ENDWHERE
The mask is applied to the arguments of functions on the right side of the assignment if they are
considered to be elemental functions. Only elemental intrinsics are considered elemental
functions. Transformational intrinsics, inquiry intrinsics, and functions or operations defined in
the subprogram are considered to be nonelemental functions.
Consider the following example using LOG, an elemental function:
WHERE(A .GT. 0) B = LOG(A)
The mask is applied to A, and LOG is executed only for the positive values of A. The result of the
LOG is assigned to those elements of B where the mask is true.
Consider the following example using SUM, a nonelemental function:
REAL A, B
DIMENSION A(10,10), B(10)
WHERE(B .GT. 0.0) B = SUM(A, DIM=1)
Since SUM is nonelemental, it is evaluated fully for all of A. Then, the assignment only happens
for those elements for which the mask evaluated to true.
Consider the following example:

4-25
4 Intel Fortran Language Reference

REAL A, B, C
DIMENSION A(10,10), B(10), C(10)
WHERE(C .GT. 0.0) B = SUM(LOG(A), DIM=1)/C
Because SUM is nonelemental, all of its arguments are evaluated fully regardless of whether they
are elemental or not. In this example, LOG(A) is fully evaluated for all elements in A even though
LOG is elemental. Notice that the mask is applied to the result of the SUM and to C to determine
the right side. One way of thinking about this is that everything inside the argument list of a
nonelemental function does not use the mask, everything outside does.

See Also
“FORALL Statement and Construct” for details on a generalized form of masked array
assignment

FORALL Statement and Construct

The FORALL statement and construct is a generalization of the Fortran 95/90 masked array
assignment (WHERE statement and construct). It allows more general array shapes to be assigned,
especially in construct form.
FORALL is a feature of Fortran 95. It takes the following form:
FORALL (triplet-spec [, triplet-spec]...[, mask-expr]) assign-stmt
The FORALL construct takes the following form:
[name:] FORALL (triplet-spec [, triplet-spec]...[, mask-expr])
forall-body-stmt
[forall-body-stmt]...
END FORALL [name]
triplet-spec
Is a triplet specification with the following form:
subscript-name = subscript-1 : subscript-2 [:stride]
The subscript-name must be a scalar of type integer. It is valid only within the scope of the
FORALL; its value is undefined on completion of the FORALL.
The subscripts and stride cannot contain a reference to any subscript-name in triplet-spec.
The stride cannot be zero. If it is omitted, the default value is 1.
Evaluation of an expression in a triplet specification must not affect the result of evaluating any
other expression in another triplet specification.

4-26
 Expressions and Assignment Statements 4
mask-expr
Is a logical array expression (called the mask expression). If it is omitted, the value .TRUE. is
assumed. The mask expression can reference the subscript name in triplet-spec.
assign-stmt
Is an assignment statement or a pointer assignment statement. The variable being assigned to must
be an array element or array section and must reference all of the subscript-names included in all
triplet-specs.
name
Is the name of the FORALL construct.
forall-body-stmt
Is one of the following:
• An assign-stmt
• A WHERE statement or construct
The WHERE statement and construct use a mask to make the array assignments (see
“WHERE Statement and Construct”).
• A FORALL statement or construct
Rules and Behavior
If a construct name is specified in the FORALL statement, the same name must appear in the
corresponding END FORALL statement.
A FORALL statement is executed by first evaluating all bounds and stride expressions in the
triplet specifications, giving a set of values for each subscript name. The FORALL assignment
statement is executed for all combinations of subscript name values for which the mask expression
is true.
The FORALL assignment statement is executed as if all expressions (on both sides of the
assignment) are completely evaluated before any part of the left side is changed. Valid values are
assigned to corresponding elements of the array being assigned to. No element of an array can be
assigned a value more than once.
A FORALL construct is executed as if it were multiple FORALL statements, with the same triplet
specifications and mask expressions. Each statement in the FORALL body is executed completely
before execution begins on the next FORALL body statement.
Any procedure referenced in the mask expression or FORALL assignment statement must be pure.
Pure functions can be used in the mask expression or called directly in a FORALL statement. Pure
subroutines cannot be called directly in a FORALL statement, but can be called from other pure
procedures.

4-27
4 Intel Fortran Language Reference

Examples
Consider the following:
FORALL(I = 1:N, J = 1:N, A(I, J) .NE. 0.0) B(I, J) = 1.0 / A(I, J)
This statement takes the reciprocal of each nonzero element of array A(1:N, 1:N) and assigns it to
the corresponding element of array B. Elements of A that are zero do not have their reciprocal
taken, and no assignments are made to corresponding elements of B.
Every array assignment statement and WHERE statement can be written as a FORALL statement,
but some FORALL statements cannot be written using just array syntax. For example, the
preceding FORALL statement is equivalent to the following:
WHERE(A /= 0.0) B = 1.0 / A
It is also equivalent to:
FORALL (I = 1:N, J = 1:N)
WHERE(A(I, J) .NE. 0.0) B(I, J) = 1.0/A(I, J)
END FORALL
However, the following FORALL example cannot be written using just array syntax:
FORALL(I = 1:N, J = 1:N) H(I, J) = 1.0/REAL(I + J - 1)
This statement sets array element H(I, J) to the value 1.0 /REAL(I + J - 1) for values of I and
J between 1 and N.
Consider the following:
TYPE MONARCH
INTEGER, POINTER :: P
END TYPE MONARCH

TYPE(MONARCH), DIMENSION(8) :: PATTERN

INTEGER, DIMENSION(8), TARGET :: OBJECT
FORALL(J=1:8) PATTERN(J)%P => OBJECT(1+IEOR(J-1,2))
This FORALL statement causes elements 1 through 8 of array PATTERN to point to elements 3, 4,
1, 2, 7, 8, 5, and 6, respectively, of OBJECT. IEOR can be referenced here because it is pure.
The following example shows a FORALL construct:
FORALL(I = 3:N + 1, J = 3:N + 1)
C(I, J) = C(I, J + 2) + C(I, J - 2) + C(I + 2, J) + C(I - 2, J)
D(I, J) = C(I, J)
END FORALL
The assignment to array D uses the values of C computed in the first statement in the construct,
not the values before the construct began execution.

4-28
 Expressions and Assignment Statements 4
See Also
• “Subscript Triplets”
• “Pointer Assignments”
• “WHERE Statement and Construct”
• “Pure Procedures”

4-29
4 Intel Fortran Language Reference

4-30
Specification Statements 5
A specification statement is a nonexecutable statement that declares the attributes of data objects.
In Fortran 95/90, many of the attributes that can be defined in specification statements can also be
optionally specified in type declaration statements.
This chapter contains information on the following topics:
• “Type Declaration Statements”
Explicitly specifies the properties (for example: data type, rank, and extent) of data objects.
• “ALLOCATABLE Attribute and Statement”
Specifies a list of array names that are allocatable (have a deferred-shape).
• “AUTOMATIC and STATIC Attributes and Statements”
Control the storage allocation of variables in subprograms.
• “COMMON Statement”
Defines one or more contiguous areas, or blocks, of physical storage (called common blocks).
• “DATA Statement”
Assigns initial values to variables before program execution.
• “DIMENSION Attribute and Statement”
Specifies that an object is an array, and defines the shape of the array.
• “EQUIVALENCE Statement”
Specifies that a storage area is shared by two or more objects in a program unit.
• “EXTERNAL Attribute and Statement”
Allows external (user-supplied) procedures to be used as arguments to other subprograms.
• “IMPLICIT Statement”
Overrides the implicit data type of names.
• “INTENT Attribute and Statement”
Specifies the intended use of a dummy argument.

5-1
5 Intel Fortran Language Reference

• “INTRINSIC Attribute and Statement”

Allows intrinsic procedures to be used as arguments to subprograms.
• “NAMELIST Statement”
Associates a name with a list of variables. This group name can be referenced in some
input/output operations.
• “OPTIONAL Attribute and Statement”
Allows a procedure reference to omit arguments.
• “PARAMETER Attribute and Statement”
Defines a named constant.
• “POINTER Attribute and Statement”
Specifies that an object is a pointer.
• “PRIVATE and PUBLIC Attributes and Statements”
Declare the accessibility of entities in a module.
• “SAVE Attribute and Statement”
Causes the definition and status of objects to be retained after the subprogram in which they
are declared completes execution.
• “TARGET Attribute and Statement”
Specifies a pointer target.
• “VOLATILE Attribute and Statement”
Prevents optimizations from being performed on specified objects.

See Also
Chapter 8, “Program Units and Procedures”, for details on BLOCK DATA and PROGRAM
statements

Type Declaration Statements

A type declaration statement explicitly specifies the properties of data objects or functions.
The general form of a type declaration statement follows:
type [[, att]... ::] v [/c-list/] [, v [/c-list/]]...
type
Is one of the following data type specifiers:
BYTE DOUBLE COMPLEX
INTEGER[([KIND=]k)] CHARACTER[([LEN=]n)[,[KIND=]k]]

5-2
 Specification Statements 5
REAL[([KIND=]k)] LOGICAL[([KIND=]k)]
DOUBLE PRECISION TYPE (derived-type-name)
COMPLEX[([KIND=]k)]
In the optional kind selector "([KIND=]k) ", k is the kind parameter. It must be an acceptable kind
parameter for that data type. If the kind selector is not present, entities declared are of default type.
(For a list of the valid noncharacter data types, see Table 5-2.)
Kind parameters for intrinsic numeric and logical data types can also be specified using the *n
format, where n is the length (in bytes) of the entity; for example, INTEGER*4.
att
Is one of the following attribute specifiers:
ALLOCATABLE POINTER
AUTOMATIC PRIVATE1
DIMENSION PUBLIC1
EXTERNAL SAVE
INTENT STATIC
INTRINSIC TARGET
OPTIONAL VOLATILE
PARAMETER
1. These are access specifiers.

v
Is the name of a data object or function. It can optionally be followed by:
• An array specification, if the object is an array.
In a function declaration, an array must be a deferred-shape array if it has the POINTER
attribute; otherwise, it must be an explicit-shape array.
• A character length, if the object is of type character.
• An initialization expression or, for pointer objects, => NULL( ).
A function name must be the name of an intrinsic function, external function, function dummy
procedure, or statement function.
c-list
Is a list of constants, as in a DATA statement. If v is the name of a constant or an initialization
expression, the c-list cannot be present.

5-3
5 Intel Fortran Language Reference

The c-list cannot specify more than one value unless it initializes an array. When initializing an
array, the c-list must contain a value for every element in the array.

Rules and Behavior

Type declaration statements must precede all executable statements.
In most cases, a type declaration statement overrides (or confirms) the implicit type of an entity.
However, a variable that appears in a DATA statement and is typed implicitly can appear in a
subsequent type declaration only if that declaration confirms the implicit typing.
The double colon separator (::) is required only if the declaration contains an attribute specifier or
initialization; otherwise it is optional.
If att appears, c-list cannot be specified; for example:
INTEGER I /2/ ! Valid
INTEGER, SAVE :: I /2/ ! Invalid
The same attribute must not appear more than once in a given type declaration statement, and an
entity cannot be given the same attribute more than once in a scoping unit.
If the PARAMETER attribute is specified, the declaration must contain an initialization
expression.
If => NULL( ) is specified for a pointer, its initial association status is disassociated.
A variable (or variable subobject) can only be initialized once in an executable program.
If a declaration contains an initialization expression, but no PARAMETER attribute is specified,
the object is a variable whose value is initially defined. The object becomes defined with the value
determined from the initialization expression according to the rules of intrinsic assignment.
The presence of initialization implies that the name of the object is saved, except for objects in
named common blocks or objects with the PARAMETER attribute.
The following objects cannot be initialized in a type declaration statement:
• A dummy argument
• A function result
• An object in a named common block (unless the type declaration is in a block data program
unit)
• An object in blank common
• An allocatable array
• An external name
• An intrinsic name
• An automatic object
• An object that has the AUTOMATIC attribute

5-4
 Specification Statements 5
An object can have more than one attribute. Table 5-1 lists the compatible attributes.

Table 5-1 Compatible Attributes

Attribute Compatible with:
ALLOCATABLE AUTOMATIC, DIMENSION1, PRIVATE, PUBLIC, SAVE, STATIC,
TARGET, VOLATILE
AUTOMATIC ALLOCATABLE, DIMENSION, POINTER, TARGET, VOLATILE
DIMENSION ALLOCATABLE, AUTOMATIC, INTENT, OPTIONAL, PARAMETER,
POINTER, PRIVATE, PUBLIC, SAVE, STATIC, TARGET, VOLATILE
EXTERNAL OPTIONAL, PRIVATE, PUBLIC
INTENT DIMENSION, OPTIONAL, TARGET, VOLATILE
INTRINSIC PRIVATE, PUBLIC
OPTIONAL DIMENSION, EXTERNAL, INTENT, POINTER, TARGET, VOLATILE
PARAMETER DIMENSION, PRIVATE, PUBLIC
POINTER AUTOMATIC, DIMENSION1, OPTIONAL, PRIVATE, PUBLIC, SAVE,
STATIC, VOLATILE
PRIVATE ALLOCATABLE, DIMENSION, EXTERNAL, INTRINSIC, PARAMETER,
POINTER, SAVE, STATIC, TARGET, VOLATILE
PUBLIC ALLOCATABLE, DIMENSION, EXTERNAL, INTRINSIC, PARAMETER,
POINTER, SAVE, STATIC, TARGET, VOLATILE
SAVE ALLOCATABLE, DIMENSION, POINTER, PRIVATE, PUBLIC, SAVE,
TARGET, VOLATILE
STATIC ALLOCATABLE, DIMENSION, POINTER, PRIVATE, PUBLIC, SAVE,
TARGET, VOLATILE
TARGET ALLOCATABLE, AUTOMATIC, DIMENSION, INTENT, OPTIONAL,
PRIVATE, PUBLIC, SAVE, STATIC, VOLATILE
VOLATILE ALLOCATABLE, AUTOMATIC, DIMENSION, INTENT, OPTIONAL,
POINTER, PRIVATE, PUBLIC, SAVE, STATIC, TARGET
1. With deferred shape

Examples
The following show valid type declaration statements:
DOUBLE PRECISION B(6)
INTEGER(KIND=2) I
REAL(KIND=4) X, Y
REAL(4) X, Y
LOGICAL, DIMENSION(10,10) :: ARRAY_A, ARRAY_B

5-5
5 Intel Fortran Language Reference

INTEGER, PARAMETER :: SMALLEST = SELECTED_REAL_KIND(6, 70)

REAL(KIND (0.0)) M
COMPLEX(KIND=8) :: D
TYPE(EMPLOYEE) :: MANAGER
REAL, INTRINSIC :: COS CHARACTER(15) PROMPT
CHARACTER*12, SAVE :: HELLO_MSG
INTEGER COUNT, MATRIX(4,4), SUM
LOGICAL*2 SWITCH
REAL :: X = 2.0
TYPE (NUM), POINTER :: FIRST => NULL()

See Also
• “Derived Data Types”
• “Implicit Typing Rules”
• “DATA Statement”
• “Initialization Expressions”
• “Intrinsic Data Types” for details on specific kind parameters of intrinsic data types

Declaration Statements for Noncharacter Types

Table 5-2 shows the data types that can appear in noncharacter type declaration statements.

Table 5-2 Noncharacter Data Types

BYTE1
LOGICAL2
LOGICAL(1) (or LOGICAL*1)
LOGICAL(2) (or LOGICAL*2)
LOGICAL(4) (or LOGICAL*4)
LOGICAL(8) (or LOGICAL*8)
INTEGER3
INTEGER(1) (or INTEGER*1)
INTEGER(2) (or INTEGER*2)
INTEGER(4) (or INTEGER*4)
INTEGER(8) (or INTEGER*8)
REAL4
REAL(4) (or REAL*4)

5-6
 Specification Statements 5
Table 5-2 Noncharacter Data Types
DOUBLE PRECISION (REAL(8) or REAL*8)
REAL(16) (or REAL*16)
COMPLEX5
COMPLEX(4) (or COMPLEX*8)
DOUBLE COMPLEX (COMPLEX(8) or COMPLEX*16)
COMPLEX(16) (or COMPLEX*32)
1. Same as INTEGER(1).
2. This is treated as default logical.
3. This is treated as default integer.
4. This is treated as default real.
5. This is treated as default complex.

In noncharacter type declaration statements, you can optionally specify the name of the data object
or function as v*n, where n is the length (in bytes) of v. The length specified overrides the length
implied by the data type.
The value for n must be a valid length for the type of v (see Table 15-2). The type specifiers
BYTE, DOUBLE PRECISION, and DOUBLE COMPLEX have one valid length, so the n
specifier is invalid for them.
For an array specification, the n must be placed immediately following the array name; for
example, in an INTEGER declaration statement, IVEC*2(10) is an INTEGER(2) array of 10
elements.

Examples
In a noncharacter type declaration statement, a subsequent kind parameter overrides any initial
kind parameter. For example, consider the following statements:
INTEGER(2) I, J, K, M12*4, Q, IVEC*4(10)
REAL(8) WX1, WXZ, WX3*4, WX5, WX6*4
REAL(8) PI/3.14159E0/, E/2.72E0/, QARRAY(10)/5*0.0,5*1.0/
In the first statement, M12*4 and IVEC*4 override the KIND=2 specification. In the second
statement, WX3*4 and WX6*4 override the KIND=8 specification. In the third statement,
QARRAY is initialized with implicit conversion of the REAL(4) constants to a REAL(8) data
type.

See Also
• “Type Declaration Statements” for details on the general form and rules for type declaration
statements

5-7
5 Intel Fortran Language Reference

• Your user’s guide for details on compiler options that can affect the defaults for numeric and
logical data types

Declaration Statements for Character Types

A CHARACTER type specifier can be immediately followed by the length of the character object
or function. It takes one of the following forms:
Keyword Forms
CHARACTER [([LEN=]len)]
CHARACTER [([LEN=]len [, [KIND=]n])]
CHARACTER [(KIND=n [, LEN=len])]
Nonkeyword Form
CHARACTER*len[,]
len
Is one of the following:
• In keyword forms
The len is a specification expression or an asterisk (*). If no length is specified, the default
length is 1.
If the length evaluates to a negative value, the length of the character entity is zero.
• In nonkeyword form
The len is a specification expression or an asterisk enclosed in parentheses, or a scalar integer
literal constant (with no kind parameter). The comma is permitted only if no double colon (::)
appears in the type declaration statement.
This form can also (optionally) be specified following the name of the data object or function
(v*len). In this case, the length specified overrides any length following the CHARACTER
type specifier.
The largest valid value for len in both forms is 2**31–1 on IA-32 processors; 2**63–1 on Intel®
Itanium® processors. Negative values are treated as zero.
n
Is a scalar integer initialization expression specifying a valid kind parameter. Currently the only
kind available is 1.

Rules and Behavior

An automatic object can appear in a character declaration. The object cannot be a dummy
argument, and its length must be declared with a specification expression that is not a constant
expression.

5-8
 Specification Statements 5
The length specified for a character-valued statement function or statement function dummy
argument of type character must be an integer constant expression.
When an asterisk length specification *(*) is used for a function name or dummy argument, it
assumes the length of the corresponding function reference or actual argument. Similarly, when an
asterisk length specification is used for a named constant, the name assumes the length of the
actual constant it represents. For example, STRING assumes a 9-byte length in the following
statements:
CHARACTER*(*) STRING
PARAMETER (STRING = ’VALUE IS:’)
A function name must not be declared with a * length if the function is an internal or module
function, or if it is array-valued, pointer-valued, recursive, or pure.
The form CHARACTER*(*) is an obsolescent feature in Fortran 95.

Examples
The following example declares an array NAMES containing 100 32-character elements, an array
SOCSEC containing 100 9-character elements, and a variable NAMETY that is 10 characters long
and has an initial value of 'ABCDEFGHIJ'.
CHARACTER*32 NAMES(100),SOCSEC(100)*9,NAMETY*10 /’ABCDEFGHIJ’/
The following example includes a CHARACTER statement declaring two 8-character variables,
LAST and FIRST.
INTEGER, PARAMETER :: LENGTH=4
CHARACTER*(4+LENGTH) LAST, FIRST
The following example shows a CHARACTER statement declaring an array LETTER containing
26 one-character elements. It also declares a dummy argument BUBBLE that has a passed length
defined by the calling program.
SUBROUTINE S1(BUBBLE)
CHARACTER LETTER(26), BUBBLE*(*)
In the following example, NAME2 is an automatic object:
SUBROUTINE AUTO_NAME(NAME1)
CHARACTER(LEN = *) NAME1
CHARACTER(LEN = LEN(NAME1)) NAME2

See Also
• “Type Declaration Statements” for details on the general form and rules for type declaration
statements
• “Specification of Data Type” and “Assumed-Length Character Arguments” for details on
asterisk length specifications

5-9
5 Intel Fortran Language Reference

• Appendix A, “Deleted and Obsolescent Language Features”, for details on obsolescent

features in Fortran 95

Declaration Statements for Derived Types

The derived-type (TYPE) declaration statement specifies the properties of objects and functions of
derived (user-defined) type.
The derived type must be defined before you can specify objects of that type in a TYPE type
declaration statement.
An object of derived type must not have the PUBLIC attribute if its type is PRIVATE.
A structure constructor specifies values for derived-type objects.

Examples
The following are examples of derived-type declaration statements:
TYPE(EMPLOYEE) CONTRACT
...
TYPE(SETS), DIMENSION(:,:), ALLOCATABLE :: SUBSET_1
The following example shows a public type with private components:
TYPE LIST_ITEMS
PRIVATE
...
TYPE(LIST_ITEMS), POINTER :: NEXT, PREVIOUS
END TYPE LIST_ITEMS

See Also
• “Derived Data Types”
• “Use and Host Association”
• “PRIVATE and PUBLIC Attributes and Statements”
• “Structure Constructors”
• “Type Declaration Statements” for details on the general form and rules for type declaration
statements

Declaration Statements for Arrays

An array declaration (or array declarator) declares the shape of an array. It takes the following
form:
(a-spec)

5-10
 Specification Statements 5
a-spec
Is one of the following array specifications:
• “Explicit-Shape Specifications”
• “Assumed-Shape Specifications”
• “Assumed-Size Specifications”
• “Deferred-Shape Specifications”
The array specification can be appended to the name of the array when the array is declared.

Examples
The following examples show array declarations:
SUBROUTINE SUB(N, C, D, Z)
REAL, DIMENSION(N, 15) :: IARRY ! An explicit-shape array
REAL C(:), D(0:) ! An assumed-shape array
REAL, POINTER :: B(:,:) ! A deferred-shape array pointer
REAL, ALLOCATABLE, DIMENSION(:) :: K ! A deferred-shape allocatable array
REAL :: Z(N,*) ! An assumed-size array

See Also
“Type Declaration Statements” for details on the general form and rules for type declaration
statements

Explicit-Shape Specifications
An explicit-shape array is declared with explicit values for the bounds in each dimension of the
array. An explicit-shape specification takes the following form:
([dl:] du[, [dl:] du]...)
dl
Is a specification expression indicating the lower bound of the dimension. The expression can
have a positive, negative, or zero value. If necessary, the value is converted to integer type.
If the lower bound is not specified, it is assumed to be 1.
du
Is a specification expression indicating the upper bound of the dimension. The expression can
have a positive, negative, or zero value. If necessary, the value is converted to integer type.
The bounds can be specified as constant or nonconstant expressions, as follows:

5-11
5 Intel Fortran Language Reference

• If the bounds are constant expressions, the subscript range of the array in a dimension is the
set of integer values between and including the lower and upper bounds. If the lower bound is
greater than the upper bound, the range is empty, the extent in that dimension is zero, and the
array has a size of zero.
• If the bounds are nonconstant expressions, the array must be declared in a procedure. The
bounds can have different values each time the procedure is executed, since they are
determined when the procedure is entered.
The bounds are not affected by any redefinition or undefinition of the variables in the
specification expression that occurs while the procedure is executing.
The following explicit-shape arrays can specify nonconstant bounds:
— An automatic array (the array is a local variable)
— An adjustable array (the array is a dummy argument to a subprogram)
The following are examples of explicit-shape specifications:
INTEGER I(3:8, -2:5) ! Rank-two array; range of dimension one is
... ! 3 to 8, range of dimension two is -2 to 5
SUBROUTINE SUB(A, B, C)
INTEGER :: B, C
REAL, DIMENSION(B:C) :: A ! Rank-one array; range is B to C

Automatic Arrays
An automatic array is an explicit-shape array that is a local variable. Automatic arrays are only
allowed in function and subroutine subprograms, and are declared in the specification part of the
subprogram. At least one bound of an automatic array must be a nonconstant specification
expression. The bounds are determined when the subprogram is called.
The following example shows automatic arrays:
SUBROUTINE SUB1 (A, B)
INTEGER A, B, LOWER
COMMON /BOUND/ LOWER
...
INTEGER AUTO_ARRAY1(B)
...
INTEGER AUTO_ARRAY2(LOWER:B)
..
INTEGER AUTO_ARRAY3(20, B*A/2)
END SUBROUTINE

5-12
 Specification Statements 5
Adjustable Arrays
An adjustable array is an explicit-shape array that is a dummy argument to a subprogram. At least
one bound of an adjustable array must be a nonconstant specification expression. The bounds are
determined when the subprogram is called.
The array specification can contain integer variables that are either dummy arguments or variables
in a common block.
When the subprogram is entered, each dummy argument specified in the bounds must be
associated with an actual argument. If the specification includes a variable in a common block, the
variable must have a defined value. The array specification is evaluated using the values of the
actual arguments, as well as any constants or common block variables that appear in the
specification.
The size of the adjustable array must be less than or equal to the size of the array that is its
corresponding actual argument.
To avoid possible errors in subscript evaluation, make sure that the bounds expressions used to
declare multidimensional adjustable arrays match the bounds as declared by the caller.
In the following example, the function computes the sum of the elements of a rank-two array.
Notice how the dummy arguments M and N control the iteration:
FUNCTION THE_SUM(A, M, N)
DIMENSION A(M, N)
SUMX = 0.0
DO J = 1, N
DO I = 1, M
SUMX = SUMX + A(I, J)
END DO
END DO
THE_SUM = SUMX
END FUNCTION
The following are examples of calls on THE_SUM:
DIMENSION A1(10,35), A2(3,56)
SUM1 = THE_SUM(A1,10,35)
SUM2 = THE_SUM(A2,3,56)
The following example shows how the array bounds determined when the procedure is entered do
not change during execution:
DIMENSION ARRAY(9,5)
L = 9
M = 5

5-13
5 Intel Fortran Language Reference

CALL SUB(ARRAY,L,M)
END

SUBROUTINE SUB(X,I,J)
DIMENSION X(-I/2:I/2,J)
X(I/2,J) = 999
J = 1
I = 2
END
The assignments to I and J do not affect the declaration of adjustable array X as X(–4:4,5) on entry
to subroutine SUB.

See Also
“Specification Expressions”

Assumed-Shape Specifications
An assumed-shape array is a dummy argument array that assumes the shape of its associated
actual argument array. An assumed-shape specification takes the following form:
([dl]:[, [dl]:]...)
dl
Is a specification expression indicating the lower bound of the dimension. The expression can
have a positive, negative, or zero value. If necessary, the value is converted to integer type.
If the lower bound is not specified, it is assumed to be 1.
The rank of the array is the number of colons ( : ) specified.
The value of the upper bound is the extent of the corresponding dimension of the associated actual
argument array + lower-bound – 1.
The following is an example of an assumed-shape specification:
INTERFACE
SUBROUTINE SUB(M)
INTEGER M(:, 1:, 5:)
END SUBROUTINE
END INTERFACE
INTEGER L(20, 5:25, 10)
CALL SUB(L)

5-14
 Specification Statements 5
SUBROUTINE SUB(M)
INTEGER M(:, 1:, 5:)
END SUBROUTINE
Array M has the same extents as array L, but array M has bounds (1:20, 1:21, 5:14).
Note that an explicit interface is required when calling a routine that expects an assumed-shape or
pointer array.

Assumed-Size Specifications
An assumed-size array is a dummy argument array that assumes the size (only) of its associated
actual argument array; the rank and extents can differ for the actual and dummy arrays. An
assumed-size specification takes the following form:
([expli-shape-spec,] [expli-shape-spec,]... [dl:] *)
expli-shape-spec
Is an explicit-shape specification (see “Explicit-Shape Specifications”).
dl
Is a specification expression indicating the lower bound of the dimension. The expression can
have a positive, negative, or zero value. If necessary, the value is converted to integer type. <p> If
the lower bound is not specified, it is assumed to be 1.
*
Is the upper bound of the last dimension.
The rank of the array is the number of explicit-shape specifications plus 1.
The size of the array is assumed from the actual argument associated with the assumed-size
dummy array as follows:
• If the actual argument is an array of type other than default character, the size of the dummy
array is the size of the actual array.
• If the actual argument is an array element of type other than default character, the size of the
dummy array is a + 1 - s, where s is the subscript order value and a is the size of the
actual array.
• If the actual argument is a default character array, array element, or array element substring,
and it begins at character storage unit b of an array with n character storage units, the size of
the dummy array is as follows:
MAX(INT((n + 1 - b)/y), 0)
The y is the length of an element of the dummy array.
An assumed-size array can only be used as a whole array reference in the following cases:
• When it is an actual argument in a procedure reference that does not require the shape

5-15
5 Intel Fortran Language Reference

• In the intrinsic function LBOUND

Because the actual size of an assumed-size array is unknown, an assumed-size array cannot be
used as any of the following in an I/O statement:
• An array name in the I/O list
• A unit identifier for an internal file
• A run-time format specifier
The following is an example of an assumed-size specification:
SUBROUTINE SUB(A, N)
REAL A, N
DIMENSION A(1:N, *)
...

See Also
“Array Elements” for details on array element order

Deferred-Shape Specifications
A deferred-shape array is an array pointer or an allocatable array.
The array specification contains a colon ( : ) for each dimension of the array. No bounds are
specified. The bounds (and shape) of allocatable arrays and array pointers are determined when
space is allocated for the array during program execution.
An array pointer is an array declared with the POINTER attribute. Its bounds and shape are
determined when it is associated with a target by pointer assignment, or when the pointer is
allocated by execution of an ALLOCATE statement.
In pointer assignment, the lower bound of each dimension of the array pointer is the result of the
LBOUND intrinsic function applied to the corresponding dimension of the target. The upper
bound of each dimension is the result of the UBOUND intrinsic function applied to the
corresponding dimension of the target.
A pointer dummy argument can be associated only with a pointer actual argument. An actual
argument that is a pointer can be associated with a nonpointer dummy argument.
A function result can be declared to have the pointer attribute.
An allocatable array is declared with the ALLOCATABLE attribute. Its bounds and shape are
determined when the array is allocated by execution of an ALLOCATE statement.
The following are examples of deferred-shape specifications:
REAL, ALLOCATABLE :: A(:,:) ! Allocatable array
REAL, POINTER :: C(:), D (:,:,:) ! Array pointers

5-16
 Specification Statements 5
See Also
• “POINTER Attribute and Statement”
• “ALLOCATABLE Attribute and Statement”
• “ALLOCATE Statement”
• “Pointer Assignments”
• “LBOUND”
• “UBOUND”

ALLOCATABLE Attribute and Statement

The ALLOCATABLE attribute specifies that an array is an allocatable array with a deferred shape.
The shape of an allocatable array is determined when an ALLOCATE statement is executed,
dynamically allocating space for the array.
The ALLOCATABLE attribute can be specified in a type declaration statement or an
ALLOCATABLE statement, and takes one of the following forms:
Type Declaration Statement:
type, [att-ls,] ALLOCATABLE [, att-ls] :: a[(d-spec)] [, a[(d-spec)]]...
Statement:
ALLOCATABLE [::] a[(d-spec)] [, a[(d-spec)]]...
type
Is a data type specifier.
att-ls
Is an optional list of attribute specifiers.
a
Is the name of the allocatable array; it must not be a dummy argument or function result.
d-spec
Is a deferred-shape specification (: [, :]...). Each colon represents a dimension of the array.

Rules and Behavior

If the array is given the DIMENSION attribute elsewhere in the program, it must be declared as a
deferred-shape array.
When the allocatable array is no longer needed, it can be deallocated by execution of a
DEALLOCATE statement.

5-17
5 Intel Fortran Language Reference

An allocatable array cannot be specified in a COMMON, EQUIVALENCE, DATA, or

NAMELIST statement.
Allocatable arrays are not saved by default. If you want to retain the values of an allocatable array
across procedure calls, you must specify the SAVE attribute for the array.

Examples
The following example shows a type declaration statement specifying the ALLOCATABLE
attribute:
REAL, ALLOCATABLE :: Z(:, :, :)
The following is an example of the ALLOCATABLE statement:
REAL A, B(:) ALLOCATABLE :: A(:,:), B

See Also
• “Type Declaration Statements”
• “ALLOCATE Statement”
• “DEALLOCATE Statement”
• “Allocation of Allocatable Arrays” for details on allocation status
• Table 5-1 for details on compatible attributes

AUTOMATIC and STATIC Attributes and Statements

The AUTOMATIC and STATIC attributes control the storage allocation of variables in
subprograms.
The AUTOMATIC and STATIC attributes can be specified in a type declaration statement or an
AUTOMATIC or STATIC statement, and take one of the following forms:
Type Declaration Statement:
type, [att-ls,] AUTOMATIC [, att-ls] :: v [, v]...
type, [att-ls,] STATIC [, att-ls] :: v [, v]...
Statement:
AUTOMATIC v [, v]...
STATIC v [, v]...
type
Is a data type specifier.
att-ls
Is an optional list of attribute specifiers.

5-18
 Specification Statements 5
v
Is the name of a variable or an array specification. It can be of any type.

Rules and Behavior

AUTOMATIC and STATIC declarations only affect how data is allocated in storage, as follows:
• A variable declared as AUTOMATIC and allocated in memory resides in the stack storage
area.
• A variable declared as STATIC and allocated in memory resides in the static storage area.
If you want to retain definitions of variables upon reentry to subprograms, you must use the SAVE
attribute.
Automatic variables can reduce memory use because only the variables currently being used are
allocated to memory.
Automatic variables allow possible recursion. With recursion, a subprogram can call itself
(directly or indirectly), and resulting values are available upon a subsequent call or return to the
subprogram. For recursion to occur, RECURSIVE must be specified in one of the following ways:
• As a keyword in a FUNCTION or SUBROUTINE statement
• As a compiler option
• As an option in an OPTIONS statement
By default, the compiler allocates local variables of non-recursive subprograms, except for
allocatable arrays, in the static storage area. The compiler may choose to allocate a variable in
temporary (stack or register) storage if it notices that the variable is always defined before use.
Appropriate use of the SAVE attribute can prevent compiler warnings if a variable is used before it
is defined.
To change the default for variables, specify them as AUTOMATIC or specify RECURSIVE (in
one of the ways mentioned above).
To override any compiler option that may affect variables, explicitly specify the variables as
AUTOMATIC or STATIC.

NOTE. Variables that are data-initialized, and variables in COMMON and

SAVE statements are always static. This is regardless of whether a compiler
option specifies recursion.

A variable cannot be specified as AUTOMATIC or STATIC more than once in the same scoping
unit.

5-19
5 Intel Fortran Language Reference

If the variable is a pointer, AUTOMATIC or STATIC apply only to the pointer itself, not to any
associated target.
Some variables cannot be specified as AUTOMATIC or STATIC. The following table shows these
restrictions:

Variable AUTOMATIC STATIC

Dummy argument No No
Automatic object No No
Common block item No Yes
Use-associated item No No
Function result No No
Component of a derived type No No

A variable can be specified with both the STATIC and SAVE attributes.
If a variable is in a module’s outer scope, it can be specified as STATIC, but not as AUTOMATIC.

Examples
The following examples show type declaration statements specifying the AUTOMATIC and
STATIC attributes:
REAL, AUTOMATIC :: A, B, C
INTEGER, STATIC :: ARRAY_A
The following example shows an AUTOMATIC and a STATIC statement:
...
CONTAINS
INTEGER FUNCTION REDO_FUNC
INTEGER I, J(10), K
REAL C, D, E(30)
AUTOMATIC I, J, K(20)
STATIC C, D, E
...
END FUNCTION
...

See Also
• “Type Declaration Statements”
• “OPTIONS Statement”

5-20
 Specification Statements 5
• “SAVE Attribute and Statement”
• “Functions, Subroutines, and Statement Functions” for details on subprograms
• “Recursive Procedures” for details on specifying recursive subprograms
• Table 5-1 for details on compatible attributes
• “POINTER Attribute and Statement” for details on pointers
• “Modules and Module Procedures” for details on modules
• Your user’s guide for details on compiler options

COMMON Statement
A COMMON statement defines one or more contiguous areas, or blocks, of physical storage
(called common blocks) that can be accessed by any of the scoping units in an executable
program. COMMON statements also define the order in which variables and arrays are stored in
each common block, which can prevent misaligned data items.
Common blocks can be named or unnamed (a blank common).
The COMMON statement takes the following form:
COMMON [/[cname]/] var-list [[,] /[cname]/ var-list]...
cname
Is the name of the common block. The name can be omitted for blank common (//).
var-list
Is a list of variable names, separated by commas.
The variable must not be a dummy argument, allocatable array, automatic object, function,
function result, or entry to a procedure. It must not have the PARAMETER attribute. If an object
of derived type is specified, it must be a sequence type.

Rules and Behavior

A common block is a global entity, and must not have the same name as any other global entity in
the program, such as a subroutine or function.
Any common block name (or blank common) can appear more than once in one or more
COMMON statements in a program unit. The list following each successive appearance of the
same common block name is treated as a continuation of the list for the block associated with that
name.
A variable can appear in only one common block within a scoping unit.

5-21
5 Intel Fortran Language Reference

If an array is specified, it can be followed by an explicit-shape array specification, each bound of

which must be a constant specification expression. Such an array must not have the POINTER
attribute.
A pointer can only be associated with pointers of the same type and kind parameters, and rank.
An object with the TARGET attribute can only be associated with another object with the
TARGET attribute and the same type and kind parameters.
A nonpointer can only be associated with another nonpointer, but association depends on their
types, as follows:

Type of Variable Type of Associated Variable

Intrinsic numeric1 or numeric sequence2 Can be of any of these types
Default character or character sequence2 Can be of either of these types
Any other intrinsic type Must have the same type and kind parameters
Any other sequence type Must have the same type
1. Default integer, default real, double precision real, default complex, double complex, or default logical.
2. If an object of numeric sequence or character sequence type appears in a common block, it is as if the individual components were
enumerated directly in the common list.

So, variables can be associated if they are of different numeric type. For example, the following is
valid:
INTEGER A(20)
REAL Y(20)
COMMON /QUANTA/ A, Y
When common blocks from different program units have the same name, they share the same
storage area when the units are combined into an executable program.
Entities are assigned storage in common blocks on a one-for-one basis. So, the data type of entities
assigned by a COMMON statement in one program unit should agree with the data type of entities
placed in a common block by another program unit. For example:

Program Unit A Program Unit B

COMMON CENTS INTEGER(2) MONEY
... COMMON MONEY
...

When these program units are combined into an executable program, incorrect results can occur if
the 2-byte integer variable MONEY is made to correspond to the lower-addressed two bytes of the
real variable CENTS.

5-22
 Specification Statements 5
Named common blocks must be declared to have the same size in each program unit. Blank
common can have different lengths in different program units.

NOTE. If a common block is initialized by a DATA statement, the module

containing the initialization must declare the common block to be its maximum
defined length. This limitation does not apply if you compile all source modules
together.

Examples
In the following example, the COMMON statement in the main program puts HEAT and X in
blank common, and KILO and Q in a named common block, BLK1:

Main Program Subprogram

COMMON HEAT, X /BLK1/KILO, Q SUBROUTINE FIGURE
... COMMON /BLK1/LIMA, R / /ALFA,BET
...
CALL FIGURE RETURN
... END

The COMMON statement in the subroutine makes ALFA and BET share the same storage
location as HEAT and X in blank common. It makes LIMA and R share the same storage location
as KILO and Q in BLK1.
The following example shows how a COMMON statement can be used to declare arrays:
COMMON / MIXED / SPOTTED(100), STRIPED(50,50)

See Also
• “Specification Expressions”
• “Storage Association”
• “Derived Data Types”
• “EQUIVALENCE Statement”
• “EQUIVALENCE and COMMON Interaction”
• Your user’s guide for details on alignment of data items in common blocks

5-23
5 Intel Fortran Language Reference

DATA Statement
The DATA statement assigns initial values to variables before program execution. It takes the
following form:
DATA var-list /c-list/[[,] var-list /c-list/]...
var-list
Is a list of variables or implied-DO lists, separated by commas.
Subscript expressions and expressions in substring references must be initialization expressions.
An implied-DO list in a DATA statement takes the following form:
(do-list, var = expr1, expr2 [, expr3])
do-list
Is a list of one or more array elements, substrings, scalar structure components, or implied-DO
lists, separated by commas. Any array elements or scalar structure components must not have a
constant parent.
var
Is the name of a scalar integer variable (the implied-DO variable).
expr
Are scalar integer expressions. The expressions can contain variables of other implied-DO lists
that have this implied-DO list within their ranges.
c-list
Is a list of constants (or names of constants), or for pointer objects, NULL( ); constants must be
separated by commas. If the constant is a structure constructor, each component must be an
initialization expression. If the constant is in binary, octal, or hexadecimal form, the corresponding
object must be of type integer.
A constant can be specified in the form r*constant, where r is a repeat specification. It is a
nonnegative scalar integer constant (with no kind parameter). If it is a named constant, it must
have been declared previously in the scoping unit or made accessible through use or host
association. If r is omitted, it is assumed to be 1.

Rules and Behavior

A variable can be initialized only once in an executable program. A variable that appears in a
DATA statement and is typed implicitly can appear in a subsequent type declaration only if that
declaration confirms the implicit typing.
The number of constants in c-list must equal the number of variables in var-list. The constants are
assigned to the variables in the order in which they appear (from left to right).

5-24
 Specification Statements 5
The following objects cannot be initialized in a DATA statement:
• A dummy argument
• A function
• A function result
• An automatic object
• An allocatable array
• A variable that is accessible by use or host association
• A variable in a named common block (unless the DATA statement is in a block data program
unit)
• A variable in blank common
Except for variables in named COMMON blocks, a named variable has the SAVE attribute if any
part of it is initialized in a DATA statement. You can confirm this property by specifying the
variable in a SAVE statement or a type declaration statement containing the SAVE attribute.
When an unsubscripted array name appears in a DATA statement, values are assigned to every
element of that array in the order of subscript progression. The associated constant list must
contain enough values to fill the array.
Array element values can be initialized in three ways: by name, by element, or by an implied-DO
list (interpreted in the same way as a DO construct).
The following conversion rules and restrictions apply to variable and constant list items:
• If the constant and the variable are both of numeric type, the following conversion occurs:
— The constant value is converted to the data type of the variable being initialized, if
necessary.
— When a binary, octal, or hexadecimal constant is assigned to a variable or array element,
the number of digits that can be assigned depends on the data type of the data item. If the
constant contains fewer digits than the capacity of the variable or array element, the
constant is extended on the left with zeros. If the constant contains more digits than can
be stored, the constant is truncated on the left.
• If the constant and the variable are both of character type, the following conversion occurs:
— If the length of the constant is less than the length of the variable, the rightmost character
positions of the variable are initialized with blank characters.
— If the length of the constant is greater than the length of the variable, the character
constant is truncated on the right.
• If the constant is of numeric type and the variable is of character type, the following
restrictions apply:
— The character variable must have a length of one character.

5-25
5 Intel Fortran Language Reference

— The constant must be an integer, binary, octal, or hexadecimal constant, and must have a
value in the range 0 through 255.
When the constant and variable conform to these restrictions, the variable is initialized with
the character that has the ASCII code specified by the constant. (This lets you initialize a
character object to any 8-bit ASCII code.)
• If the constant is a Hollerith or character constant, and the variable is a numeric variable or
numeric array element, the number of characters that can be assigned depends on the data
type of the data item.
If the Hollerith or character constant contains fewer characters than the capacity of the
variable or array element, the constant is extended on the right with blank characters. If the
constant contains more characters than can be stored, the constant is truncated on the right.

Examples
The following example shows the three ways that DATA statements can initialize array element
values:
DIMENSION A(10,10)
DATA A/100*1.0/ ! initialization by name
DATA A(1,1), A(10,1), A(3,3) /2*2.5, 2.0/ ! initialization by element
DATA ((A(I,J), I=1,5,2), J=1,5) /15*1.0/ ! initialization by implied-DO list
The following example shows DATA statements containing structure components:
TYPE EMPLOYEE
INTEGER ID
CHARACTER(LEN=40) NAME
END TYPE EMPLOYEE
TYPE(EMPLOYEE) MAN_NAME, CON_NAME
DATA MAN_NAME / EMPLOYEE(417, ’Henry Adams’) /
DATA CON_NAME%ID, CON_NAME%NAME /891, "David James "/
In the following example, the first DATA statement assigns zero to all 10 elements of array A, and
four asterisks followed by two blanks to the character variable STARS:
INTEGER A(10), B(10)
CHARACTER BELL, TAB, LF, FF, STARS*6
DATA A,STARS /10*0,’****’/
DATA BELL,TAB,LF,FF /7,9,10,12/
DATA (B(I), I=1,10,2) /5*1/
In this case, the second DATA statement assigns ASCII control character codes to the character
variables BELL, TAB, LF, and FF. The last DATA statement uses an implied-DO list to assign the
value 1 to the odd-numbered elements in the array B.

5-26
 Specification Statements 5
As a Fortran 95 feature, a pointer can be initialized as disassociated by using a DATA statement.
For example:
INTEGER, POINTER :: P
DATA P/NULL( )/
END

See Also
• “Initialization and Specification Expressions”
• “Type Declaration Statements”
• “I/O Lists” for details on implied-DO lists

DIMENSION Attribute and Statement

The DIMENSION attribute specifies that an object is an array, and defines the shape of the array.
The DIMENSION attribute can be specified in a type declaration statement or a DIMENSION
statement, and takes one of the following forms:
Type Declaration Statement:
type, [att-ls,] DIMENSION (a-spec) [, att-ls] :: a[(a-spec)] [, a[(a-spec)]]...
Statement:
DIMENSION [::] a(a-spec) [, a(a-spec)]...
type
Is a data type specifier.
att-ls
Is an optional list of attribute specifiers.
a-spec
Is an array specification.
In a type declaration statement, any array specification following an array overrides any array
specification following DIMENSION.
a
Is the name of the array being declared.

Rules and Behavior

The DIMENSION attribute allocates a number of storage elements to each array named, one
storage element to each array element in each dimension. The size of each storage element is
determined by the data type of the array.

5-27
5 Intel Fortran Language Reference

The total number of storage elements assigned to an array is equal to the number produced by
multiplying together the number of elements in each dimension in the array specification. For
example, the following statement defines ARRAY as having 16 real elements of 4 bytes each and
defines MATRIX as having 125 integer elements of 4 bytes each:
DIMENSION ARRAY(4,4), MATRIX(5,5,5)
An array can also be declared in the following statements: ALLOCATABLE, POINTER,
TARGET, and COMMON.

Examples
The following examples show type declaration statements specifying the DIMENSION attribute:
REAL, DIMENSION(10, 10) :: A, B, C(10, 15) ! Specification following C
! overrides the one following
! DIMENSION
REAL, ALLOCATABLE, DIMENSION(:) :: E
The following are examples of the DIMENSION statement:
DIMENSION BOTTOM(12,24,10)
DIMENSION X(5,5,5), Y(4,85), Z(100)
DIMENSION MARK(4,4,4,4)
SUBROUTINE APROC(A1,A2,N1,N2,N3)
DIMENSION A1(N1:N2), A2(N3:*)

CHARACTER(LEN = 20) D
DIMENSION A(15), B(15, 40), C(-5:8, 7), D(15)

See Also
• “Type Declaration Statements”
• “Arrays”
• “ALLOCATABLE Attribute and Statement”
• “COMMON Statement”
• “POINTER Attribute and Statement”
• “TARGET Attribute and Statement”
• “Declaration Statements for Arrays” for details on array specifications
• Table 5-1 for details on compatible attributes

5-28
 Specification Statements 5
EQUIVALENCE Statement
The EQUIVALENCE statement specifies that a storage area is shared by two or more objects in a
program unit. This causes total or partial storage association of the objects that share the storage
area.
The EQUIVALENCE statement takes the following form:
EQUIVALENCE (equiv-list) [, (equiv-list)]...
equiv-list
Is a list of two or more variables, array elements, or substrings, separated by commas (also called
an equivalence set). If an object of derived type is specified, it must be a sequence type. Objects
cannot have the TARGET attribute.
Each expression in a subscript or a substring reference must be an integer initialization expression.
A substring must not have a length of zero.

Rules and Behavior

The following objects cannot be specified in EQUIVALENCE statements:
• A dummy argument
• An allocatable array
• A pointer
• An object of nonsequence derived type
• An object of sequence derived type containing a pointer in the structure
• A function, entry, or result name
• A named constant
• A structure component
• A subobject of any of the above objects
The EQUIVALENCE statement causes all of the entities in one parenthesized list to be allocated
storage beginning at the same storage location.
Association of objects depends on their types, as follows:

Type of Object Type of Associated Object

Intrinsic numeric1 or numeric sequence Can be of any of these types
Default character or character sequence Can be of either of these types2
Any other intrinsic type Must have the same type and kind parameters

5-29
5 Intel Fortran Language Reference

Type of Object Type of Associated Object

Any other sequence type Must have the same type
1. Default integer, default real, double precision real, default complex, double complex, or default logical.
2. The lengths do not have to be equal.

So, objects can be associated if they are of different numeric type. For example, the following is
valid:
INTEGER A(20)
REAL Y(20)
EQUIVALENCE(A, Y)
Objects of default character do not need to have the same length. The following example
associates character variable D with the last 4 (of the 6) characters of character array F:
CHARACTER(LEN=4) D
CHARACTER(LEN=3) F(2)
EQUIVALENCE(D, F(1)(3:))
Entities having different data types can be associated because multiple components of one data
type can share storage with a single component of a higher-ranked data type. For example, if you
make an integer variable equivalent to a complex variable, the integer variable shares storage with
the real part of the complex variable.
The same storage unit cannot occur more than once in a storage sequence, and consecutive storage
units cannot be specified in a way that would make them nonconsecutive.

Examples
The following EQUIVALENCE statement is invalid because it specifies the same storage unit for
X(1) and X(2):
REAL, DIMENSION(2), :: X
REAL :: Y
EQUIVALENCE(X(1), Y), (X(2), Y)
The following EQUIVALENCE statement is invalid because A(1) and A(2) will not be
consecutive:
REAL A(2)
DOUBLE PRECISION D(2)
EQUIVALENCE(A(1), D(1)), (A(2), D(2))
In the following example, the EQUIVALENCE statement causes the four elements of the integer
array IARR to share the same storage as that of the double-precision variable DVAR.
DOUBLE PRECISION DVAR

5-30
 Specification Statements 5
INTEGER(KIND=2) IARR(4)
EQUIVALENCE(DVAR, IARR(1))
In the following example, the EQUIVALENCE statement causes the first character of the
character variables KEY and STAR to share the same storage location. The character variable
STAR is equivalent to the substring KEY(1:10).
CHARACTER KEY*16, STAR*10
EQUIVALENCE(KEY, STAR)

See Also
• “Initialization Expressions”
• “Derived Data Types”
• “Storage Association” for details on storage units, sequence, and association

Making Arrays Equivalent

When you make an element of one array equivalent to an element of another array, the
EQUIVALENCE statement also sets equivalences between the other elements of the two arrays.
Thus, if the first elements of two equal-sized arrays are made equivalent, both arrays share the
same storage. If the third element of a 7-element array is made equivalent to the first element of
another array, the last five elements of the first array overlap the first five elements of the second
array.
Two or more elements of the same array should not be associated with each other in one or more
EQUIVALENCE statements. For example, you cannot use an EQUIVALENCE statement to
associate the first element of one array with the first element of another array, and then attempt to
associate the fourth element of the first array with the seventh element of the other array.
Consider the following valid example:
DIMENSION TABLE (2,2), TRIPLE (2,2,2)
EQUIVALENCE(TABLE(2,2), TRIPLE(1,2,2))
These statements cause the entire array TABLE to share part of the storage allocated to TRIPLE.
Table 5-3 shows how these statements align the arrays:

Table 5-3 Equivalence of Array Storage

Array TRIPLE Array TABLE
Array Elements Element Number Array Element Element Number
TRIPLE(1,1,1) 1
TRIPLE(2,1,1) 2
TRIPLE(1,2,1) 3

5-31
5 Intel Fortran Language Reference

Table 5-3 Equivalence of Array Storage

Array TRIPLE Array TABLE
Array Elements Element Number Array Element Element Number
TRIPLE(2,2,1) 4 TABLE(1,1) 1
TRIPLE(1,1,2) 5 TABLE(2,1) 2
TRIPLE(2,1,2) 6 TABLE(1,2) 3
TRIPLE(1,2,2) 7 TABLE(2,2) 4
TRIPLE(2,2,2) 8

Each of the following statements also aligns the two arrays as shown in Table 5-3:
EQUIVALENCE(TABLE, TRIPLE(2,2,1))
EQUIVALENCE(TRIPLE(1,1,2), TABLE(2,1))
You can also make arrays equivalent with nonunity lower bounds. For example, an array defined
as A(2:3,4) is a sequence of eight values. A reference to A(2,2) refers to the third element in the
sequence. To make array A(2:3,4) share storage with array B(2:4,4), you can use the following
statement:
EQUIVALENCE(A(3,4), B(2,4))
The entire array A shares part of the storage allocated to array B. Table 5-4 shows how these
statements align the arrays. The arrays can also be aligned by the following statements:
EQUIVALENCE(A, B(4,1)) EQUIVALENCE(B(3,2), A(2,2))

Table 5-4 Equivalence of Arrays with Nonunity Lower Bounds

Array B Array A
Array Element Element Number Array Element Element Number
B(2,1) 1
B(3,1) 2
B(4,1) 3 A(2,1) 1
B(2,2) 4 A(3,1) 2
B(3,2) 5 A(2,2) 3
B(4,2) 6 A(3,2) 4
B(2,3) 7 A(2,3) 5
B(3,3) 8 A(3,3) 6
B(4,3) 9 A(2,4) 7
B(2,4) 10 A(3,4) 8
B(3,4) 11

5-32
 Specification Statements 5
Table 5-4 Equivalence of Arrays with Nonunity Lower Bounds
Array B Array A
Array Element Element Number Array Element Element Number
B(4,4) 12

Only in the EQUIVALENCE statement can you identify an array element with a single subscript
(the linear element number), even though the array was defined as multidimensional. For example,
the following statements align the two arrays as shown in Table 5-4:
DIMENSION B(2:4,1:4), A(2:3,1:4)
EQUIVALENCE(B(6), A(4))

Making Substrings Equivalent

When you make one character substring equivalent to another character substring, the
EQUIVALENCE statement also sets associations between the other corresponding characters in
the character entities; for example:
CHARACTER NAME*16, ID*9
EQUIVALENCE(NAME(10:13), ID(2:5))
These statements cause character variables NAME and ID to share space (see Figure 5-1). The
arrays can also be aligned by the following statement:
EQUIVALENCE(NAME(9:9), ID(1:1))

5-33
5 Intel Fortran Language Reference

Figure 5-1 Equivalence of Substrings

NAME
Character
Position
1
2
3
4
5
6
ID
7
Character
8 Position
9 1
10 2
11 3
12 4
13 5
14 6
15 7
16 8
9

ZK−0618−GE

If the character substring references are array elements, the EQUIVALENCE statement sets
associations between the other corresponding characters in the complete arrays.
Character elements of arrays can overlap at any character position. For example, the following
statements cause character arrays FIELDS and STAR to share storage (see Figure 5-2).

5-34
 Specification Statements 5
CHARACTER FIELDS(100)*4, STAR(5)*5
EQUIVALENCE(FIELDS(1)(2:4), STAR(2)(3:5))
The EQUIVALENCE statement cannot assign the same storage location to two or more substrings
that start at different character positions in the same character variable or character array. The
EQUIVALENCE statement also cannot assign memory locations in a way that is inconsistent with
the normal linear storage of character variables and arrays.

EQUIVALENCE and COMMON Interaction

A common block can extend beyond its original boundaries if variables or arrays are associated
with entities stored in the common block. However, a common block can only extend beyond its
last element; the extended portion cannot precede the first element in the block.

Examples
Figure 5-3 and Figure 5-4 show valid and invalid extensions of the common block, respectively.

5-35
5 Intel Fortran Language Reference

Figure 5-2 Equivalence of Character Arrays

STAR

Character Subscript
Position
1 1
2
3
FIELDS
4
5
Subscript Character
Position 1 2
1 1 2
2 3
3 4
4 5
2 1 1 3
2 2
3 3
4 4
3 1 5
2 1 4
3 2
4 3
4 1 4
2 5
3 1 5
4 2
5 1 3
2 4
3 5
4
6 1
2
3
4
7 1
2

100 1
2
3
4

ZK−0619−GE

5-36
 Specification Statements 5
Figure 5-3 A Valid Extension of a Common Block

Valid

DIMENSION A (4), B (6) A (1) A (2) A (3) A (4)

COMMON A
EQUIVALENCE (A (2), B (1)) B (1) B (2) B (3) B (4) B (5) B (6)

Existing Extended
Common Portion
ZK−1944−GE

Figure 5-4 An Invalid Extension of a Common Block

Invalid
DIMENSION A (4), B (6) A (1) A (2) A (3) A (4)
COMMON A
EQUIVALENCE (A (2), B (3)) B (1) B (2) B (3) B (4) B (5) B (6)

Extended Existing Extended

Portion Common Portion
ZK−1945−GE

The second example is invalid because the extended portion, B(1), precedes the first element of
the common block.
The following example shows a valid EQUIVALENCE statement and an invalid EQUIVALENCE
statement in the context of a common block.
COMMON A, B, C
DIMENSION D(3)
EQUIVALENCE(B, D(1)) ! Valid, because common block is extended
! from the end.

5-37
5 Intel Fortran Language Reference

COMMON A, B, C
DIMENSION D(3)
EQUIVALENCE(B, D(3)) ! Invalid, because D(1) would extend common
! block to precede A’s location.

EXTERNAL Attribute and Statement

The EXTERNAL attribute allows an external or dummy procedure to be used as an actual
argument. (To specify intrinsic procedures as actual arguments, use the INTRINSIC attribute.)
The EXTERNAL attribute can be specified in a type declaration statement or an EXTERNAL
statement, and takes one of the following forms:
Type Declaration Statement:
type, [att-ls,] EXTERNAL [, att-ls] :: ex-pro [, ex-pro]...
Statement:
EXTERNAL ex-pro [, ex-pro]...
type
Is a data type specifier.
att-ls
Is an optional list of attribute specifiers.
ex-pro
Is the name of an external (user-supplied) procedure or dummy procedure.

Rules and Behavior

In a type declaration statement, only functions can be declared EXTERNAL. However, you can
use the EXTERNAL statement to declare subroutines and block data program units, as well as
functions, to be external.
The name declared EXTERNAL is assumed to be the name of an external procedure, even if the
name is the same as that of an intrinsic procedure. For example, if SIN is declared with the
EXTERNAL attribute, all subsequent references to SIN are to a user-supplied function named
SIN, not to the intrinsic function of the same name.
You can include the name of a block data program unit in the EXTERNAL statement to force a
search of the object module libraries for the block data program unit at link time. However, the
name of the block data program unit must not be used in a type declaration statement.

5-38
 Specification Statements 5
Examples
The following example shows type declaration statements specifying the EXTERNAL attribute:
PROGRAM TEST
...
INTEGER, EXTERNAL :: BETA
LOGICAL, EXTERNAL :: COS
...
CALL SUB(BETA) ! External function BETA is an actual argument
You can use a name specified in an EXTERNAL statement as an actual argument to a subprogram,
and the subprogram can then use the corresponding dummy argument in a function reference or a
CALL statement; for example:
EXTERNAL FACET
CALL BAR(FACET)

SUBROUTINE BAR(F)
EXTERNAL F
CALL F(2)
Used as an argument, a complete function reference represents a value, not a subprogram; for
example, FUNC(B) represents a value in the following statement:
CALL SUBR(A, FUNC(B), C)

See Also
• “Type Declaration Statements”
• Chapter 9, “Intrinsic Procedures”
• “INTRINSIC Attribute and Statement”
• Table 5-1 for details on compatible attributes

IMPLICIT Statement
The IMPLICIT statement overrides the default implicit typing rules for names. (The default data
type is INTEGER for names beginning with the letters I through N, and REAL for names
beginning with any other letter.)
The IMPLICIT statement takes one of the following forms:
IMPLICIT type (a[, a]...)[, type (a[, a]...)]...
IMPLICIT NONE

5-39
5 Intel Fortran Language Reference

type
Is a data type specifier (CHARACTER*(*) is not allowed).
a
Is a single letter, a dollar sign ($), or a range of letters in alphabetical order. The form for a range
of letters is a1-a2, where the second letter follows the first alphabetically (for example, A-C).
The dollar sign can be used at the end of a range of letters, since IMPLICIT interprets the dollar
sign to alphabetically follow the letter Z. For example, a range of X–$ would apply to identifiers
beginning with the letters X, Y, Z, or $.

Rules and Behavior

The IMPLICIT statement assigns the specified data type (and kind parameter) to all names that
have no explicit data type and begin with the specified letter or range of letters. It has no effect on
the default types of intrinsic procedures.
When the data type is CHARACTER*len, len is the length for character type. The len is an
unsigned integer constant or an integer initialization expression enclosed in parentheses. The
range for len is 1 to 2**31–1 on IA-32 processors; 1 to 2**63–1 on Intel Itanium processors.
Names beginning with a dollar sign ($) are implicitly INTEGER.
The IMPLICIT NONE statement disables all implicit typing defaults. When IMPLICIT NONE is
used, all names in a program unit must be explicitly declared. An IMPLICIT NONE statement
must precede any PARAMETER statements, and there must be no other IMPLICIT statements in
the scoping unit.

NOTE. To receive diagnostic messages when variables are used but not
declared, you can specify a compiler option instead of using IMPLICIT NONE.

The following IMPLICIT statement represents the default typing for names when they are not
explicitly typed:
IMPLICIT INTEGER (I-N), REAL (A-H, O-Z)

Examples
The following are examples of the IMPLICIT statement:
IMPLICIT DOUBLE PRECISION (D)
IMPLICIT COMPLEX (S,Y), LOGICAL(1) (L,A-C)
IMPLICIT CHARACTER*32 (T-V)
IMPLICIT CHARACTER*2 (W)

5-40
 Specification Statements 5
IMPLICIT TYPE(COLORS) (E-F), INTEGER (G-H)

See Also
Your user’s guide for details on compiler options

INTENT Attribute and Statement

The INTENT attribute specifies the intended use of one or more dummy arguments.
The INTENT attribute can be specified in a type declaration statement or an INTENT statement,
and takes one of the following forms:
Type Declaration Statement:
type, [att-ls,] INTENT (intent-spec) [, att-ls] :: d-arg [, d-arg]...
Statement:
INTENT (intent-spec) [::] d-arg [, d-arg]...
type
Is a data type specifier.
att-ls
Is an optional list of attribute specifiers.
intent-spec
Is one of the following specifiers:
• IN
Specifies that the dummy argument will be used only to provide data to the procedure. The
dummy argument must not be redefined (or become undefined) during execution of the
procedure.
Any associated actual argument must be an expression.
• OUT
Specifies that the dummy argument will be used to pass data from the procedure back to the
calling program. The dummy argument is undefined on entry and must be defined before it is
referenced in the procedure.
Any associated actual argument must be definable.
• INOUT
Specifies that the dummy argument can both provide data to the procedure and return data to
the calling program.
Any associated actual argument must be definable.

5-41
5 Intel Fortran Language Reference

d-arg
Is the name of a dummy argument. It cannot be a dummy procedure or dummy pointer.

Rules and Behavior

The INTENT statement can only appear in the specification part of a subprogram or interface
body.
If no INTENT attribute is specified for a dummy argument, its use is subject to the limitations of
the associated actual argument.
If a function specifies a defined operator, the dummy arguments must have intent IN.
If a subroutine specifies defined assignment, the first argument must have intent OUT or INOUT,
and the second argument must have intent IN.
A dummy argument with intent IN (or a subobject of such a dummy argument) must not appear as
any of the following:
• A DO variable or implied-DO variable
• The variable of an assignment statement
• The pointer-object of a pointer assignment statement
• An object or STAT variable in an ALLOCATE or DEALLOCATE statement
• An input item in a READ statement
• A variable name in a NAMELIST statement if the namelist group name appears in a NML
specifier in a READ statement
• An internal file unit in a WRITE statement
• A definable variable in an INQUIRE statement
• An IOSTAT or SIZE specifier in an I/O statement
• An actual argument in a reference to a procedure with an explicit interface if the associated
dummy argument has intent OUT or INOUT
If an actual argument is an array section with a vector subscript, it cannot be associated with a
dummy array that is defined or redefined (has intent OUT or INOUT).

Examples
The following example shows type declaration statements specifying the INTENT attribute:
SUBROUTINE TEST(I, J)
INTEGER, INTENT(IN) :: I
INTEGER, INTENT(OUT), DIMENSION(I) :: J
The following are examples of the INTENT statement:
SUBROUTINE TEST(A, B, X)

5-42
 Specification Statements 5
INTENT(INOUT) :: A, B
...
SUBROUTINE CHANGE(FROM, TO)
USE EMPLOYEE_MODULE
TYPE(EMPLOYEE) FROM, TO
INTENT(IN) FROM
INTENT(OUT) TO
...

See Also
• “Type Declaration Statements”
• “Argument Association”
• Table 5-1 for details on compatible attributes

INTRINSIC Attribute and Statement

The INTRINSIC attribute allows the specific name of an intrinsic procedure to be used as an
actual argument. (Not all specific names can be used as actual arguments. For more information,
see Table 9-1.)
The INTRINSIC attribute can be specified in a type declaration statement or an INTRINSIC
statement, and takes one of the following forms:
Type Declaration Statement:
type, [att-ls,] INTRINSIC [, att-ls] :: in-pro [, in-pro]...
Statement:
INTRINSIC in-pro [, in-pro]...
type
Is a data type specifier.
att-ls
Is an optional list of attribute specifiers.
in-pro
Is the name of an intrinsic procedure.

Rules and Behavior

In a type declaration statement, only functions can be declared INTRINSIC. However, you can use
the INTRINSIC statement to declare subroutines, as well as functions, to be intrinsic.

5-43
5 Intel Fortran Language Reference

The name declared INTRINSIC is assumed to be the name of an intrinsic procedure. If a generic
intrinsic function name is given the INTRINSIC attribute, the name retains its generic properties.

Examples
The following example shows a type declaration statement specifying the INTRINSIC attribute:
PROGRAM EXAMPLE
...
REAL(8), INTRINSIC :: DACOS
...
CALL TEST(X, DACOS) ! Intrinsic function DACOS is an actual argument
The following example shows an INTRINSIC statement:

Main Program Subprogram

EXTERNAL CTN SUBROUTINE TRIG(X,F,Y)
INTRINSIC SIN, COS Y = F(X)
... RETURN
END
CALL TRIG(ANGLE,SIN,SINE)
... FUNCTION CTN(X)
CTN = COS(X)/SIN(X)
CALL TRIG(ANGLE,COS, COSINE) RETURN
... END
CALL TRIG(ANGLE,CTN,COTANGENT)

Note that when TRIG is called with a second argument of SIN or COS, the function reference
F(X) references the Fortran 95/90 library functions SIN and COS; but when TRIG is called with a
second argument of CTN, F(X) references the user function CTN.

See Also
• “Type Declaration Statements”
• “References to Generic Intrinsic Functions”
• “References to Elemental Intrinsic Procedures”
• Chapter 9, “Intrinsic Procedures”, for details on specific intrinsic procedures
• Table 5-1 for details on compatible attributes

5-44
 Specification Statements 5
NAMELIST Statement
The NAMELIST statement associates a name with a list of variables. This group name can be
referenced in some input/output operations.
A NAMELIST statement takes the following form:
NAMELIST /group/var-list [[,] /group/var-list]...
group
Is the name of the group.
var-list
Is a list of variables (separated by commas) that are to be associated with the preceding group
name. The variables can be of any data type.

Rules and Behavior

The namelist group name is used by namelist I/O statements instead of an I/O list. The unique
group name identifies a list whose entities can be modified or transferred.
A variable can appear in more than one namelist group.
Each variable in var-list must be accessed by use or host association, or it must have its type, type
parameters, and shape explicitly or implicitly specified in the same scoping unit. If the variable is
implicitly typed, it can appear in a subsequent type declaration only if that declaration confirms
the implicit typing.
The following variables cannot be specified in a namelist group:
• An array dummy argument with nonconstant bounds
• A variable with assumed character length
• An allocatable array
• An automatic object
• A pointer
• A variable of a type that has a pointer as an ultimate component
• A subobject of any of the above objects
Only the variables specified in the namelist can be read or written in namelist I/O. It is not
necessary for the input records in a namelist input statement to define every variable in the
associated namelist.
The order of variables in the namelist controls the order in which the values appear on namelist
output. Input of namelist values can be in any order.
If the group name has the PUBLIC attribute, no item in the variable list can have the PRIVATE
attribute.

5-45
5 Intel Fortran Language Reference

The group name can be specified in more than one NAMELIST statement in a scoping unit. The
variable list following each successive appearance of the group name is treated as a continuation
of the list for that group name.

Examples
In the following example, D and E are added to the variables A, B, and C for group name LIST:
NAMELIST /LIST/ A, B, C
NAMELIST /LIST/ D, E
In the following example, two group names are defined:
CHARACTER*30 NAME(25)
NAMELIST /INPUT/ NAME, GRADE, DATE /OUTPUT/ TOTAL, NAME
Group name INPUT contains variables NAME, GRADE, and DATE. Group name OUTPUT
contains variables TOTAL and NAME.

See Also
• “Rules for Namelist Sequential READ Statements” for details on namelist input
• “Rules for Namelist Sequential WRITE Statements” for details on namelist output

OPTIONAL Attribute and Statement

The OPTIONAL attribute permits dummy arguments to be omitted in a procedure reference.
The OPTIONAL attribute can be specified in a type declaration statement or an OPTIONAL
statement, and takes one of the following forms:
Type Declaration Statement:
type, [att-ls,] OPTIONAL [, att-ls] :: d-arg [, d-arg]...
Statement:
OPTIONAL [::] d-arg [, d-arg]...
type
Is a data type specifier.
att-ls
Is an optional list of attribute specifiers.
d-arg
Is the name of a dummy argument.

5-46
 Specification Statements 5
Rules and Behavior
The OPTIONAL attribute can only appear in the scoping unit of a subprogram or an interface
body, and can only be specified for dummy arguments.
A dummy argument is "present " if it associated with an actual argument. A dummy argument that
is not optional must be present. You can use the PRESENT intrinsic function to determine whether
an optional dummy argument is associated with an actual argument.
To call a procedure that has an optional argument, you must use an explicit interface.

Examples
The following example shows a type declaration statement specifying the OPTIONAL attribute:
SUBROUTINE TEST(A)
REAL, OPTIONAL, DIMENSION(-10:2) :: A
END SUBROUTINE
The following is an example of the OPTIONAL statement:
SUBROUTINE TEST(A, B, L, X)
OPTIONAL :: B
INTEGER A, B, L, X
IF (PRESENT(B)) THEN ! Printing of B is conditional
PRINT *, A, B, L, X ! on its presence
ELSE
PRINT *, A, L, X
ENDIF
END SUBROUTINE
INTERFACE
SUBROUTINE TEST(ONE, TWO, THREE, FOUR)
INTEGER ONE, TWO, THREE, FOUR
OPTIONAL :: TWO
END SUBROUTINE
END INTERFACE

INTEGER I, J, K, L
I = 1
J = 2
K = 3
L = 4

CALL TEST(I, J, K, L) ! Prints: 1 2 3 4

CALL TEST(I, THREE=K, FOUR=L) ! Prints: 1 3 4 END

5-47
5 Intel Fortran Language Reference

Note that in the second call to subroutine TEST, the second positional (optional) argument is
omitted. In this case, all following arguments must be keyword arguments.

See Also
• “Type Declaration Statements”
• “PRESENT”
• “Optional Arguments”
• Table 5-1 for details on compatible attributes

PARAMETER Attribute and Statement

The PARAMETER attribute defines a named constant.
The PARAMETER attribute can be specified in a type declaration statement or a PARAMETER
statement, and takes one of the following forms:
Type Declaration Statement:
type, [att-ls,] PARAMETER [, att-ls] :: c = expr [, c = expr]...
Statement:
PARAMETER [(] c = expr [, c = expr]...[)]
type
Is a data type specifier.
att-ls
Is an optional list of attribute specifiers.
c
Is the name of the constant.
expr
Is an initialization expression. It can be of any data type.

Rules and Behavior

The type, type parameters, and shape of the named constant are determined in one of the following
ways:
• By an explicit type declaration statement in the same scoping unit.
• By the implicit typing rules in effect for the scoping unit. If the named constant is implicitly
typed, it can appear in a subsequent type declaration only if that declaration confirms the
implicit typing.

5-48
 Specification Statements 5
For example, consider the following statement:
PARAMETER (MU=1.23)
According to implicit typing, MU is of integer type, so MU=1. For MU to equal 1.23, it should
previously be declared REAL in a type declaration or be declared in an IMPLICIT statement.
A named constant must not appear in a format specification or as the character count for Hollerith
constants. For compilation purposes, writing the name is the same as writing the value.
If the named constant is used as the length specifier in a CHARACTER declaration, it must be
enclosed in parentheses.
The name of a constant cannot appear as part of another constant, although it can appear as either
the real or imaginary part of a complex constant.
You can only use the named constant within the scoping unit containing the defining
PARAMETER statement.
Any named constant that appears in the initialization expression must have been defined
previously in the same type declaration statement (or in a previous type declaration statement or
PARAMETER statement), or made accessible by use or host association.

Examples
The following example shows a type declaration statement specifying the PARAMETER attribute:
REAL, PARAMETER :: C = 2.9979251, Y = (4.1 / 3.0)
The following is an example of the PARAMETER statement:
REAL(4) PI, PIOV2
REAL(8) DPI, DPIOV2
LOGICAL FLAG
CHARACTER*(*) LONGNAME

PARAMETER (PI=3.1415927, DPI=3.141592653589793238D0)

PARAMETER (PIOV2=PI/2, DPIOV2=DPI/2)
PARAMETER (FLAG=.TRUE., LONGNAME=’A STRING OF 25 CHARACTERS’)

See Also
• “Type Declaration Statements”
• “Initialization Expressions”
• “IMPLICIT Statement”
• “Alternative Syntax for the PARAMETER Statement”
• Table 5-1 for details on compatible attributes

5-49
5 Intel Fortran Language Reference

POINTER Attribute and Statement

The POINTER attribute specifies that an object is a pointer (a dynamic variable). A pointer does
not contain data, but points to a scalar or array variable where data is stored. A pointer has no
initial storage set aside for it; memory storage is created for the pointer as a program runs.
The POINTER attribute can be specified in a type declaration statement or a POINTER statement,
and takes one of the following forms:
Type Declaration Statement:
type, [att-ls,] POINTER [, att-ls] :: ptr [(d-spec)] [, ptr [(d-spec)]]...
Statement:
POINTER [::] ptr [(d-spec)] [, ptr [(d-spec)]]...
type
Is a data type specifier.
att-ls
Is an optional list of attribute specifiers.
ptr
Is the name of the pointer. The pointer cannot be declared with the INTENT or PARAMETER
attributes.
d-spec
Is a deferred-shape specification (: [,:]...). Each colon represents a dimension of the array.

Rules and Behavior

No storage space is created for a pointer until it is allocated with an ALLOCATE statement or until
it is assigned to a allocated target. A pointer must not be referenced or defined until memory is
associated with it.
Each pointer has an association status, which tells whether the pointer is currently associated with
a target object. When a pointer is initially declared, its status is undefined. You can use the
ASSOCIATED intrinsic function to find the association status of a pointer.
If the pointer is an array, and it is given the DIMENSION attribute elsewhere in the program, it
must be declared as a deferred-shape array.
A pointer cannot be specified in a DATA, EQUIVALENCE, or NAMELIST statement.
Fortran 95/90 pointers are not the same as integer pointers. For more information, see the
“Integer POINTER Statement”.

5-50
 Specification Statements 5
Examples
The following example shows type declaration statements specifying the POINTER attribute:
TYPE(SYSTEM), POINTER :: CURRENT, LAST
REAL, DIMENSION(:,:), POINTER :: I, J, REVERSE
The following is an example of the POINTER statement:
TYPE(SYSTEM) :: TODAYS
POINTER :: TODAYS, A(:,:)

See Also
• “Type Declaration Statements”
• “Pointer Assignments”
• “ALLOCATE Statement”
• “Pointer Association”
• “Pointer Arguments”
• “ASSOCIATED”
• “Deferred-Shape Specifications” for details on deferred-shape arrays
• “NULL”, which can be used to disassociate a pointer
• Table 5-1 for details on compatible attributes

PRIVATE and PUBLIC Attributes and Statements

The PRIVATE and PUBLIC attributes specify the accessibility of entities in a module. (These
attributes are also called accessibility attributes.)
The PRIVATE and PUBLIC attributes can be specified in a type declaration statement or a
PRIVATE or PUBLIC statement, and take one of the following forms:
Type Declaration Statement:
type, [att-ls,] PRIVATE [, att-ls] :: entity [, entity]...
type, [att-ls,] PUBLIC [, att-ls] :: entity [, entity]...
Statement:
PRIVATE [[::] entity [, entity]...]
PUBLIC [[::] entity [, entity]...]
type
Is a data type specifier.
att-ls
Is an optional list of attribute specifiers.

5-51
5 Intel Fortran Language Reference

entity
Is one of the following:
• A variable name
• A procedure name
• A derived type name
• A named constant
• A namelist group name
In statement form, an entity can also be a generic identifier (a generic name, defined operator, or
defined assignment).

Rules and Behavior

The PRIVATE and PUBLIC attributes can only appear in the scoping unit of a module.
Only one PRIVATE or PUBLIC statement without an entity list is permitted in the scoping unit of
a module; it sets the default accessibility of all entities in the module.
If no PUBLIC or PRIVATE statements are specified in a module, the default is PUBLIC
accessibility. Entities with PUBLIC accessibility can be accessed from outside the module by
means of a USE statement.
If a derived type is declared PRIVATE in a module, its components are also PRIVATE. The
derived type and its components are accessible to any subprograms within the defining module
through host association, but they are not accessible from outside the module.
If the derived type is declared PUBLIC in a module, but its components are declared PRIVATE,
any scoping unit accessing the module though use association (or host association) can access the
derived-type definition, but not its components.
If a module procedure has a dummy argument or a function result of a type that has PRIVATE
accessibility, the module procedure must have PRIVATE accessibility. If the module has a generic
identifier, it must also be declared PRIVATE.
If a procedure has a generic identifier, the accessibility of the procedure’s specific name is
independent of the accessibility of its generic identifier. One can be declared PRIVATE and the
other PUBLIC.

Examples
The following examples show type declaration statements specifying the PUBLIC and PRIVATE
attributes:
REAL, PRIVATE :: A, B, C
INTEGER, PUBLIC :: LOCAL_SUMS
The following is an example of the PUBLIC and PRIVATE statements:

5-52
 Specification Statements 5
MODULE SOME_DATA
REAL ALL_B
PUBLIC ALL_B
TYPE RESTRICTED_DATA
REAL LOCAL_C
DIMENSION LOCAL_C(50)
END TYPE RESTRICTED_DATA
PRIVATE RESTRICTED_DATA
END MODULE
The following derived-type declaration statement indicates that the type is restricted to the
module:
TYPE, PRIVATE :: DATA
...
END TYPE DATA
The following example shows a PUBLIC type with PRIVATE components:
MODULE MATTER
TYPE ELEMENTS
PRIVATE
INTEGER C, D
END TYPE
...
END MODULE MATTER
In this case, components C and D are private to type ELEMENTS, but type ELEMENTS is not
private to MODULE MATTER. Any program unit that uses the module MATTER, can declare
variables of type ELEMENTS, and pass as arguments values of type ELEMENTS.

See Also
• “Type Declaration Statements”
• “Derived Data Types”
• “USE Statement”
• “Use and Host Association”
• “Defining Generic Names for Procedures” for details on generic identifiers
• “Modules and Module Procedures” for details on modules
• Table 5-1 for details on compatible attributes

5-53
5 Intel Fortran Language Reference

SAVE Attribute and Statement

The SAVE attribute causes the values and definition of objects to be retained after execution of a
RETURN or END statement in a subprogram.
The SAVE attribute can be specified in a type declaration statement or a SAVE statement, and
takes one of the following forms:
Type Declaration Statement:
type, [att-ls,] SAVE [, att-ls] :: [object [, object]...]
Statement:
SAVE [object [, object]...]
type
Is a data type specifier.
att-ls
Is an optional list of attribute specifiers.
object
Is the name of an object, or the name of a common block enclosed in slashes
(/common-block-name/).

Rules and Behavior

In Intel® Fortran, certain variables are given the SAVE attribute, or not, by default:
• The following variables are saved by default:
— COMMON variables
— Local variables of non-recursive subprograms
— Data initialized by DATA statements
• The following variables are not saved by default:
— Variables that are declared AUTOMATIC
— Local variables that are allocatable arrays
— Derived-type variables that are data initialized by default initialization of any of their
components
— RECORD variables that are data initialized by default initialization specified in its
STRUCTURE declaration
• Local variables that are not described in the preceding two lists are saved by default.
To enhance portability and avoid possible compiler warning messages, Intel® recommends that
you use the SAVE statement to name variables whose values you want to preserve between
subprogram invocations.

5-54
 Specification Statements 5
When a SAVE statement does not explicitly contain a list, all allowable items in the scoping unit
are saved.
A SAVE statement cannot specify the following (their values cannot be saved):
• A blank common
• An object in a common block
• A procedure
• A dummy argument
• A function result
• An automatic object
• A PARAMETER (named) constant
Even though a common block can be included in a SAVE statement, individual variables within
the common block can become undefined (or redefined) in another scoping unit.
If a common block is saved in any scoping unit of a program (other than the main program), it
must be saved in every scoping unit in which the common block appears.
A SAVE statement has no effect in a main program.

Examples
The following example shows a type declaration statement specifying the SAVE attribute:
SUBROUTINE TEST()
REAL, SAVE :: X, Y
The following is an example of the SAVE statement:
SAVE A, /BLOCK_B/, C, /BLOCK_D/, E

See Also
• “Type Declaration Statements”
• “DATA Statement”
• “COMMON Statement” for details on common blocks
• “Recursive Procedures” for details on recursive program units
• “Modules and Module Procedures” for details on modules.
• Table 5-1 for details on compatible attributes

TARGET Attribute and Statement

The TARGET attribute specifies that an object can become the target of a pointer (it can be
pointed to).

5-55
5 Intel Fortran Language Reference

The TARGET attribute can be specified in a type declaration statement or a TARGET statement,
and takes one of the following forms:
Type Declaration Statement:
type, [att-ls,] TARGET [, att-ls] :: object [(a-spec)] [, object [(a-spec)]]...
Statement:
TARGET [::] object [(a-spec)] [, object [(a-spec)]]...
type
Is a data type specifier.
att-ls
Is an optional list of attribute specifiers.
object
Is the name of the object. The object must not be declared with the PARAMETER attribute.
a-spec
Is an array specification.

Rules and Behavior

A pointer is associated with a target by pointer assignment or by an ALLOCATE statement.
If an object does not have the TARGET attribute or has not been allocated (using an ALLOCATE
statement), no part of it can be accessed by a pointer.

Examples
The following example shows type declaration statements specifying the TARGET attribute:
TYPE(SYSTEM), TARGET :: FIRST
REAL, DIMENSION(20, 20), TARGET :: C, D
The following is an example of a TARGET statement:
TARGET :: C(50, 50), D

See Also
• “Type Declaration Statements”
• “ALLOCATE Statement”
• “Pointer Assignments”
• “Pointer Association”
• Table 5-1 for details on compatible attributes

5-56
 Specification Statements 5
VOLATILE Attribute and Statement
The VOLATILE attribute specifies that the value of an object is entirely unpredictable, based on
information local to the current program unit. It prevents objects from being optimized during
compilation.
The VOLATILE attribute can be specified in a type declaration statement or a VOLATILE
statement, and takes one of the following forms:
Type Declaration Statement:
type, [att-ls,] VOLATILE [, att-ls] :: object [, object]...
Statement:
VOLATILE object [, object]...
type
Is a data type specifier.
att-ls
Is an optional list of attribute specifiers.
object
Is the name of an object, or the name of a common block enclosed in slashes.

Rules and Behavior

A variable or COMMON block must be declared VOLATILE if it can be read or written in a way
that is not visible to the compiler. For example:
• If an operating system feature is used to place a variable in shared memory (so that it can be
accessed by other programs), the variable must be declared VOLATILE.
• If a variable is accessed or modified by a routine called by the operating system when an
asynchronous event occurs, the variable must be declared VOLATILE.
If an array is declared VOLATILE, each element in the array becomes volatile. If a common block
is declared VOLATILE, each variable in the common block becomes volatile.
If an object of derived type is declared VOLATILE, its components become volatile.
If a pointer is declared VOLATILE, the pointer itself becomes volatile.
A VOLATILE statement cannot specify the following:
• A procedure
• A function result
• A namelist group

5-57
5 Intel Fortran Language Reference

Examples
The following example shows a type declaration statement specifying the VOLATILE attribute:
INTEGER, VOLATILE :: D, E
The following example shows a VOLATILE statement:
PROGRAM TEST
LOGICAL(1) IPI(4)
INTEGER(4) A, B, C, D, E, ILOOK
INTEGER(4) P1, P2, P3, P4
COMMON /BLK1/A, B, C

VOLATILE /BLK1/, D, E
EQUIVALENCE(ILOOK, IPI)
EQUIVALENCE(A, P1)
EQUIVALENCE(P1, P4)
The named common block, BLK1, and the variables D and E are volatile. Variables P1 and P4
become volatile because of the direct equivalence of P1 and the indirect equivalence of P4.

See Also
• “Type Declaration Statements”
• Table 5-1 for details on compatible attributes
• Your user’s guide for details on optimizations performed by the compiler

5-58
Dynamic Allocation 6
Data objects can be static or dynamic. If a data object is static, a fixed amount of memory storage
is created for it at compile time and is not freed until the program exits. If a data object is dynamic,
memory storage for the object can be created (allocated), altered, or freed (deallocated) as a
program executes.
In Fortran 95/90, pointers, allocatable arrays, and automatic arrays are dynamic data objects.
No storage space is created for a pointer until it is allocated with an ALLOCATE statement or until
it is assigned to a allocated target. A pointer can be dynamically disassociated from a target by
using a NULLIFY statement.
An ALLOCATE statement can also be used to create storage for an allocatable array. A
DEALLOCATE statement is used to free the storage space reserved in a previous ALLOCATE
statement.
Automatic arrays differ from allocatable arrays in that they are automatically allocated and
deallocated whenever you enter or leave a procedure, respectively.
This chapter contains information on the following topics:
• The “ALLOCATE Statement”
• The “DEALLOCATE Statement”
• The “NULLIFY Statement”

See Also
• “Pointer Assignments”
• “Explicit-Shape Specifications” for details on automatic arrays
• “NULL”, which can also be used to disassociate a pointer

6-1
6 Intel Fortran Language Reference

ALLOCATE Statement
The ALLOCATE statement dynamically creates storage for allocatable arrays and pointer targets.
The storage space allocated is uninitialized.
The ALLOCATE statement takes the following form:
ALLOCATE (object [(s-spec[, s-spec...])] [, object[(s-spec[, s-spec...])]]...[, STAT=sv])
object
Is the object to be allocated. It is a variable name or structure component, and must be a pointer or
allocatable array. The object can be of type character with zero length.
s-spec
Is a shape specification in the form [lower-bound:]upper-bound. Each bound must be a scalar
integer expression. The number of shape specifications must be the same as the rank of the object.
sv
Is a scalar integer variable in which the status of the allocation is stored.

Rules and Behavior

A bound in s-spec must not be an expression containing an array inquiry function whose argument
is any allocatable object in the same ALLOCATE statement; for example, the following is not
permitted:
INTEGER ERR
INTEGER, ALLOCATABLE :: A(:), B(:)
...
ALLOCATE(A(10:25), B(SIZE(A)), STAT=ERR) ! A is invalid as an argument
! to function SIZE
If a STAT variable is specified, it must not be allocated in the ALLOCATE statement in which it
appears. If the allocation is successful, the variable is set to zero. If the allocation is not successful,
an error condition occurs, and the variable is set to a positive integer value (representing the
run-time error). If no STAT variable is specified and an error condition occurs, program execution
terminates.

Examples
The following is an example of the ALLOCATE statement:
INTEGER J, N, ALLOC_ERR
REAL, ALLOCATABLE :: A(:), B(:,:)
...
ALLOCATE(A(0:80), B(-3:J+1, N), STAT = ALLOC_ERR)

6-2
 Dynamic Allocation 6
See Also
• “ALLOCATABLE Attribute and Statement” for details on allocatable arrays
• “POINTER Attribute and Statement” for details on pointers
• Your user’s guide or online documentation for details on run-time error messages

Allocation of Allocatable Arrays

The bounds (and shape) of an allocatable array are determined when it is allocated. Subsequent
redefinition or undefinition of any entities in the bound expressions does not affect the array
specification.
If the lower bound is greater than the upper bound, that dimension has an extent of zero, and the
array has a size of zero. If the lower bound is omitted, it is assumed to be 1.
When an array is allocated, it is definable. If you try to allocate a currently allocated allocatable
array, an error occurs.
The intrinsic function ALLOCATED can be used to determine whether an allocatable array is
currently allocated; for example:
REAL, ALLOCATABLE :: E(:,:)
...
IF (.NOT. ALLOCATED(E)) ALLOCATE(E(2:4,7))

Allocation Status
During program execution, the allocation status of an allocatable array is one of the following:
• Not currently allocated
The array was never allocated or the last operation on it was a deallocation. Such an array
must not be referenced or defined.
• Currently allocated
The array was allocated by an ALLOCATE statement. Such an array can be referenced,
defined, or deallocated.
If an allocatable array has the SAVE attribute, it has an initial status of "not currently allocated". If
the array is then allocated, its status changes to "currently allocated". It keeps that status until the
array is deallocated.
If an allocatable array does not have the SAVE attribute, it has the status of "not currently
allocated" at the beginning of each invocation of the procedure. If the array’s status changes to
"currently allocated", it is deallocated if the procedure is terminated by execution of a RETURN or
END statement.

6-3
6 Intel Fortran Language Reference

Examples
Example 6-1 shows a program that performs virtual memory allocation. This program uses
Fortran 95/90 standard-conforming statements instead of calling an operating system memory
allocation routine.

Example 6-1 Allocating Virtual Memory

! Program accepts an integer and displays square root values

INTEGER(4) :: N
READ (5,*) N ! Reads an integer value
CALL MAT(N)
END

! Subroutine MAT uses the typed integer value to display the square
! root values of numbers from 1 to N (the number read)

SUBROUTINE MAT(N)
REAL(4), ALLOCATABLE :: SQR(:) ! Declares SQR as a one-dimensional
! allocatable array
ALLOCATE (SQR(N)) ! Allocates array SQR
DO J=1,N
SQR(J) = SQRT(FLOATJ(J)) ! FLOATJ converts integer to REAL
ENDDO

WRITE (6,*) SQR ! Displays calculated values

DEALLOCATE (SQR) ! Deallocates array SQR
END SUBROUTINE MAT

See Also
“ALLOCATED”

Allocation of Pointer Targets

When a pointer is allocated, the pointer is associated with a target and can be used to reference or
define the target. (The target can be an array or a scalar, depending on how the pointer was
declared.)
Other pointers can become associated with the pointer target (or part of the pointer target) by
pointer assignment.

6-4
 Dynamic Allocation 6
In contrast to allocatable arrays, a pointer can be allocated a new target even if it is currently
associated with a target. The previous association is broken and the pointer is then associated with
the new target.
If the previous target was created by allocation, it becomes inaccessible unless it can still be
referred to by other pointers that are currently associated with it.
The intrinsic function ASSOCIATED can be used to determine whether a pointer is currently
associated with a target. (The association status of the pointer must be defined.) For example:
REAL, TARGET :: TAR(0:50)
REAL, POINTER :: PTR(:)
PTR => TAR
...
IF (ASSOCIATED(PTR,TAR))...

See Also
• “Pointer Assignments”
• “ASSOCIATED”
• “POINTER Attribute and Statement” for details on pointers

DEALLOCATE Statement
The DEALLOCATE statement frees the storage allocated for allocatable arrays and pointer targets
(and causes the pointers to become disassociated). It takes the following form:
DEALLOCATE (object [, object]...[, STAT=sv])
object
Is a structure component or the name of a variable, and must be a pointer or allocatable array.
sv
Is a scalar integer variable in which the status of the deallocation is stored.

Rules and Behavior

If a STAT variable is specified, it must not be deallocated in the DEALLOCATE statement in
which it appears. If the deallocation is successful, the variable is set to zero. If the deallocation is
not successful, an error condition occurs, and the variable is set to a positive integer value
(representing the run-time error). If no STAT variable is specified and an error condition occurs,
program execution terminates.
It is recommended that all explicitly allocated storage be explicitly deallocated when it is no
longer needed.

6-5
6 Intel Fortran Language Reference

Examples
The following example shows deallocation of an allocatable array:
INTEGER ALLOC_ERR
REAL, ALLOCATABLE :: A(:), B(:,:)
...
ALLOCATE (A(10), B(-2:8,1:5))
...
DEALLOCATE(A, B, STAT = ALLOC_ERR)

See Also
Your user’s guide or online documentation for details on run-time error messages

Deallocation of Allocatable Arrays

If the DEALLOCATE statement specifies an array that is not currently allocated, an error occurs.
If an allocatable array with the TARGET attribute is deallocated, the association status of any
pointer associated with it becomes undefined.
If a RETURN or END statement terminates a procedure, an allocatable array has one of the
following allocation statuses:
• It keeps its previous allocation and association status if the following is true:
— It has the SAVE attribute.
— It is in the scoping unit of a module that is accessed by another scoping unit which is
currently executing.
— It is accessible by host association.
• It remains allocated if it is accessed by use association.
• Otherwise, its allocation status is deallocated.
The intrinsic function ALLOCATED can be used to determine whether an allocatable array is
currently allocated; for example:
SUBROUTINE TEST
REAL, ALLOCATABLE, SAVE :: F(:,:)
REAL, ALLOCATABLE :: E(:,:,:)
...
IF (.NOT. ALLOCATED(E)) ALLOCATE(E(2:4,7,14))
END SUBROUTINE TEST

6-6
 Dynamic Allocation 6
Note that when subroutine TEST is exited, the allocation status of F is maintained because F has
the SAVE attribute. Since E does not have the SAVE attribute, it is deallocated. On the next
invocation of TEST, E will have the status of "not currently allocated".

See Also
• “Use and Host Association”
• “TARGET Attribute and Statement”
• “RETURN Statement”
• “END Statement”
• “SAVE Attribute and Statement”

Deallocation of Pointer Targets

A pointer must not be deallocated unless it has a defined association status. If the DEALLOCATE
statement specifies a pointer that has undefined association status, or a pointer whose target was
not created by allocation, an error occurs.
A pointer must not be deallocated if it is associated with an allocatable array, or it is associated
with a portion of an object (such as an array element or an array section).
If a pointer is deallocated, the association status of any other pointer associated with the target (or
portion of the target) becomes undefined.
Execution of a RETURN or END statement in a subprogram causes the pointer association status
of any pointer declared (or accessed) in the procedure to become undefined, unless any of the
following applies to the pointer:
• It has the SAVE attribute.
• It is in the scoping unit of a module that is accessed by another scoping unit which is currently
executing.
• It is accessible by host association.
• It is in blank common.
• It is in a named common block that appears in another scoping unit that is currently
executing.
• It is the return value of a function declared with the POINTER attribute.
If the association status of a pointer becomes undefined, it cannot subsequently be referenced or
defined.

Examples
The following example shows deallocation of a pointer:

6-7
6 Intel Fortran Language Reference

INTEGER ERR
REAL, POINTER :: PTR_A(:)
...
ALLOCATE (PTR_A(10), STAT=ERR)
...
DEALLOCATE(PTR_A)

See Also
• “Use and Host Association”
• “RETURN Statement”
• “END Statement”
• “SAVE Attribute and Statement”
• “POINTER Attribute and Statement” for details on pointers
• “COMMON Statement” for details on common blocks
• “NULL”, which can be used to disassociate a pointer

NULLIFY Statement
The NULLIFY statement disassociates a pointer from its target. It takes the following form:
NULLIFY (pointer-object [, pointer-object]...)
pointer-object
Is a structure component or the name of a variable; it must be a pointer (have the POINTER
attribute).

Rules and Behavior

The initial association status of a pointer is undefined. You can use NULLIFY to initialize an
undefined pointer, giving it disassociated status. Then the pointer can be tested using the intrinsic
function ASSOCIATED.

Examples
The following is an example of the NULLIFY statement:
REAL, TARGET :: TAR(0:50)
REAL, POINTER :: PTR_A(:), PTR_B(:)
PTR_A => TAR
PTR_B => TAR
...
NULLIFY(PTR_A)

6-8
 Dynamic Allocation 6
After these statements are executed, PTR_A will have disassociated status, while PTR_B will
continue to be associated with variable TAR.

See Also
• “POINTER Attribute and Statement”
• “Pointer Assignments”
• “ASSOCIATED”
• “NULL”, which can be used to disassociate a pointer

6-9
6 Intel Fortran Language Reference

6-10
Execution Control 7
A program normally executes statements in the order in which they are written. Executable control
constructs and statements modify this normal execution by transferring control to another
statement in the program, or by selecting blocks (groups) of constructs and statements for
execution or repetition.
In Fortran 95/90, control constructs (CASE, DO, and IF) can be named. The name must be a
unique identifier in the scoping unit, and must appear on the initial line and terminal line of the
construct. On the initial line, the name is separated from the statement keyword by a colon (:).
A block can contain any executable Fortran statement except an END statement. You can transfer
control out of a block, but you cannot transfer control into another block.
DO loops cannot partially overlap blocks. The DO statement and its terminal statement must
appear together in a statement block.
This chapter contains information on the following topics:
• The “Branch Statements”
• The “CALL Statement”
• The “CASE Constructs”
• The “CONTINUE Statement”
• The “DO Constructs”
• The “END Statement”
• The “IF Construct and Statement”
• The “PAUSE Statement”
• The “RETURN Statement”
• The “STOP Statement”

7-1
7 Intel Fortran Language Reference

Branch Statements
Branching affects the normal execution sequence by transferring control to a labeled statement in
the same scoping unit. The transfer statement is called the branch statement, while the statement
to which the transfer is made is called the branch target statement.
Any executable statement can be a branch target statement, except for the following:
• CASE statement
• ELSE statement
• ELSE IF statement
Certain restrictions apply to the following statements:

Statement Restriction
DO terminal statement The branch must be taken from within its nonblock DO construct.1
END DO The branch must be taken from within its block DO construct.
END IF The branch should be taken from within its IF construct.2
END SELECT The branch must be taken from within its CASE construct.
1. If the terminal statement is shared by more than one nonblock DO construct, the branch can only be taken from within the
innermost DO construct.
2. You can branch to an END IF statement from outside the IF construct; this is a deleted feature in Fortran 95. Intel® Fortran fully
supports features deleted in Fortran 95.

The following branch statements are described in this section:

• “Unconditional GO TO Statement”
• “Computed GO TO Statement”
• “The ASSIGN and Assigned GO TO Statements”
• “Arithmetic IF Statement”
See Also
• “IF Construct and Statement”
• “CASE Constructs”
• “DO Constructs”

Unconditional GO TO Statement
The unconditional GO TO statement transfers control to the same branch target statement every
time it executes. It takes the following form:
GO TO label

7-2
 Execution Control 7
label
Is the label of a valid branch target statement in the same scoping unit as the GO TO statement.
The unconditional GO TO statement transfers control to the branch target statement identified by
the specified label.
The following are examples of GO TO statements:
GO TO 7734
GO TO 99999

Computed GO TO Statement
The computed GO TO statement transfers control to one of a set of labeled branch target
statements based on the value of an expression. It is an obsolescent feature in Fortran 95.
The computed GO TO statement takes the following form:
GO TO (label-list)[,] expr
label-list
Is a list of labels (separated by commas) of valid branch target statements in the same scoping unit
as the computed GO TO statement. (Also called the transfer list.) The same label can appear more
than once in this list.
expr
Is a scalar numeric expression in the range 1 to n, where n is the number of statement labels in
label-list. If necessary, it is converted to integer data type.

Rules and Behavior

When the computed GO TO statement is executed, the expression is evaluated first. The value of
the expression represents the ordinal position of a label in the associated list of labels. Control is
transferred to the statement identified by the label. For example, if the list contains (30,20,30,40)
and the value of the expression is 2, control is transferred to the statement identified with label 20.
If the value of the expression is less than 1 or greater than the number of labels in the list, control
is transferred to the next executable statement or construct following the computed GO TO
statement.

Examples
The following example shows valid computed GO TO statements:
GO TO (12,24,36), INDEX
GO TO (320,330,340,350,360), SITU(J,K) + 1

7-3
7 Intel Fortran Language Reference

See Also
Appendix A, “Deleted and Obsolescent Language Features”, for details on obsolescent features in
Fortran 95

The ASSIGN and Assigned GO TO Statements

The ASSIGN statement assigns a label to an integer variable. Subsequently, this variable can be
used as a branch target statement by an assigned GO TO statement or as a format specifier in a
formatted input/output statement.
The ASSIGN and assigned GO TO statements are deleted features in Fortran 95; they were
obsolescent features in Fortran 90. Intel Fortran fully supports features deleted in Fortran 95.

See Also
Appendix A, “Deleted and Obsolescent Language Features”, for details on obsolescent features in
Fortran 95 and Fortran 90, as well as features deleted in Fortran 95

ASSIGN Statement
The ASSIGN statement assigns a statement label value to an integer variable. It takes the
following form:
ASSIGN label TO var
label
Is the label of a branch target or FORMAT statement in the same scoping unit as the ASSIGN
statement.
var
Is a scalar integer variable.

Rules and Behavior

When an ASSIGN statement is executed, the statement label is assigned to the integer variable.
The variable is then undefined as an integer variable and can only be used as a label (unless it is
later redefined with an integer value).
The ASSIGN statement must be executed before the statements in which the assigned variable is
used.

Examples
The following example shows ASSIGN statements:
INTEGER ERROR

7-4
 Execution Control 7
...
ASSIGN 10 TO NSTART
ASSIGN 99999 TO KSTOP
ASSIGN 250 TO ERROR
Note that NSTART and KSTOP are integer variables implicitly, but ERROR must be previously
declared as an integer variable.
The following statement associates the variable NUMBER with the statement label 100:
ASSIGN 100 TO NUMBER
If an arithmetic operation is subsequently performed on variable NUMBER (such as follows), the
run-time behavior is unpredictable:
NUMBER = NUMBER + 1
To return NUMBER to the status of an integer variable, you can use the following statement:
NUMBER = 10
This statement dissociates NUMBER from statement 100 and assigns it an integer value of 10.
Once NUMBER is returned to its integer variable status, it can no longer be used in an assigned
GO TO statement.

Assigned GO TO Statement
The assigned GO TO statement transfers control to the statement whose label was most recently
assigned to a variable. The assigned GO TO statement takes the following form:
GO TO var [[,] (label-list)]
var
Is a scalar integer variable.
label-list
Is a list of labels (separated by commas) of valid branch target statements in the same scoping unit
as the assigned GO TO statement. The same label can appear more than once in this list.

Rules and Behavior

The variable must have a statement label value assigned to it by an ASSIGN statement (not an
arithmetic assignment statement) before the GO TO statement is executed.
If a list of labels appears, the statement label assigned to the variable must be one of the labels in
the list.
Both the assigned GO TO statement and its associated ASSIGN statement must be in the same
scoping unit.

7-5
7 Intel Fortran Language Reference

Examples
The following example is equivalent to GO TO 200:
ASSIGN 200 TO IGO
GO TO IGO
The following example is equivalent to GO TO 450:
ASSIGN 450 TO IBEG
GO TO IBEG, (300,450,1000,25)
The following example shows an invalid use of an assigned variable:
ASSIGN 10 TO I
J = I
GO TO J
In this case, variable J is not the variable assigned to, so it cannot be used in the assigned GO TO
statement.

Arithmetic IF Statement
The arithmetic IF statement conditionally transfers control to one of three statements, based on the
value of an arithmetic expression. It is an obsolescent feature in Fortran 95 and Fortran 90.
The arithmetic IF statement takes the following form:
IF (expr) label1, label2, label3
expr
Is a scalar numeric expression of type integer or real (enclosed in parentheses).
label1, label2, label3
Are the labels of valid branch target statements that are in the same scoping unit as the arithmetic
IF statement.

Rules and Behavior

All three labels are required, but they do not need to refer to three different statements. The same
label can appear more than once in the same arithmetic IF statement.
During execution, the expression is evaluated first. Depending on the value of the expression,
control is then transferred as follows:

If the Value of expr is: Control Transfers To:

Less than 0 Statement label1
Equal to 0 Statement label2

7-6
 Execution Control 7
If the Value of expr is: Control Transfers To:
Greater than 0 Statement label3

Examples
The following example transfers control to statement 50 if the real variable THETA is less than or
equal to the real variable CHI. Control passes to statement 100 only if THETA is greater than CHI.
IF (THETA-CHI) 50,50,100
The following example transfers control to statement 40 if the value of the integer variable
NUMBER is even. It transfers control to statement 20 if the value is odd.
IF (NUMBER / 2*2 - NUMBER) 20,40,20

See Also
Appendix A, “Deleted and Obsolescent Language Features”, for details on obsolescent features in
Fortran 95 and Fortran 90

CALL Statement
The CALL statement transfers control to a subroutine subprogram. It takes the following form:
CALL sub [([a-arg [, a-arg]...]) ]
sub
Is the name of the subroutine subprogram or other external procedure, or a dummy argument
associated with a subroutine subprogram or other external procedure.
a-arg
Is an actual argument optionally preceded by [keyword=], where keyword is the name of a dummy
argument in the explicit interface for the subroutine. The keyword is assigned a value when the
procedure is invoked.
Each actual argument must be a variable, an expression, the name of a procedure, or an alternate
return specifier. (It must not be the name of an internal procedure, statement function, or the
generic name of a procedure.)
An alternate return specifier is an asterisk (*), or ampersand (&), followed by the label of an
executable branch target statement in the same scoping unit as the CALL statement. (An alternate
return is an obsolescent feature in Fortran 95 and Fortran 90.)

7-7
7 Intel Fortran Language Reference

Rules and Behavior

When the CALL statement is executed, any expressions in the actual argument list are evaluated,
then control is passed to the first executable statement or construct in the subroutine. When the
subroutine finishes executing, control returns to the next executable statement following the
CALL statement, or to a statement identified by an alternate return label (if any).
If an argument list appears, each actual argument is associated with the corresponding dummy
argument by its position in the argument list or by the name of its keyword. The arguments must
agree in type and kind parameters.
If positional arguments and argument keywords are specified, the argument keywords must appear
last in the actual argument list.
If a dummy argument is optional, the actual argument can be omitted.
An actual argument associated with a dummy procedure must be the specific name of a procedure,
or be another dummy procedure. Certain specific intrinsic function names must not be used as
actual arguments (see Table 9-1).
You can use a CALL statement to invoke a function as long as the function is not one of the
following types:
• REAL(8)
• REAL(16)
• COMPLEX(8)
• COMPLEX(16)
• CHARACTER
Examples
The following example shows valid CALL statements:
CALL CURVE(BASE,3.14159+X,Y,LIMIT,R(LT+2))

CALL PNTOUT(A,N,’ABCD’)

CALL EXIT

CALL MULT(A,B,*10,*20,C) ! The asterisks and ampersands denote

CALL SUBA(X,&30,&50,Y) ! alternate returns
The following example shows a subroutine with argument keywords:
PROGRAM KEYWORD_EXAMPLE
INTERFACE
SUBROUTINE TEST_C(I, L, J, KYWD2, D, F, KYWD1)
INTEGER I, L(20), J, KYWD1

7-8
 Execution Control 7
REAL, OPTIONAL :: D, F
COMPLEX KYWD2
...
END SUBROUTINE TEST_C
END INTERFACE
INTEGER I, J, K
INTEGER L(20)
COMPLEX Z1
CALL TEST_C(I, L, J, KYWD1 = K, KYWD2 = Z1)
...
The first three actual arguments are associated with their corresponding dummy arguments by
position. The argument keywords are associated by keyword name, so they can appear in any
order.
Note that the interface to subroutine TEST has two optional arguments that have been omitted in
the CALL statement.
The following is another example of a subroutine call with argument keywords:
CALL TEST(X, Y, N, EQUALITIES = Q, XSTART = X0)
The first three arguments are associated by position.

See Also
• “Subroutines”
• “Argument Association” for details on procedure arguments
• “OPTIONAL Attribute and Statement” for details on optional arguments
• “Dummy Procedure Arguments” for details on dummy arguments
• Appendix A, “Deleted and Obsolescent Language Features”, for details on obsolescent
features in Fortran 95 and Fortran 90

CASE Constructs
The CASE construct conditionally executes one block of constructs or statements depending on
the value of a scalar expression in a SELECT CASE statement.
The CASE construct takes the following form:

7-9
7 Intel Fortran Language Reference

[name:] SELECT CASE (expr)

[CASE (case-value [, case-value]...) [name]
block]...
[CASE DEFAULT [name]
block]
END SELECT [name]
name
Is the name of the CASE construct.
expr
Is a scalar expression of type integer, logical, or character (enclosed in parentheses). Evaluation of
this expression results in a value called the case index.
case-value
Is one or more scalar integer, logical, or character initialization expressions enclosed in
parentheses. Each expr must be of the same type and kind parameter as expr. If the type is
character, case-value and expr can be of different lengths, but their kind parameter must be the
same.
Integer and character expressions can be expressed as a range of case values, taking one of the
following forms:
low:high
low:
:high
Case values must not overlap.
block
Is a sequence of zero or more statements or constructs.

Rules and Behavior

If a construct name is specified in a SELECT CASE statement, the same name must appear in the
corresponding END SELECT statement. The same construct name can optionally appear in any
CASE statement in the construct. The same construct name must not be used for different named
constructs in the same scoping unit.
The case expression (expr) is evaluated first. The resulting case index is compared to the case
values to find a matching value (there can only be one). When a match occurs, the block following
the matching case value is executed and the construct terminates.
The following rules determine whether a match occurs:

7-10
 Execution Control 7
• When the case value is a single value (no colon appears), a match occurs as follows:

Data Type A Match Occurs If:

Logical case-index .EQV. case- value
Integer or character case-index = = case-value

• When the case value is a range of values (a colon appears), a match depends on the range
specified, as follows:

Range A Match Occurs If:

low: case-index >= low
:high case-index <= high
low:high low <= case-index <= high

The following are all valid case values:

CASE (1, 4, 7, 11:14, 22) ! Individual values as specified:
! 1, 4, 7, 11, 12, 13, 14, 22
CASE (:-1) ! All values less than zero
CASE (0) ! Only zero
CASE (1:) ! All values above zero
If no match occurs but a CASE DEFAULT statement is present, the block following that statement
is executed and the construct terminates.
If no match occurs and no CASE DEFAULT statement is present, no block is executed, the
construct terminates, and control passes to the next executable statement or construct following
the END SELECT statement.
Figure 7-1 shows the flow of control in a CASE construct.

7-11
7 Intel Fortran Language Reference

Figure 7-1 Flow of Control in CASE Constructs

Construct Flow of Control

Evaluate Test 1
SELECT CASE (TEST 1)
CASE (1)
block 1 Matches Yes Execute
CASE (2) CASE (1) block 1

block 2
No
END SELECT

Matches Yes Execute

CASE (2) block 2

No

SELECT CASE (TEST 2)

CASE (1)
block 1 Matches Yes Execute
CASE (2) CASE (1) block 1

block 2
No
CASE (3)
block 3
CASE DEFAULT Matches Yes Execute
block 4 CASE (2) block 2

END SELECT
No

Matches Yes Execute

CASE (3) block 3

No

Execute
block 4

ZK−6515A−GE

7-12
 Execution Control 7
You cannot use branching statements to transfer control to a CASE statement. However, branching
to a SELECT CASE statement is allowed. Branching to the END SELECT statement is allowed
only from within the CASE construct.

Examples
The following are examples of CASE constructs:
INTEGER FUNCTION STATUS_CODE (I)
INTEGER I
CHECK_STATUS: SELECT CASE (I)
CASE (:-1)
STATUS_CODE = -1
CASE (0)
STATUS_CODE = 0
CASE (1:)
STATUS_CODE = 1
END SELECT CHECK_STATUS
END FUNCTION STATUS_CODE

SELECT CASE (J)

CASE (1, 3:7, 9) ! Values: 1, 3, 4, 5, 6, 7, 9
CALL SUB_A
CASE DEFAULT
CALL SUB_B
END SELECT
The following three examples are equivalent:
1. SELECT CASE (ITEST .EQ. 1)
CASE (.TRUE.)
CALL SUB1 ()
CASE (.FALSE.)
CALL SUB2 ()
END SELECT
2. SELECT CASE (ITEST)
CASE DEFAULT
CALL SUB2 ()
CASE (1)
CALL SUB1 ()
END SELECT

7-13
7 Intel Fortran Language Reference

3. IF (ITEST .EQ. 1) THEN

CALL SUB1 ()
ELSE
CALL SUB2 ()
END IF

CONTINUE Statement
The CONTINUE statement is primarily used to terminate a labeled DO construct when the
construct would otherwise end improperly with either a GO TO, arithmetic IF, or other prohibited
control statement.
The CONTINUE statement takes the following form:
CONTINUE
The statement by itself does nothing and has no effect on program results or execution sequence.
The following example shows a CONTINUE statement:
DO 150 I = 1,40
40 Y = Y + 1
Z = COS(Y)
PRINT *, Z
IF (Y .LT. 30) GO TO 150
GO TO 40
150 CONTINUE

DO Constructs
The DO construct controls the repeated execution of a block of statements or constructs. (This
repeated execution is called a loop.)
The number of iterations of a loop can be specified in the initial DO statement in the construct, or
the number of iterations can be left indefinite by a simple DO ("DO forever") construct or DO
WHILE statement.
The EXIT and CYCLE statements modify the execution of a loop. An EXIT statement terminates
execution of a loop, while a CYCLE statement terminates execution of the current iteration of a
loop. For example:
DO
READ (EUNIT, IOSTAT=IOS) Y
IF (IOS /= 0) EXIT
IF (Y <0) CYCLE

7-14