Numerical Methods in Scientific Computing I
Math 2070 is our gateway course in computational
mathematics.
Syllabus for Fall 2008
Welcome to Math 2070!
Numerical Methods in Scientific Computing
This is the first part of the sequence Math 2070, 2071 and is
introduction
_to numerical methods and the fundamentals of the analysis (stability,
consistency, _convergence, efficiency and accuracy) of numerical
methods.
The course covers both _theoretical and practical aspects of the methods.
Math 2070 covers _numerical analysis except numerical linear algebra
and
numerical Diff Eqs and Math 2071 covers _the remainder,
Math 2070: CRN 13384 _Lecture: MW 3-4:15Ty. 704 ,
Recitation: CRN 16072
MW 4:20-5:35 in GSCC 126
Lab Instructor is Dr. Mike Sussman .
Dr.
Mike Sussman .
Labs are available
online.
Labs are
available online. _ MATLAB will be taught in the lab and used for the
labs. _
Office: Ty. 603, (412)
624-8312 _E-mail: W J L at P I T T dot E D U
_http://www.math.pitt.edu/~wjl _ _
Course materials:
The main course material will be lecture notes from
the lectures in class. Attend and take good notes!
You might find some
material presented simpler than in the text,
some differently than the
text, some small extensions and omissions from the text. The topics are
standard so variations will be minor rather than major. My lecture notes
have evolved through the search for the simplest mathematically rigorous
way to explain WHY and HOW and WHEN and WHEN NOT algorithms that are
important for practical computing work.
Textbooks are only useful when they give the same topics from a different
point of view than the lectures. (This will not be a course where the
teacher puts the book on the board.)
The official text is:
A Ralston and P
Rabinowitz, A first course in Numerical Analysis, Dover reprint, 2001,
an
excellent and inexpensive book. Many years Atkinson's book is used here,
K. Atkinson, An Introduction to Numerical Analysis, 2nd Ed,
also an
excellent book but more expensive.
Course Grades: _Lab grade= 30% _Mid-Term Exam=20% _Final Exam= 20%
_Homework= 30%
Misc. General Policies:
Make Up Exams will NOT be given.
HW will be
collected and graded.
You are not graded on what you can prove.
You are
graded on what your explanation of a proof conveys
in a clear and direct
manner to others.
Write in complete and correctly punctuated sentences.
Avoid intoxication with the symbols of symbolic logic.
(Write for
people
not for automatons!)
Negative partial credit is possible for extraneous
and irrelevant nonsensical information.
No quibbling over "points"; Focus
on learning!
Matlab
Primer
Matlab Tutorial: Postscript;
HTML
For useful material related to this course go to Kendall Atkinson's class web page
Accessing MATLAB Remotely
Dr. Sussman
has graciously provided instructions for accessing Matlab remotely.
The first answer
is: Yes, Matlab can be accessed remotely using your usual network access.
I am not familiar with
"PittNet" -- is
it a dialup connection (slow) or some
sort of fast
connection?
In either case, directions follow.
ASSUMING YOU ARE
USING LINUX or another type of Unix:
Use ssh to get to
unixs1 or unixs2, type "matlab": example
ssh
youraccountname@unixs2.cis.pitt.edu
password
matlab
Wait a long while
(1-2 minutes for a fast connection,
a looooong time
for dialup) and Matlab will come up.
WARNING: if
you have a (slow) dialup connection, you can
turn off the
graphical
stuff and run matlab in command mode:
(you get no
graphics
and no plotting)
ssh
YoUrAcCoUnTnAmE@unixs2.cis.pitt.edu
password
DISPLAY=
matlab
If you have a dialup
and you want plotting but no gui, do NOT
reset DISPLAY to
nothing. Just do:
matlab -nosplash
-nojvm
If you turn off the
gui, you will need some sort of editor.
Either open another
ssh session with your favorite editor
in it (pico, vi,
emacs, etc.) or use the exclamation point
to start an editor
from the Matlab command line (!pico ...)
ASSUMING YOU ARE
USING WINDOWS
You either have
an "X-server" program or you don't. I do
not know whether
one is included in the programs they supply
to students.
ASSUMING YOU
HAVE A DIALUP CONNECTION OR YOU DO NOT HAVE AN X-server
Use the Start->Run
menu and type
telnet
unixs2.cis.pitt.edu
(or unixs1 or
unixs)
It will ask you
to log in. Then just type
matlab
to get the LINE
version of Matlab (no graphics, no plotting). There
is no way to do
plotting without an X-server. You also will not have
the Matlab editor,
but you can edit a file FROM THE MATLAB COMMAND
LINE with the
command
"!pico filename.m" where you don't type the
quotation marks
and you put your own name where I have "filename.m".
When you exit pico,
you will return to Matlab.
ASSUMING YOU HAVE
BOTH AN X-server AND A FAST CONNECTION
Start the X-server
first. You will need to know the "display" name
It will be
something
like 192.160.1.1:0 (your IP address first, then
colon zero).
Use the Start->Run
menu and type
telnet
unixs2.cis.pitt.edu
username, password,
etc.
DISPLAY=192.160.1.1:0
EXPORT
DISPLAY
matlab
There might be a
telnet or rlogin or ssh command that comes with
the X-server. If
so, the DISPLAY variable is automatically set.
REMARK:
There is a free
Matlab clone called "octave" that runs on Windows
(If you run linux,
install it from your CDs). See
http://octave.sourceforge.net/Octave_Windows.htm
It is not so pretty
as Matlab, and it is mostly command-line
driven, but it will
do plotting and most simple stuff.
If you have experience programming in FORTRAN or C,
the
least painful way to migrate to MATLAB is to begin by using MATLAB
as a low
level programming language and then learn the higher level features
as you need them.
These notes below were prepared by Dr. M. Sussman for exactly that
purpose.
For that reason, they parallel "A Synopsis of 5 statement
FORTRAN".
1. INTRODUCTION: Matlab Statements.
You can use "%" anywhere on a line to make Matlab skip
everything you write past the "%". This is
called "commenting it out."
Ending a line without a semicolon (";") means its result will
be printed. Ending a line with a semicolon means it will not
be printed.
Types of Variables.
All simple variables in Matlab are actually complex matrices.
Matlab tries to "treat them the way you meant them." Variable
names are case sensitive, so iT is different from It is
different from IT is different from it.
Arithmetic Operations.
These are denoted by the
usual symbols
+, -, , / and *
Exponentiation is denoted by ^
The arithmetic equals (=) has a different meaning than in arithmetic.
For
example, the statement
X=X+1.0;
makes perfect sense in Matlab. It means, look at the left hand side,
find
the storage location set aside to store the variable called X and find
the
value of X. Add one to that value then put the result back in the X
storage location. This requires the computer to do something; hence,
it is
called an executable statement. (It's described informally by: "look
in
the box marked X. Get the number there; add one to it and put it back
in
the X box.")
CONTROL STATEMENTS
Simply typing a variable name on a line by itself without a semicolon
after
it will cause it to be printed. A sequence of variables
separated
by
commas will all be printed.
Anything put in quotation marks is printed directly as written.
Examples
of this are given later.
2. The Heart of the Program.
A computed basically can only do 5 things:
* Input data,
* perform arithmetic calculations,
* decisions based on logical or arithmetic tests,
* output data and
* loop (meaning perform al the above iteratively).
We've seen how to perform basic arithmetic calculations. Let's now
review
some of the remainder. The real power of the computer is unleashed
with
loops (doing a lot of calculations) and matrices and vectors (handling
a
lot of data).
INPUT, OUTPUT and CONTROL
A single variable can be read from the keyboard using the command
r=input('What is the value?')
and the string 'What is the value?' will be printed and then the user
will type a number and the value of that number will become the value
of r.
DECISIONS.
Decisions in Matlab are
performed by "IF tests." There are many
kinds. One basic kind takes the form
if (condition is true)
executable
statement;
else
executable
statement;
end
For example, the following adds 1 to x if x = 0 and subtracts 1
otherwise:
if x>=0
x=x+1.0;
else
x=x-1.0;
end
Equality is denoted "==" to distinguish it from assignment.
LOOPS.
These are "DO-Loops" in
FORTRAN and "FOR-Loops" in C and Matlab.
for i = beginning: stepsize : end
executable statements;
end
where "beginning", "end" and "stepsize" are all integers.For example,
this
computes the sum
1+1/2+1/4+1/8++ 1/(2**1000).
sum=0.0
for I=0,1000,1
addend=1.0/(2.0^i);
sum=sum+addend;
end
Suppose we want to exit a
loop early when a condition holds. Use
a "break" statement. For example, to exit the above when SUM>
1.5 we add an if-test
sum=0.0
for k=0:1:1000
addend=1.0/(2.0^k);
sum=sum+addend;
if sum>1.5)
break;
end
end
k
sum
Matlab's BUILT IN FUNCTIONS
Essentially all basic mathematical functitons are built-in. For
example,
exp(x) computes the exponential of x, sin(x) computes its sine, inv(M)
computes the inverse of a matrix, eig(M) computes the eigenvalues of
a
matrix, etc.
Inline functions
Simple functions can be put directly in a Matlab statement:
area=inline('pi*r^2','r');
defines a function area(r) that computes the area of a circle given
its radius.
Here is an example:
area=inline('pi*r^2','r');
x=2.0;
a=area(x);
disp(['radius=',
num2str(x),
' area=' , num2str(a)])
note that Matlab knows the value of pi.
If a function uses more
calculations or a longer formula then use
a function m-file. Function m-files are very useful!!! Here's an
example:
function a=area(x,y)
a=y*x^2;
If you put those lines in a file named "area.m" then you can call them
from a program easily.
r=2.0
a=area(r,pi)
Here is an example of a simple MATLAB program which does numerical
differentiation:
% THIS IS
IN MATLAB!!!
%
% This program computes two finite
difference approximations
% to the derivative of a given
function.
% this is Matlab syntax to define a function "in line"
% you can also make up a separate m-file
F = inline('X*exp(X)','X');
FP = inline('X*exp(X)+exp(X)','X');
a=1.0;
h=0.5;
disp('Here we go-hold on!');
for i=0:13
h=1.0/(2.0^i);
d1hf= ( F(a+h)-F(a-h))/(2.0*h);
d2hf=(F(a+2.0*h)-F(a-2.0*h))/(4.0*h);
df=(4.0/3.0)*d1hf-(1.0/3.0)*d2hf;
e1=abs(FP(a)-df);
disp(['h=', num2str(h),' f''~',num2str(df),'
error=',num2str(e1)]);
end
disp('Whew-that was fast!')
3. Arrays = Vectors and Matrices.
Vectors and matrices are
the way to store and manipulate lots of
data.
For example, this computes the first 20 Fibonacci number:
fibo(1)=1.0;
fibo(2)=2.0;
for k=3:20
fibo(k)=fibo(k-1)+fibo(k-2);
end
fibo(20)
Remark: It's interesting to try running this changing "20" to, e.g., "50".
4. Programming "Rules of Thumb".
These days one is more
often
modifying an existing code or linking
pieces of codes than programming a new application from scratch.
Nevertheless, the following "rules of thumb" will, if followed, save
you
hours of headaches in debugging:
1. Be careful and correct: every hour you spend in checking, planning
and
double checking will save four hours of debugging.
2. Use pseudo code to organize and plan your program.
3. Check it twice before running it! Then run it on several test cases
with known true-solutions.
4. Use modules. Break the program into clear chunks (one way is to use
FUNCTION m-files). Check and debug each module independently of the
whole program before testing the whole program.
5. Use the right amount of generalization!
6. Print intermediate results.
7. Include warning messages.
8. Use variable names that are easy to understand and declare all
variables.
9. Put lots of comments in!
10. Keep your loops simple!
11. Think a lot about your data structures.
12. Use arrays to store data.
13. Use built in functions and program libraries.
14. Put clarity (for people) above compactness or even speed of
execution
FORTRAN INFORMATION
Some people might choose to use FORTRAN (or be forced
to because
they deal with legacy programms). I've inclluded some
information next for those lucky ones.
HOW TO RUN A FORTRAN PROGRAM
Here are some
basic , basic instructions on how to
(a) write a fortran
program [ie, create a file].
(b) how to run
it.
(a) To create
a file you need to use an editor. In unix, the pico editor
is probably easiest
because it's menu driven. Dont forget though that unix
is case sensitive:
large and small letters have different meanings , so
get the
capitalization
exactly right!
At the prompt type:
pico progname.for
(the "progname " you may choose but be sure to make it .for at the
end.)
Next paste in or type in your program. Editing it is easy-read the
commands at
the bottom of the
screen. When you are done type
'control'O
then type
'control'X
Now you've created a file progname.for.
(b) Here's how to run progname.for
At the
prompt type
setup sunpro
At the
next prompt type:
f77 -C progname.for
This compiles
your program. Now run it by typing at the next prompt
./ a.out (i.e., " dot slash a dot out" without any
spaces!)
This tells
the computer to dump your output to the screen.
Try
writing
a simple program to add 2 numbers and output it. If it doesnt
work, check
carefully
the cases [small letters or caps] and the spaces in
your
commands.
Another
comment:
If you discover something interesting, email me and I'll
send it to the
whole
class.
More Remarks:
These instructions
are for our UNIXS system. There are a lot of free
FORTRAN compilers
available [FORTRAN 77] as well as a lot of free C
compilers too. I'll
email to you an addres on where to download one, if
you are interested
in working on a PC. I suggest though that you start on
UNIXS if you've
never programmed before.
Have fun!
FORTRAN Compilers-
Here are some FORTRAN resources including free and/or cheap FORTRAN compilers for a PC.
"The Fortran
Library,
http://www.fortranlib.com, is a comprehensive guide
to online Fortran
resources, including compiler vendors and
resellers,
benchmarks,
programming tools, books and articles on Fortran
and numerical
methods,
and commerical and public domain Fortran software.
The Fortran Market,
http://www.fortran.com/fortran/ , also provides
many links to
Fortran
resources and is a reseller for several Fortran 90
and 95 compilers,
benchmarking and test suites, and books on Fortran."
One former student installed one. Here below are his instruction on how to do this:
Subject: Fortran Compiler for PC's
First of all, the stuff has to be downloaded.
It can be gotten via anonymous ftp (using Netscape, for instance) from
ftp://ftp.bu.edu/pub/mirrors/simtelnet/gnu/djgpp/v2gnu/g770523b.zip
and you also
need
ftp://ftp.bu.edu/pub/mirrors/simtelnet/gnu/djgpp/unzip386.exe
There are other
things
like additional documentation, but this provides the
bare essentials
(I realized that it needed to be cut down for people to be
able to download
it).
Then this file
(g770523b.zip)
needs to be unzipped. I recommend making the
directory C:\DJGPP
by typing
mkdir \DJGPP
at an MS-DOS
prompt.
Then, go to the directory where you downloaded
g770523b.zip to,
and type
move g770523b.zip
\djgpp
move unzip386.exe
\djgpp
cd \djgpp
unzip386
g770523.zip
You'll also need
to make sure you can access the compiler, so add
C:\DJGPP\BIN to
your PATH statement in your CONFIG.SYS. If you don't know
how to do this,
just type the following from an MS-DOS prompt.
echo PATH=%PATH%;C:\DJGPP\BIN >> \CONFIG.SYS
After that, you'll
need to write the FORTRAN programs in something like
Notepad (do not
use a Word Processor for this!). To compile your program,
named (for
instance)
progname.for, type the following.
g77 -o progname progname.for
and to run the new program, type
progname
A Synopsis of "5-Statement FORTRAN"
ABSTRACT
This is prepared
solely for the benefit of my students. ItÕs intended to have 2
purposes.
1. To introduce
math students whoÕve never programmed before but are used
to the algorithmic
thought in rigorous
proofs to a language quickly and get them working, and
2. To do the same
for students who have experience programming in another language
like C, for example.
1. Introduction.
FORTRAN is short for FORmula TRANslation language. It is a low
level language
designed
for doing scientific calculations and lots of
them. Although it
is out of favor in CS departments, it is extremely handy
to know a bit of
FORTRAN because:
(estimated) 95% of scientific software is in FORTRAN.
Thus, if you must
modify an existing program it will likely be a FORTRAN
one.
It is also useful
for us because it is simple ( = easy to learn) and its
logic parallels
the logic of mathematical formulas.
Generally, for
these and other
reasons, if you program in another language, it is a good
idea to know how
to call a FORTRAN subroutine from that language.
2. FORTRAN Statements.
When you type a line of a FORTRAN program, different locations of
characters (i.e.,
which column it is types in) have different meanings.
Column
1
Column 2-5 Column
6
Column 7-72
Comment indicator
Line number Blank or continuation Executable FORTRAN
statement
Generally, try not
to continue a statement from one line to another: Keep
formulas short
enough
that you can glance at it and see what it is doing.
Thus, try to leave
column 6 blank. A character in column 1 tells the
compiler to ignore
the line so you use these lines to write notes to
yourself. You can
also use "C " in column 1 to de-activate a line. This is
called "commenting
it out."
Types of
Variables.
Variable names can have no more than 7 characctters.
You should declare
variables but in FORTRAN you don't need to
because there are
defaults.
INTEGERS:
Integers are stored
as such and added exactly. Any variable
beginning
with
I, J, K, L, M, N
is by default an
integer. Thus, old-style FORTRAN would use the
(undeclared)
variable
ICOUNT. Variables can also be declared as integers
initially, meaning
before the first executable statement. For example,
_ _ _ _ _ _ _ _ _ INTEGER COUNT
will make COUNT an
integer even though the undeclared default of a
variable COUNT is
real. In integer arithmetic
I =1/4
Returns I = 0 while
in real arithmetic
X = 1.0/4.0
Returns X = 0.25.
Don't use mixed mode arithmetic!
REAL
NUMBERS:
These can be
declared
as real before the first executable
statement by,
e.g.,
_ _ _ _ _ _ _ REAL X
By default any
variable
beginning with
A-H or O-Z
is also real. Reals
are numbers with decimal digits such as
PI = 3.141592736
XINDEX = 1.0
They are stored
in scientific notation and carry a certain number of
significant digits.
Carrying 7 digits base 10 is typical although not
universal.
DOUBLE
PRECISION
variables must
always
be declared n before the first
executable
statement,
e.g.,
_ _ _ _ _ _ _ DOUBLE PRECISION X
They work like reals
but carry more than 2x the number of significant
figures as reals
(also called single precision). Double precision is the
normal mode for
many scientific calculations. If you add a real to a
double precision
variable, you immediately lose al the extra accuracy of
the double
precision
variable so:
Avoid mixed mode arithmetic.
Arithmetic
Operations.
These are denoted by the usual symbols
+, -, , / and *
Exponentiation is
denoted by ** with differences between real and integer
exponents:
(Integer) X**2
means
X * X
(Real) X**2.0 means
EXP(2.0 LOG( X ) ).
The arithmetic
equals
(=) has a different meaning than in arithmetic. For
example, the
statement
X=X+1.0
makes perfect sense
in FORTRAN. It means, look at the left hand side, find
the storage
location
set aside to store the variable called X and find the
value of X. Add
one to that value then put the result back in the X
storage location.
This requires the computer to do something; hence, it is
called an
executable
statement. (It's described informally by: "look in
the box marked X.
Get the number there; add one to it and put it back in
the X
box.")
CONTROL
STATEMENTS
Programs always end with two statements that terminate the
program:
STOP
END
Another useful statement is the unformatted print statement which
just dumps the
output
to your computer screen. This is fine for moderate
amounts of output.
(For lots of it, read about formatted print statements
in a FORTRAN book.)
An unformatted print takes the form
PRINT *, variables to be printed separated by commas.
Anything put in
quotation
marks is printed directly as written. Examples
of this are given
later. Generally, for moderate amounts of data, an
unformatted print
is fine. On your terminal screen, highlight the output.
Next copy and paste
it into your favorite text editor and format it and
then print
it.
3. The Heart of the Program.
A computed basically can only do 5 things:
¥ Input
data,
¥ perform
arithmetic
calculations,
¥ decisions
based on logical or arithmetic tests,
¥ output data
and
¥ loop (meaning
perform al the above iteratively).
We've seen how to
perform basic arithmetic calculations. Let's now review
some of the
remainder.
The real power of the computer is unleashed with
loops (doing a lot
of calculations) and matrices and vectors (handling a
lot of
data).
INPUT, OUTPUT
and CONTROL
Unformatted input is (usually from your terminal screen)
READ*, variables
While unformatted
output is
PRINT*, variables.
You can label the
variables by putting notes to be printed in quotes as in:
PRINT*, ÒNext we print the value of XÓ, X
This results in a printted line like:
Next we print the value of X .34567E2
when X has the value
34.567.
DECISIONS.
Decisions in FORTRAN are performed by "IF tests." There are many
kinds. One basic
kind takes the form
IF (condition is true) THEN executable statement
ELSE executable statement
ENDIF
For example, the
following adds 1 to x if x = 0 and subtracts 1 otherwise:
IF(X.GE.0) THEN X=X+1.0
ELSE X=X-1.0
ENDIF
The conditions are arithmetic inequalities using the following.
Math
FORTRAN
Example
<
.LT.
X<Y is written as: (X.LT.Y)
>
.GT.
X>Y is written as: (X.GT.Y)
=
.EQ.
I=J is written as: (I.EQ.J)
> or
=
.GE.
is written as: (X.GE.Y)
< or
=
.LE.
is written as: (X.LE.Y)
not
equal
.NE.
is written as: (I.NE.J)
LOOPS.
These are "DO-Loops" in FORTRAN and "FOR-Loops" in C. If r is a
statement number,
they take the form
DO r I = beginning, end, stepsize
executable statements
r CONTINUE
where "beginning",
"end" and "stepsize" are all integers.For example, this
computes the
sum
1+1/2+1/4+1/8++
1/(2**1000).
PROGRAM SUM.for
SUM=0.0
DO 10 I=0,1000,1
ADDEND=1.0/(2.0**I)
SUM=SUM+ADDEND
10
CONTINUE
STOP
END
Suppose we want to exit a loop early when a condition holds. In
this case, in
FORTRAN
the only way is to use a "GO TO" statement. (This is
the only valid use
of GO TO's.) For example, to exit the above when SUM>
1.5 we add an
if-test
with a GO TO:
PROGRAM SUM.for
SUM=0.0
DO 10 I=0,1000,1
ADDEND=1.0/(2.0**I)
SUM=SUM+ADDEND
IF(SUM.GT.1.5) THEN GO TO 20
ENDIF
10
CONTINUE
20
PRINT*, "I=",I, "and sum=", SUM
STOP
END
FORTRAN's BUILT
IN FUNCTIONS
There are many built in functions in FORTRAN. If you put a "D" in
front the function
returns a double precision answer. Some common ones
include:
ABS(X)=|x| ,
TAN(X) =
tangent(x),
ATAN(X)=
arctangent(x),
COS(X),
SIN(X),TAN(X),...
,
EXP(X) =
exponential
function of x= e**x ,
LOG(X)= natural
logarithm of x,
LOG10(X)= logarithm
base 10 of x,
SQRT(X)=square root
of x,
FLOAT(I) and
REAL(I)
convert integer I into a real to avoid mixed mode arithmetic,
DFLOAT(I) makes
I a double precision real,
and so
on!
FUNCTION
STATEMENTS
Function statements are very handy to code a simple formula.
IMPORTANT: MUST
BE BEFORE THE FIRST EXECUTABLE STATEMENT!
Here is an example:
PROGRAM AREA.for
AREA( R)=4.0*ATAN(1.0)*R**2
X=2.0
A=AREA(X)
PRINT*, "Radius=", X, "AREA=" , A
STOP
END
Note that
4.0*ATAN(1.0)
is a standard way to code PI without typing in all
its digits!
If a function uses more calculations or a longer formula then use
a function
subroutine.
Function subroutines are very useful!!! Here's an
example:
PROGRAM AREA.for
PI=4.0*ATAN(1.0)
R=2.0
A=AREA(R,PI)
STOP
END
FUNCTION AREA(X,Y)
AREA=Y*X**2
RETURN
END
Notes:
You must have "AREA
= " somewhere in function subroutine AREA
And you must always
have "RETURN, END" at the end.
4. Arrays =
Vectors
and Matrices.
Vectors and matrices are the way to store and manipulate lots of
data. They must
be set up with various dimensioning statements
BEFORE THE FIRST
EXECUTABLE STATEMENT!!!
Examples of these dimensioning statements are the following:
REAL X(50), A(50, 50)
INTEGER INDEX(50)
which means the same as:
REAL X, A
INTEGER INDEX
DIMENSION X(50), A(50, 50), INDEX(50)
For example, this computes the first 20 Fibonacci number:
PROGRAM Fibonacci.for
REAL FIBO(20)
FIBO(1)=1.0
FIBO(2)=2.0
DO 10 I=3,20,1
FIBO(I)=FIBO(I-1)+FIBO(I-2)
10
CONTINUE
PRINT*,FIBO(20)
STOP
END
Remark: It's
interesting
to try running this changing "20" to, e.g., "50".
You will soon see
why FIBO(.) is stored as a real number rather than (at
first and second
consideration) the more natural integer.
5. Programming
"Rules of Thumb".
These days one is more often modifying an existing code or linking
pieces of codes
than programming a new application from scratch.
Nevertheless, the
following "rules of thumb" will, if followed, save you
hours of headaches
in debugging:
1. Be careful and
correct: every hour you spend in checking, planning and
double checking
will save four hours of debugging.
2. Use pseudo code to organize and plan your program.
3. Check it twice
before running it! Then run it on several test cases
with known
true-solutions.
4. Use modules.
Break
the program into clear chunks (one way is to use
FUNCTION
subroutines).
Check and debug each module independently of the
whole program
before
testing the whole program.
5. Use the right amount of generalization!
6. Print intermediate results.
7. Include warning messages.
8. Use variable
names
that are easy to understand and declare all
variables.
9. Put lots of comments in!
10. Keep your loops simple!
11. Think a lot about your data structures.
12. Use arrays to store data.
13. Use built in functions and program libraries.
14. Put clarity (for
people) above compactness or even speed of execution