Connector Corner: Accelerate revenue generation using UiPath API-centric busi...
Errata file oop_via_f90
1. Errata File "OOP via F90"
This is only the beginning of an errata for the text based on comments
from readers. As of June 2004 I have not yet verified the suggested
errors. I hope to review them when I start the summer break in July
2004. Please feel free to send your comments. Prof. Akin
The Errata will cite pages in the published book, which will differ
from the PDF drafts here, especially for Chapter 9.
------------------------------- 1 --------------------------------------
One reviewer suggests that the source code line numbers should be
moved from the left margin to the right margin. This will be done in
any future release.
------------------------------- 2 --------------------------------------
Date: Fri, 4 Jul 2003 19:40:51 +0100
From: Alistair Mills
To: akin@rice.edu
Subject: Object oriented Fortran 90
Professor Akin
I have just come across your very interesting book. I think that this is a
book which has been waiting to be written! It is very interesting. I hope
that you will not be offended by what I have to say. It is intended to be
constructive. Your book is a very readable account of the subject, and is
much more comprehensible than other things which I have read on the same
matter! I do not know how you can find time to be a professor at a major
school of engineering, do research, and write such things also!
I have also found your web site, and I have found that you have indexes to
the figures and the files. This is very helpful, as it was taking me time
to work out which source code files correspond to the text. I found that
the page numbers are not correct, but the figure numbers are approximately
correct. For example, I have changed the page numbers for chapter 7, and a
couple of the figure numbers. I will send you a complete updated index, if
you are interested. That would then agree with the published page numbers.
class_Stack.f90 7.2 160 *** See expanded list below ***
stack_check.f90 7.3 161
class_Queue.f90 7.5 163
queue_check.f90 7.6 165
singly_linked_list.f90 7.10 169
Test_SLL_Integers.f90 7.11 171
Integer_Objects.f90 7.12 172
doubly_linked_list.f90 7.14 173
Test_DLL_Integers.f90 7.15 175
random_access.f90 7.16 176
interface_Queue Section_7.3
exceptions.f90 none
object_type.f90 none
I have also observed a couple of coding errors. There is quite a serious
one in chapter 7.
Test_DLL_Integers.f90 7.15 175
2. Line 156 should read as follows:
point_to_Obj_3 => Get_Ptr_to_Obj (container, Obj_3) ! There is also an
error on the printed version on this line [20] and [21]
Rather than:
point_to_Obj_3 = Get_Ptr_to_Obj (container, Obj_3)
The program fails at run time when using both DVF 6.6 and Intel 7.0. The
error is a common one. The assignment statement on the original attempts to
copy the contents of the object at the end of the pointer to the contents of
the object at the end of point_to_Obj_3. As there is nothing yet on the end
of point_to_Obj_3, the run time system fails with an access violation.
There is also an error in chapter 4. Line 19 of passing_types.f90 is "call
by value". Fortran only does call by address. If you change line 19 to
eliminate the additional parentheses, then the results are different. The
parentheses force the creation of a temporary location containing a copy of
Input_val. The value in the temporary location is changed, but this is not
copied back to the source ie Input_Val. So the effect is the same, although
the reasons are different.
! pass by value
call No_Change ( Input_Val ) ! Use but do not change
print *, "After No_Change it is ", Input_Val
If you find what I have to say constructive, then I may have more when I
have completed reading the book!
With best wishes
Alistair Mills
------------------------------- 3 te: Tue, 8 Jul 2003 20:10:48 +0100
From: Alistair Mills
To: 'Ed Akin 221 Cox x4879' <akin@mems.rice.edu>
Subject: RE: Object oriented Fortran 90
Prof Akin
Thanks for pointing out the link, and thank you for including my comments.
Here is my version of the source code index.
Alistair
Source Figure Page
hello.c 1.3 09
hello.cpp 1.3 09
hello.f90 1.3 09
hello.m 1.3 09
Math_Constants.f90 2.1 29
Fibonacci.f90 2.6 34
create_a_type.f90 Section_2.2 29
use_a_type.f90 Section_2.2 30
Geometric_Classes.f90 3.3,3.4 39
4. 6.12 146
6.13 147
6.14 148
6.15 149
6.16 150
Test_Is_A_Member.f90 6.17 153
member_1_class.f90 6.18 153
member_2_class.f90 6.19 154
is_a_member_class.f90 6.20 155
class_Stack.f90 7.1 160
stack_check.f90 7.3 161
class_Queue.f90 7.5 163
queue_check.f90 7.6 165
singly_linked_list.f90 7.10 169
Test_SLL_Integers.f90 7.11 171
Integer_Objects.f90 7.12 172
doubly_linked_list.f90 7.14 173
Test_DLL_Integers.f90 7.15 175
random_access.f90 7.16 176
interface_Queue Section_7.3
exceptions.f90 none
object_type.f90 none
trans_opt.f90 8.1 191
Matrix_Operators.f90 none
array_demo.f90 none
display_real.f90 none
elem_type_data_class.f90 9.1 210
memory_leak.f90 9.2 212
No_Copy_Reallocate.f90 9.4 214
9.6 219
System_Constants.f90 none
------------------------------- 4 ---------------------------------
Date: Sun, 20 Jun 2004 03:56:44 -0700 (PDT)
From: Wayne B'Rells
To: akin@rice.edu
Subject: Errata for "OO Programming via Fortran 90/95"?
Dear Dr. Akin:
I recently picked up your book on OO programming with Fortran 90/95. I have
only read up to section 2.4, but have discovered a few errors in the text and
in the sample programs. Specifically, line [19] of the Fibonacci example
(Figure 2.6 ) references 'num%exists', which does not exist in the definition
of the 'Fibonacci_Number' type. This new logical variable is also mentioned
in the text, but not seem to be USED in the code.
Would you, perhaps, have an Errata listing for your book? (Such a listing of
corrections would make it a bit easier to follow some of your examples...)
BTW, I will be converting many of your examples so they can be compiled with
the 'F' compiler. This compiler seems to include all the new F90/95 features,
but leaves out those F77 constructs which are now redundant.
Hoping to hear from you,
5. Wayne B'Rells
Schenectady, NY
------------------------------- 5 ---------------------------------
Date: Mon, 21 Jun 2004 05:16:37 -0700 (PDT)
From: Wayne B'Rells
To: Ed Akin 221 Cox x4879 <akin@is.rice.edu>
Subject: Re: Errata for "OO Programming via Fortran 90/95"?
Dr. Akin:
I was able able to look at the 'errata', but did not notice my specific
problem. On the other hand, the code on the CD was correct in that it did NOT
include any reference to "num%exists".
FYI, the homepage for the F compiler is: http://www.swcp.com/~walt/
As I see it, the major advantages of the F compiler are:
1) It is free.
2) It is available for both the PC and Unix.
3) It FORCES users to strictly adhere to Fortran 90/95 coding practices and
to explicitly declare all variables, access privileges, etc. This seems
particularly desirable from a pedagogical point of view.
My "conversion" of the Fibonaccci example to F did suggest a few places where
the code could be "cleaned up" a bit:
1) The "implicit none" statements in the contained functions of the
"class_Fibonacci_Number" module were flagged as errors by the F compiler.
According to the Metcalf & Reid book ("Fortran 90/95 Explained"): "...and if
there is an implicit none statement there must be no other implicit statement
in the scoping unit." In other words, the implicit none statement at the
module level is inherited by the contained functions via host association. (I
suspect that many F90 compilers just treat the extra implicit none statements
as redundant and ignore them...)
2) In F, all contained functions must be explicitly given the 'public' or
'private' access attribute. Therefore, I had to add 'new_Fibonacci_Number' to
the list of public module functions.
3) In F, the 'intent' of all dummy arguments must be specified. Therefore, I
had to add "intent(in)" to the list of attributes for the 'max' argument in
the 'new_Fibonacci_Number' function.
These were the major modifications that I found necessary. The minor changes
included:
1) Putting only one statement per line
2) Changing ' to ".
3) Putting output formats directly in the write statements
Best wishes,
Wayne------------------------------- 6 ---------------------------------
6. Object Oriented Programming
via Fortran 90/95
Ed Akin
Rice University
Mechanical Engineering and Materials Science Department
Houston, Texas
May 29, 2001
Draft # 4.2, Copyright c 2001, All rights reserved.
11. Preface
There has been an explosion of interest in, and books on object-oriented programming (OOP). Why have
yet another book on the subject? In the past a basic education was said to master the three r’s: reading,
’riting, and ’rithmetic. Today a sound education in engineering programming leads to producing code that
satisfy the four r’s: readability, reusability, reliability, and really-efficient. While some object-oriented
programming languages have some of these abilities Fortran 90/95 offers all of them for engineering
applications. Thus this book is intended to take a different tack by using the Fortran 90/95 language as its
main OOP tool. With more than one hundred pure and hybrid object-oriented languages available, one
must be selective in deciding which ones merit the effort of learning to utilize them. There are millions
of Fortran programmers, so it is logical to present the hybrid object-oriented features of Fortran 90/95 to
them to update and expand their programming skills. This work provides an introduction to Fortran 90
as well as to object-oriented programming concepts. Even with the current release (Fortran 95) we will
demonstrate that Fortran offers essentially all of the tools recommended for object-oriented programming
techniques. It is expected that Fortran 200X will offer additional object-oriented capabilities, such as
declaring ”extensible” (or virtual) functions. Thus, it is expected that the tools learned here will be of
value far into the future.
It is commonly agreed that the two decades old F77 standard for the language was missing several
useful and important concepts of computer science that evolved and were made popular after its release,
but it also had a large number of powerful and useful features. The following F90 standard included
a large number of improvements that have often been overlooked by many programmers. It is fully
compatible with all old F77 standard code, but it declared several features of that standard as obsolete.
That was done to encourage programmers to learn better methods, even though the standard still supports
those now obsolete language constructs. The F90 standards committee brought into the language most of
the best features of other more recent languages like Ada, C, C++, Eiffel, etc. Those additions included in
part: structures, dynamic memory management, recursion, pointers (references), and abstract data types
along with their supporting tools of encapsulation, inheritance, and the overloading of operators and
routines. Equally important for those involved in numerical analysis the F90 standard added several new
features for efficient array operations that are very similar to those of the popular M ATLAB environment.
Most of those features include additional options to employ logical filters on arrays. All of the new array
features were intended for use on vector or parallel computers and allow programmers to avoid the bad
habit of writing numerous serial loops. The current standard, F95, went on to add more specific parallel
array tools, provided “pure” routines for general parallel operations, simplified the use of pointers, and
made a few user friendly refinements of some F90 features. Indeed, at this time one can view F90/95 as
the only cross-platform international standard language for parallel computing. Thus Fortran continues
to be an important programming language that richly rewards the effort of learning to take advantage of
its power, clarity, and user friendliness.
We begin that learning process in Chapter 1 with an overview of general programming techniques.
Primarily the older “procedural” approach is discussed there, but the chapter is closed with an outline of
the newer “object” approach to programming. An experienced programmer may want to skip directly to
the last section of Chapter 1 where we outline some object-oriented methods. In Chapter 2, we introduce
the concept of the abstract data types and their extension to classes. Chapter 3 provides a fairly detailed
introduction to the concepts and terminology of object-oriented programming. A much larger supporting
glossary is provided as an appendix.
For the sake of completeness Chapter 4 introduces language specific details of the topics discussed in
2002
c J.E. Akin i
12. the first chapter. The Fortran 90/95 syntax is used there, but in several cases cross-references are made to
similar constructs in the C++ language and the M ATLAB environment. While some readers may want to
skip Chapter 4, it will help others learn the Fortran 90/95 syntax and/or to read related publications that
use C++ or M ATLAB. All of the syntax of Fortran 90 is also given in an appendix.
Since many Fortran applications relate to manipulating arrays or doing numerical matrix analysis,
Chapter 5 presents a very detailed coverage of the powerful intrinsic features Fortran 90 has added to
provide for more efficient operations with arrays. It has been demonstrated in the literature that object-
oriented implementations of scientific projects requiring intensive operations with arrays execute much
faster in Fortran 90 than in C++. Since Fortran 90 was designed for operations on vector and parallel
machines that chapter encourages the programmer to avoid unneeded serial loops and to replace them
with more efficient intrinsic array functions. Readers not needing to use numerical matrix analysis may
skip Chapter 5.
Chapter 6 returns to object-oriented methods with a more detailed coverage of using object-oriented
analysis and object-oriented design to create classes and demonstrates how to implement them as an OOP
in Fortran 90. Additional Fortran 90 examples of inheritance and polymorphism are given in Chapter
7. Object-oriented programs often require the objects to be stored in some type of “container” or data
structure such as a stack or linked-list. Fortran 90 object-oriented examples of typical containers are
given in Chapter 8. Some specialized topics for more advanced users are given in Chapter 9, so beginning
programmers could skip it.
To summarize the two optional uses of this text; it is recommended that experienced Fortran program-
mers wishing to learn to use OOP cover Chapters 2, 3, 6, 7, 8, and 9, while persons studying Fortran for
the first time should cover Chapters 1, 2, 3, and. Anyone needing to use numerical matrix analysis should
also include Chapter 5.
A OO glossary is included in an appendix to aid in reading this text and the current literature on OOP.
Another appendix on Fortran 90 gives an alphabetical listing on its intrinsic routines, a subject based
list of them, a detailed syntax of all the F90 statements, and a set of example uses of every statement.
Selected solutions for most of the assignments are included in another appendix along with comments
on those solutions. The final appendix gives the C++ versions of several of the F90 examples in the
text. They are provided as an aid to understanding other OOP literature. Since F90 and M ATLAB are so
similar the corresponding M ATLAB versions often directly follow the F90 examples in the text.
Ed Akin, Rice University, 2002
Acknowledgements
We are all indebted to the hundreds of programmers that labor on various standards committees to con-
tinually improve all programming languages. Chapter 1 is a modification of introductory programming
notes developed jointly with Prof. Don Johnson at Rice University. I would like to thank Prof. Tinsley
Oden and the Texas Institute for Computational Mathematics for generously hosting my sabbatical leave
where most of this work was developed, and Rice University for financing the sabbatical. Special thanks
go to my wife, Kimberly, without whose support and infinite patience this book would not have been
completed.
Source Codes
All of the example programs and selected solutions are included on the CD-ROM provide with the book.
To be readable on various platforms they have been written with the ISO9660 standard format. Additional
files are provided to relate the ISO standard short filenames to the full length program names used in the
book. Of course, the source files will have to be processed through a Fortran 90 or 95 or 2000 compiler
to form executables. All of the figures are also provided as encapsulated Postscript (tm) files.
2002
c J.E. Akin ii
17. binary, 183 dot Vector, 255, 259
column count, 99 Drill , 104, 106
direct access, 150 D L new, 149
I/O, 151 el by el Mult, 259
internal, 80 equality operator point, 188
line count, 99 equal to Object, 143
modify, 151 gcd, 42, 101
random, 151 getEmployee, 123, 124
random access, 150 getName, 123
read status, 99 getNameE, 122, 124
record number, 150 getNameM, 123, 124
scratch, 183 getRate, 122, 124
unit number, 100 GetX, 188
FILE= specifier, 271 GetY, 188
finite difference method, 179 get Arc, 112
finite element, 43 Get Capacity of Q, 140
finite element analysis, 181 get Denominator, 42
flip, 163, 166 get element, 260
float, 53 Get Front of Q, 140
floating point, see real, 23, 24, 179 get item cost, 264
FLOOR function, 56, 162 get item count, 264
flow control, 11, 51, 58 get item delay, 264
forever loop, see infinite loop get item name, 264
FORM= specifier, 271 get Latitude, 112
FORMAT statement, 34, 112 Get Length of Q, 140, 142
function, 7, 9, 51, 68 get Longitude, 112
argument, 13, 15 get menu, 273
extensible, 130 get mr rate, 104
generic, 183 get next io unit, 102, 269
INTEGER, 140 Get Next Unit, 98
LOGICAL, 137, 140 get Numerator, 42
recursive, 42, 101 Get Obj at Ptr, 149
result, 69 get Person, 37
return, 13 get person, 37
TYPE, 137, 140 Get Ptr to Obj, 149
variable, 15 get torque, 104
function code Global Position , 112
Add, 29 Great Arc , 112
add Rational, 42 initialize item, 264
add Real to Vector, 253 inputCount, 92, 265
add Vector, 253 Int deg, 112
Angle , 112 Int deg min, 112
assign, 253 Int deg min sec, 112
circle area, 34 is equal to, 42, 255, 260
clip, 69 is item empty, 264
convert, 42 Is Q Empty, 140
copy Rational, 42 is Q Empty, 142
copy Vector, 254 Is Q Full, 140
Create Q, 140 is Q Full, 142
Date , 37 is Stack Empty, 137
Decimal min, 112 is Stack Full, 137
Decimal sec, 112 is S L empty, 143
Default Angle, 112 largest index, 260
2002
c J.E. Akin 5
18. length, 260 values of, 263
lengthnormalize Vector, 255 Vector , 255
less than Object, 143 Vector max value, 255, 263
make Person, 37 Vector min value, 255, 263
make Professor, 121 Vector mult real, 255
make Rational, 42 Vector To Sparse, 263
make Rectangle, 36 zero sparse, 263
make Stack, 137 function definition, 288
make Student, 37 FUNCTION statement, 29
make Vector, 253
Manager , 123, 124 Game of Life, 4
maximum, 70 Gamma, 25
mid value, 69 gather-scatter, 168
mult Fraction, 86 gcd, see greatest common divisor
mult Rational, 42 generic function, 33, 34, 183, 288
new Fibonacci Number, 29 generic interface, 132
next generation, 251 generic linked list, 149
norm, 262 generic name, 34
normalize Vecto, 262 generic object, 42
pay, 123 generic operator, 288
payE, 122, 124 generic routine, 121
payM, 123, 124 generic subprogram, 76
Person, 121 geometric shape, 34
Person , 37 global positioning satellite, 106
pop from Stack, 137 global variable, 14, 72
GO TO statement, 64, 65
print, 121
GPS, see global positioning satellite
Professor, 121
Graham method, 18
Rational, 42
graphical representation, 27, 118
Rational , 42
greatest common divisor, 42, 101
real mult Sparse, 262
greatest integer, 162
real mult Vector, 255
grid, 190
rectangle area, 34
rows of, 262 Has-A, 107, 194
setDataE, 122, 124 header file, 129
setDataM, 123, 124 heat transfer, 185
set Date, 37 Hello world, 7
set Lat and Long at, 112 hello world, 52, 100
size of, 262 hierarchie
size Vector, 255 kind of, 18
Sparse mult real, 262 part of, 18
Student, 37, 121 High Performance Fortran, 195
Student , 37 horizontal tab, 77
subtract Real, 255 host association, 288
subtract Vector, 255 Hubbard, J.R., 36
Sub Sparse Vectors, 263 HUGE function, 162
Sum Sparse Vectors, 263 hyperbolic cosine, 56, 162
S L new, 143 hyperbolic sine, 56, 162
toc, 72 hyperbolic tangent, 56, 102, 162
to Decimal Degrees, 112
to lower, 80 I/O, see Input-Output
to Radians, 112 IACHAR function, 77, 80
to upper, 80, 100, 266 ICHAR function, 77
values, 255 identity matrix, 178
2002
c J.E. Akin 6
25. structured programming, 13 mult Fraction, 86
submatrix, 171 MyPrint Point, 188
subprogram, 68 new, 131
recursive, 101 new member 1, 131
subroutine, 68, 69 new member 2, 131
subroutine code No Change, 76
Add to Q, 140, 142 nullify Is A Member, 131
allocate type application, 181 orthonormal basis, 257
Alloc Count Int, 183 out, 104, 106
assign, 86, 131 pretty, 262
assign memb 1, 131 Print, 29
assign memb 2, 131 print, 121
Change, 76 PrintPay, 123, 124
deallocate type application, 181 PrintPayEmployee, 123, 124
Dealloc Count Int, 183 PrintPayManager, 123, 124
delete Rational, 42 print Date, 37
delete Sparse Vector, 258 print DOB, 37
delete Vector, 255 print DOD, 37
destroy D L List, 149 print DOM, 37
detroy D L List, 149 print D L list, 149
display all, 271 print GPA, 37
display members, 131 print item, 264
display memb 1, 131 print Name, 37
display memb 2, 131 print Nationality, 37
D L insert before, 149 print Sex, 37
enter entry, 272 print S L list, 143
enter item, 264 push on Stack, 137
enter update, 272 readData, 92, 100, 266
equal Fraction, 86 read Date, 37
equal Integer, 42 Read Position Angle, 112
equal Real, 255 read Vector, 255, 262
equal Vector, 260 read xy file, 268
exception, 137, 140 reduce, 42
exception status, 75, 142 Remove from Q, 142
file read, 264 Resize Count Int OneD, 183
file write, 264 restore system, 271
in, 104, 106 save system, 271
increase Size, 271 setData, 123
initialize, 272 setSalaried, 123, 124
Init Point, 188 set DOB, 37
Init Point Another, 188 set DOD, 37
Init Point Vctr, 188 set DOM, 37
Integer Sort, 95, 97, 98 set element, 262
invert, 42 set Latitude, 112
list, 42, 86, 255 set Longitude, 112
List Angle, 112 Set Point, 188
List Great Arc, 112 set Size, 271
List Position, 112 Set Vec, 188
List Position Angle, 112 Set X, 188
List Pt to Pt, 112 Set XY, 188
list type alloc status, 181 show, 262
lsq fit, 92 show Data, 97
make Sparse Vector, 258 show r v, 262
2002
c J.E. Akin 13
26. simple arithmetic, 56 triplet, see colon operator
Sort Reals, 93 true, 12
Sort String, 94 TRUE result, 62
Spy, 251 truncate to real whole number, 162
String Sort, 97, 98 truss, 166
swap objects, 126 type
swap real, 127 conversion, 80
swap type, 128 default, 52
S L delete, 143 implicit, 52
S L insert, 143 TYPE declaration, 26, 29
testing basis, 257 TYPE statement, 27, 34
test Manager 1, 123
test matrix, 89 unary operator, 292
tic, 72 underflow, 292
SUBROUTINE statement, 29 unexpected result, 165
subroutines, 33 upper triangle, 171, 174
subscript, 26, 59, 155 USE association, 119, 123, 190
bounds, 155 USE statement, 29, 33, 34, 37, 85, 89
range, 177 USE, ONLY, 119
vector, 166 user defined operator, 165
subscript triplet, 291 user interface, 2
subtraction, 56
subtype, 131 validation, 29
subtyping, 124, 130 variable, 8, 10, 23, 51
sum, 12 global, 14
SUM function, 12, 69, 162 name, 10
SUM intrinsic, 92, 165 type, 10
sum of array elements, 162 variable rank array, 156
super class, 119 vector, 155, 292
syntactic error, 17 vector class, 48, 179, 252, 256
SYSTEM CLOCK intrinsic, 72 vector subscript, 61, 166, 292
VERIFY function, 77
tab, 78, 98, 102 volume, 48
TAN function, 56, 162
tangent, 56, 162 weakness, 193
TANH function, 56, 162 WHERE construct, 165
TARGET, 15 WHERE statement, 61, 66, 165
target, 23, 75, 87, 88, 292 while-true, 67
template, 43, 124, 126, 292 wildcard, 126
tensor, 155 WRITE statement, 34, 61, 75
testing, 15
time, 265
time of day, 99
TINY function, 162
Toeplitz matrix, 171
top-down, 4
total of elements in array, 162
transformational functions, 165
transpose, 159, 171, 173
TRANSPOSE intrinsic, 162, 166
tree, 292
tree structure, 38, 87, 88
tridiagonal matrix, 179
TRIM function, 77
2002
c J.E. Akin 14
27. Chapter 1
Program Design
1.1 Introduction
The programming process is similar in approach and creativity to writing a paper. In composition, you
are writing to express ideas; in programming you are expressing a computation. Both the programmer
and the writer must adhere to the syntactic rules (grammar) of a particular language. In prose, the funda-
mental idea-expressing unit is the sentence; in programming, two units statements and comments are
available.
Standing back, composition from technical prose to fiction should be organized broadly, usually
through an outline. The outline should be expanded as the detail is elaborated, and the whole re-examined
and re-organized when structural or creative flaws arise. Once the outline settles, you begin the actual
composition process, using sentences to weave the fabric your outline expresses. Clarity in writing
occurs when your sentences, both internally and globally, communicate the outline succinctly and clearly.
We stress this approach here, with the aim of developing a programming style that produces efficient
programs that humans can easily understand.
To a great degree, no matter which language you choose for your composition, the idea can be ex-
pressed with the same degree of clarity. Some subtleties can be better expressed in one language than
another, but the fundamental reason for choosing your language is your audience: People do not know
many languages, and if you want to address the American population, you had better choose English
over Swahili. Similar situations happen in programming languages, but they are not nearly so complex
or diverse. The number of languages is far fewer, and their differences minor. Fortran is the oldest lan-
guage among those in use today. C and C++ differ from it somewhat, but there are more similarities
than not. M ATLAB’s language, written in C and Fortran, was created much later than these two, and its
structure is so similar to the others that it can be easily mastered. The C++ language is an extension of
the C language that places its emphasis on object oriented programming (OOP) methods. Fortran added
object oriented capabilities with its F90 standard, and additional enhancements for parallel machines
were issued with F95. The Fortran 2000 standard is planned to contain more user-friendly constructs for
polymorphism and will, thus, enhance its object-oriented capabilities. This creation of a new language
and its similarity to more established ones are this book’s main points: More computer programming lan-
guages will be created during your career, but these new languages will probably not be much different
than ones you already know. Why should new languages evolve? In MATLAB’s case, it was the desire to
express matrix-like expressions easily that motivated its creation. The difference between M ATLAB and
Fortran 90 is infinitesimally small compare to the gap between English and Swahili.
An important difference between programming and composition is that in programming you are writ-
ing for two audiences: people and computers. As for the computer audience, what you write is “read” by
interpreters and compilers specific to the language you used. They are very rigid about syntactic rules,
and perform exactly the calculations you say. It is like a document you write being read by the most de-
tailed, picky person you know; every pronoun is questioned, and if the antecedent is not perfectly clear,
then they throw up their hands, rigidly declaring that the entire document cannot be understood. Your
picky friend might interpret the sentence “Pick you up at eight” to mean that you will literally lift him or
her off the ground at precisely 8 o’clock, and then demand to know whether the time is in the morning or
2001
c J.E. Akin 1
28. afternoon and what the date is.
Humans demand even more from programs. This audience consists of two main groups, whose goals
can conflict. The larger of the two groups consists of users. Users care about how the program presents
itself, its user interface, and how quickly the program runs, how efficient it is. To satisfy this audience,
programmers may use statements that are overly terse because they know how to make the program more
readable by the computer’s compiler, enabling the compiler to produce faster, but less human-intelligible
program. This approach causes the other portion of the audience programmers to boo and hiss. The
smaller audience, of which you are also a member, must be able to read the program so that they can
enhance and/or change it. A characteristic of programs, which further distinguishes it from prose, is
that you and others will seek to modify your program in the future. For example, in the 1960s when
the first version of Fortran was created, useful programs by today’s standards (such as matrix inversion)
were written. Back then, the user interface possibilities were quite limited, and the use of visual displays
was limited. Thirty years later, you would (conceivably) want to take an old program, and provide a
modern user interface. If the program is structurally sound (a good outline and organized well) and is
well-written, re-using the “good” portions is easy accomplished.
The three-audience situation has prompted most languages to support both computer-oriented and
human-oriented “prose”. The program’s meaning is conveyed by statements, and is what the computer
interprets. Humans read this part, which in virtually all languages bears a strong relationship to mathe-
matical equations, and also read comments. Comments are not read by the computer at all, but are there
to help explain what might be expressed in a complicated way by programming language syntax. The
document or program you write today should be understandable tomorrow, not only by you, but also by
others. Sentences and paragraphs should make sense after a day or so of gestation. Paragraphs and larger
conceptual units should not make assumptions or leaps that confuse the reader. Otherwise, the document
you write for yourself or others served no purpose. The same is true with programming; the program’s
organization should be easy to follow and the way you write the program, using both statements and com-
ments, should help you and others understand how the computation proceeds. The existence of comments
permits the writer to directly express the program’s outline in the program to help the reader comprehend
the computation.
These similarities highlight the parallels between composition and programming. Differences become
evident because programming is, in many ways, more demanding than prose writing. On one hand, the
components and structure of programming languages are far simpler than the grammar and syntax of any
verbal or written language. When reading a document, you can figure out the misspelled words, and not
be bothered about every little imprecision in interpreting what is written. On the other, simple errors, akin
to misspelled words or unclear antecedents, can completely obviate a program, rendering it senseless or
causing it to go wildly wrong during execution. For example, there is no real dictionary when it comes
to programming. You can define variable names containing virtually any combination of letters (upper
and lower case), underscores, and numbers. A typographical error in a variable’s name can therefore
lead to unpredictable program behavior. Furthermore, computer execution speeds are becoming faster
and faster, meaning that increasingly complex programs can run very quickly. For example, the program
(actually groups of programs) that run NASA’s space shuttle might be comparable in size to Hugo’s Les
Mis´ rables, but its complexity and immediate importance to the “user” far exceeds that of the novel.
e
As a consequence, program design must be extremely structured, having the ultimate intentions of
performing a specific calculation efficiently with attractive, understandable, efficient programs. Achiev-
ing these general goals means breaking the program into components, writing and testing them separately,
then merging them according to the outline. Toward this end, we stress modular programming. Modules
can be on the scale of chapters or paragraphs, and share many of the same features. They consist of a se-
quence of statements that by themselves express a meaningful computation. They can be merged to form
larger programs by specifying what they do and how they interface to other packages of software. The
analogy in prose is agreeing on the character’s names and what events are to happen in each paragraph
so that events happen to the right people in the right sequence once the whole is formed. Modules can be
re-used in two ways. As with our program from the 1960s, we would “lift” the matrix inversion routine
and put a different user interface around it. We can also re-use a routine within a program several times.
For example, solving the equations of space flight involves the inversion of many matrices. We would
2001
c J.E. Akin 2
![Line 156 should read as follows:
point_to_Obj_3 => Get_Ptr_to_Obj (container, Obj_3) ! There is also an
error on the printed version on this line [20] and [21]
Rather than:
point_to_Obj_3 = Get_Ptr_to_Obj (container, Obj_3)
The program fails at run time when using both DVF 6.6 and Intel 7.0. The
error is a common one. The assignment statement on the original attempts to
copy the contents of the object at the end of the pointer to the contents of
the object at the end of point_to_Obj_3. As there is nothing yet on the end
of point_to_Obj_3, the run time system fails with an access violation.
There is also an error in chapter 4. Line 19 of passing_types.f90 is "call
by value". Fortran only does call by address. If you change line 19 to
eliminate the additional parentheses, then the results are different. The
parentheses force the creation of a temporary location containing a copy of
Input_val. The value in the temporary location is changed, but this is not
copied back to the source ie Input_Val. So the effect is the same, although
the reasons are different.
! pass by value
call No_Change ( Input_Val ) ! Use but do not change
print *, "After No_Change it is ", Input_Val
If you find what I have to say constructive, then I may have more when I
have completed reading the book!
With best wishes
Alistair Mills
------------------------------- 3 te: Tue, 8 Jul 2003 20:10:48 +0100
From: Alistair Mills
To: 'Ed Akin 221 Cox x4879' <akin@mems.rice.edu>
Subject: RE: Object oriented Fortran 90
Prof Akin
Thanks for pointing out the link, and thank you for including my comments.
Here is my version of the source code index.
Alistair
Source Figure Page
hello.c 1.3 09
hello.cpp 1.3 09
hello.f90 1.3 09
hello.m 1.3 09
Math_Constants.f90 2.1 29
Fibonacci.f90 2.6 34
create_a_type.f90 Section_2.2 29
use_a_type.f90 Section_2.2 30
Geometric_Classes.f90 3.3,3.4 39](data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7)