Classical Fortran: Programming for Engineering and Scientific Applications, Second Edition

546 Pages·2009·3.816 MB·\546

by  Michael Kupferschmid (Author)

Second Edition
C
lassical
F
ORTRAN
Programming for
Engineering and
Scientific Applications
59076_FM.indd 1 11/26/08 1:46:14 PM
59076_FM.indd 2 11/26/08 1:46:14 PM
Second Edition
C
lassical
F
ORTRAN
Programming for
Engineering and
Scientific Applications
Michael Kupferschmid
Boca Raton London New York
CRC Press is an imprint of the
Taylor & Francis Group, an informa business
59076_FM.indd 3 11/26/08 1:46:14 PM
CRC Press
Taylor & Francis Group
6000 Broken Sound Parkway NW, Suite 300
Boca Raton, FL 33487-2742
© 2009 by Taylor and Francis Group, LLC
CRC Press is an imprint of Taylor & Francis Group, an Informa business
No claim to original U.S. Government works
Printed in the United States of America on acid-free paper
10 9 8 7 6 5 4 3 2 1
International Standard Book Number-13: 978-1-4200-5914-4 (Ebook-PDF)
This book contains information obtained from authentic and highly regarded sources. Reasonable efforts have been
made to publish reliable data and information, but the author and publisher cannot assume responsibility for the valid-
ity of all materials or the consequences of their use. The authors and publishers have attempted to trace the copyright
holders of all material reproduced in this publication and apologize to copyright holders if permission to publish in this
form has not been obtained. If any copyright material has not been acknowledged please write and let us know so we may
rectify in any future reprint.
Except as permitted under U.S. Copyright Law, no part of this book may be reprinted, reproduced, transmitted, or uti-
lized in any form by any electronic, mechanical, or other means, now known or hereafter invented, including photocopy-
ing, microfilming, and recording, or in any information storage or retrieval system, without written permission from the
publishers.
For permission to photocopy or use material electronically from this work, please access www.copyright.com (http://
www.copyright.com/) or contact the Copyright Clearance Center, Inc. (CCC), 222 Rosewood Drive, Danvers, MA 01923,
978-750-8400. CCC is a not-for-profit organization that provides licenses and registration for a variety of users. For
organizations that have been granted a photocopy license by the CCC, a separate system of payment has been arranged.
Trademark Notice: Product or corporate names may be trademarks or registered trademarks, and are used only for
identification and explanation without intent to infringe.
Visit the Taylor & Francis Web site at
http://www.taylorandfrancis.com
and the CRC Press Web site at
http://www.crcpress.com
Contents
Preface xiii
0 Introduction 1
0.1 Why Study Programming? . . . . . . . . . . . . . . . . . . . . . . . . . . 1
0.2 The Evolution of Fortran . . . . . . . . . . . . . . . . . . . . . . . . . . 3
0.3 Why Study Fortran? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
0.4 Classical Fortran . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
0.5 About This Book . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
0.5.1 Motivation and History . . . . . . . . . . . . . . . . . . . . . . . . 11
0.5.2 Audience . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
0.5.3 Organization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
0.5.4 PedagogicalApproach . . . . . . . . . . . . . . . . . . . . . . . . . 15
0.5.5 TypographicalConventions . . . . . . . . . . . . . . . . . . . . . . 17
0.5.6 Computing Environment Dependencies . . . . . . . . . . . . . . . . 19
0.6 Advice to Instructors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
0.7 About The Author . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
0.8 Acknowledgements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
0.9 Disclaimers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
0.10 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
1 Hello, World! 29
1.1 Case Study: A First Fortran Program . . . . . . . . . . . . . . . . . . . 29
1.2 Compiling the Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
1.3 Running a Programin UNIXTM . . . . . . . . . . . . . . . . . . . . . . . . . 31
1.4 Omissions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
1.5 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2 Expressions and Assignment Statements 35
2.1 Constants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
2.2 Variables and Variable Names . . . . . . . . . . . . . . . . . . . . . . . . . 36
2.3 Arithmetic Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
2.4 Function References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
2.5 Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
2.6 Assignment Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
2.7 READ and PRINT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
2.8 Omissions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
2.9 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3 Conditionals and Branching 43
3.1 Flowcharting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
3.2 The GO TO Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3.3 The IF-THEN Construct . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.4 The Logical IF Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
v
vi Classical FORTRAN
3.5 Flowcharting Reconsidered . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.6 Additional Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.7 Omissions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.8 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
4 Scalar Data Types 55
4.1 Integers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
4.2 Reals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.3 Roundoff Errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
4.4 Type Conversions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.5 Case Study: Computing the Sine . . . . . . . . . . . . . . . . . . . . . . . 62
4.6 Other Data Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
4.6.1 Complex Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
4.6.2 Logicals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
4.6.3 Bits and Hexadecimal Numbers . . . . . . . . . . . . . . . . . . . . 67
4.7 Some Special Values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
4.8 Architectural Variations . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
4.9 Omissions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
4.10 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
5 Arrays and DO Loops 79
5.1 Vectors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
5.2 The DO Loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
5.3 Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
5.4 The Rules of DO Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
5.5 Array Dimensioning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
5.6 Case Study: Matrix Multiplication . . . . . . . . . . . . . . . . . . . . . . 86
5.7 Omissions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
5.8 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
6 Subprograms 95
6.1 SUBROUTINESubprograms . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
6.2 Call By Reference . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
6.3 FUNCTION Subprograms . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
6.4 Case Study: Bisection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
6.5 Detecting First Entry . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
6.6 Fortran, System, and Library Routines . . . . . . . . . . . . . . . . . . 105
6.6.1 Fortran Built-In Functions . . . . . . . . . . . . . . . . . . . . . 105
6.6.2 UNIXTM System Routines . . . . . . . . . . . . . . . . . . . . . . . . 107
6.6.3 Subprogram Libraries . . . . . . . . . . . . . . . . . . . . . . . . . 107
6.7 Conclusion and Omissions . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
6.8 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
7 Adjustable Dimensions and EXTERNAL 117
7.1 Adjustable Dimensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
7.1.1 Assumed-Size Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . 118
7.1.2 Passing Leading Dimensions . . . . . . . . . . . . . . . . . . . . . . 120
7.2 EXTERNAL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
7.2.1 Fixed Subprogram Names . . . . . . . . . . . . . . . . . . . . . . . 123
7.2.2 Passing Subprogram Names . . . . . . . . . . . . . . . . . . . . . . 124
7.3 Summary and Omissions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
Table of Contents vii
7.4 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
8 COMMON 133
8.1 Passing Data Through . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
8.2 Passing Data Around . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
8.3 Alignment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
8.3.1 Alignment by Order . . . . . . . . . . . . . . . . . . . . . . . . . . 136
8.3.2 Alignment in Memory . . . . . . . . . . . . . . . . . . . . . . . . . 136
8.4 Formal Parameters and COMMON . . . . . . . . . . . . . . . . . . . . . . . . 137
8.5 Arrays in COMMON . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
8.6 BLOCK DATA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
8.7 Omissions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
8.8 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
9 Input and Output 147
9.1 READ and WRITE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
9.1.1 FORMAT Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
9.1.2 Cursor Control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
9.1.3 End-of-File and Error Conditions . . . . . . . . . . . . . . . . . . . 150
9.2 Case Study: Descriptive Statistics . . . . . . . . . . . . . . . . . . . . . . 151
9.3 Implied DO Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
9.4 Unit Assignments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
9.4.1 Interactive Programs . . . . . . . . . . . . . . . . . . . . . . . . . . 155
9.4.2 Attaching Files with GETFIL. . . . . . . . . . . . . . . . . . . . . . 158
9.4.3 Batch Programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
9.5 Descriptive Statistics Revisited . . . . . . . . . . . . . . . . . . . . . . . . 160
9.6 Positioning In Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
9.7 Case Study: Merging Files . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
9.8 Unformatted I/O . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
9.9 Cautions and Omissions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
9.10 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
10 Character Variables 171
10.1 How Characters Are Stored . . . . . . . . . . . . . . . . . . . . . . . . . . 171
10.2 Writing Out and Reading In CHARACTERVariables . . . . . . . . . . . . . . 174
10.3 Editing Character Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
10.4 Object-Time FORMATs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
10.5 Case Study: QUERY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
10.6 CHARACTERVariables in Other Contexts . . . . . . . . . . . . . . . . . . . 182
10.6.1 Reading From and Writing To CHARACTERVariables . . . . . . . . 182
10.6.2 Using CHARACTERVariables in OPEN . . . . . . . . . . . . . . . . . . 184
10.6.3 CHARACTERFunctions . . . . . . . . . . . . . . . . . . . . . . . . . . 184
10.7 Character Graphics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
10.7.1 X–Y Plots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
10.7.2 Contour Plots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
10.8 Omissions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
10.9 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
viii Classical FORTRAN
11 Memory Management Techniques 199
11.1 Passing Array Columns . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
11.2 Partitioning Workspace . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
11.3 Sharing Workspace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
11.4 Sharing Constant Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
11.5 Storing a Symmetric Matrix . . . . . . . . . . . . . . . . . . . . . . . . . . 204
11.6 Sparse Matrix Techniques . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
11.6.1 Fixed Pattern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
11.6.2 Varying Pattern. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
11.7 Linked Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
11.8 Omissions and Caveats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
11.9 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
12 Design, Documentation, and Coding Style 219
12.1 The Craft of Programming . . . . . . . . . . . . . . . . . . . . . . . . . . 221
12.2 Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
12.2.1 User Interface Design. . . . . . . . . . . . . . . . . . . . . . . . . . 223
12.2.2 ProgramDesign. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
12.3 Documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
12.3.1 External Documentation . . . . . . . . . . . . . . . . . . . . . . . . 230
12.3.2 Internal Documentation . . . . . . . . . . . . . . . . . . . . . . . . 234
12.4 Coding Style . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
12.4.1 Cognitive Complexity . . . . . . . . . . . . . . . . . . . . . . . . . 240
12.4.2 Names . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
12.4.3 Branching Logic . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
12.4.4 Exposition. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
12.4.5 Typography . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248
12.4.6 Refining the Comments . . . . . . . . . . . . . . . . . . . . . . . . 251
12.5 Hand-Checking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252
12.6 Testing, Revision, and Maintenance . . . . . . . . . . . . . . . . . . . . . . 254
12.6.1 Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254
12.6.2 Revision and Maintenance . . . . . . . . . . . . . . . . . . . . . . . 255
12.7 Conclusion and Omissions . . . . . . . . . . . . . . . . . . . . . . . . . . . 257
12.8 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257
13 Archaic, Unusual, and Dangerous Usages 265
13.1 Source Form . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266
13.1.1 Sequence Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . 266
13.1.2 Dead Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266
13.1.3 Free-Form Source . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
13.1.4 INCLUDE Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
13.1.5 The PROGRAMStatement . . . . . . . . . . . . . . . . . . . . . . . . 269
13.1.6 No STOP Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
13.1.7 Star and Blank Comments . . . . . . . . . . . . . . . . . . . . . . . 270
13.1.8 Other Continuation Characters . . . . . . . . . . . . . . . . . . . . 270
13.2 Expressions and Assignment Statements . . . . . . . . . . . . . . . . . . . 272
13.2.1 Precedence Dependencies . . . . . . . . . . . . . . . . . . . . . . . 272
13.2.2 Long Names . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
13.3 Conditionals and Transfer of Control . . . . . . . . . . . . . . . . . . . . . 273
13.3.1 ELSE IF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273
13.3.2 The Computed GO TO. . . . . . . . . . . . . . . . . . . . . . . . . . 273
Table of Contents ix
13.3.3 The Arithmetic IF . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
13.3.4 The Assigned GO TO . . . . . . . . . . . . . . . . . . . . . . . . . . 274
13.3.5 Free Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
13.4 Scalar Data Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
13.4.1 Mixed Mode. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
13.4.2 Generic Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
13.4.3 IMPLICIT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278
13.4.4 IMPLICITNONE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278
13.4.5 Other Data Types . . . . . . . . . . . . . . . . . . . . . . . . . . . 279
13.4.6 Other Forms of Type Declaration . . . . . . . . . . . . . . . . . . . 280
13.4.7 Abuses of EQUIVALENCE . . . . . . . . . . . . . . . . . . . . . . . . 280
13.5 Arrays and DO Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
13.5.1 The DIMENSIONStatement . . . . . . . . . . . . . . . . . . . . . . . 281
13.5.2 Abuses of DO Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
13.5.3 Abuses of CONTINUE . . . . . . . . . . . . . . . . . . . . . . . . . . 282
13.5.4 DO WHILE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
13.6 Subprograms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
13.6.1 Alternate RETURNs . . . . . . . . . . . . . . . . . . . . . . . . . . . 284
13.6.2 ENTRY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285
13.6.3 Abuses of Subprogram Arguments . . . . . . . . . . . . . . . . . . 286
13.6.4 Call by Value . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
13.6.5 Functions Without Arguments . . . . . . . . . . . . . . . . . . . . 287
13.6.6 Statement Functions . . . . . . . . . . . . . . . . . . . . . . . . . . 288
13.6.7 Archaic Names for Built-In Functions . . . . . . . . . . . . . . . . 288
13.7 Adjustable Dimensions and EXTERNAL . . . . . . . . . . . . . . . . . . . . 289
13.7.1 Arrays Dimensioned (1) . . . . . . . . . . . . . . . . . . . . . . . . 289
13.7.2 Overuse of EXTERNAL . . . . . . . . . . . . . . . . . . . . . . . . . . 290
13.8 COMMON . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290
13.8.1 Indiscriminate Use of COMMON . . . . . . . . . . . . . . . . . . . . . 290
13.8.2 Extending COMMON by EQUIVALENCE . . . . . . . . . . . . . . . . . . 292
13.8.3 References Past the End of an Array . . . . . . . . . . . . . . . . . 292
13.8.4 Blank COMMON . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
13.8.5 Arrays Dimensioned in COMMON Statements. . . . . . . . . . . . . . 293
13.9 Input and Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
13.9.1 Carriage Control . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
13.9.2 Scale Factors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294
13.9.3 Hollerith Strings in FORMATs . . . . . . . . . . . . . . . . . . . . . . 296
13.9.4 Printing Leading Zeros . . . . . . . . . . . . . . . . . . . . . . . . . 296
13.9.5 Formatted READs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296
13.9.6 Direct-Access I/O . . . . . . . . . . . . . . . . . . . . . . . . . . . 297
13.9.7 NAMELIST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298
13.10 Character Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299
13.10.1 Characters in Variables of Other Types . . . . . . . . . . . . . . . 299
13.10.2 Arithmetic With Characters . . . . . . . . . . . . . . . . . . . . . . 300
13.10.3 Substrings, Concatenation, and Character Built-Ins. . . . . . . . . 301
13.11 Case Study: A Legacy Code . . . . . . . . . . . . . . . . . . . . . . . . . . 302
13.11.1 Source Listing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302
13.11.2 Observations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304
13.11.3 Cleaning Up the Mess . . . . . . . . . . . . . . . . . . . . . . . . . 306
13.12 Conclusion and Omissions . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
13.13 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309