Introduction
To add remarks, comments, or other annotations, type the letter c or
C in column 1, followed by the
annotation Every line of your annotation must have a c
in column 1.
All commands begin in column 7 and may not extend past column 72.
Statement numbers go in columns 1-5. You may give any command
line a statement number, even
though this line is never addressed in the program by a command.
See Logic Statements below.
Anything in column 6 indicates a continuation from the preceding line. For example: & or +.
It is suggested that you explain what the program is and the meaning
of some of the variable names at
the beginning of the program or where appropriate in the program.
The first executable lines must be for defining storage space in memory
for any matrices (indexed or sub-
scripted variables) if you are going to use them, or for changing the
integer or real default status of your
variable names.
The last command of your program must be "end"
Real and Integer Variables
By default, all variable beginning with the letters a through h and
o through z are real ( also called
floating point), that is, they may have decimal point values.
By default, all variable beginning with i through n are integer, that is, they can not have decimal values.
E.G..: Integer adat, Real index.
The variable "adat" is real by default, but the statement "integer adat"
converts it to a integer variable.
The variable "index" is integer by default, but the statement "real
index" converts it to a real or floating
point variable.
Precision of Numbers and Variables
The default precision of numbers, called single precision, is 8 digits.
So extremely small numbers like
0.000000012 will be rounded off to 0.0. To increase the precision
(number of digits) and sizes for variables, declare them as follows:
Real *8 var1, var2, etc.
This is called double precision and you can get up to 17 digits this
way. Another way to declare double
precision is to declare a variable as follows:
double precision var1, var2, etc
Constants may be entered in two formats, e. g., the speed of light in km/s:
c= 299000, or c=2.990E5. Avoid c = 2.990 * 10**5. Do not put commas in numbers.
Also, you may enter a number in double precision this way:
1.2345D5 instead of 1.2345E5
Case
You may use upper or lower case letters for commands
and variables.
However, some compilers are case sensitive.
Therefore, for variables, be consistent. Once you
introduce a variable, continue to write it exactly
the same way everywhere in the program, or you
could run into serious problems.
Defining an array of memory spaces:
To set up an array
of indexed variables such as x(i), use the Dimension
Statement as follows:
Dimension x(20), a(20), b(20), etc.
The above statement
allows you to assign 20 different values for x, a, or b, which must be
indexed in the program.
For example x must be written as x(i) in the program. One could use
any integer variable
for the index such as j, k, l, m, jj, etc. One may use a specific
value for x
by writing, for
example, y=3*x(8).
Opening and Labeling Files
Opening files must
come after dimension statements and declaration of real and integer variables.
The following command
opens a file named Input.txt:
Open (1, file = 'Input.txt')
This file is identified as "1" elsewhere in the program when reading the file
Read (1,*)
x, y, z etc. The asterisk means unformatted or as is. Files
may be formatted as
explained below.
Entering data from the keyboard.
The keyboard is the
default input device, indicated by an asterisk, *.
It is suggested
that you print a message on the monitor that tells you what to enter in
the
following way:
print *, '
Enter values for x, y, and z, separated by commas'
read *, x,y,z
The program will
pause when it encounters the above read command and begins when
you press the enter
key. If the read command is for 3 paramters and you enter only
2 and
then press enter,
the computer continues to pause until you have entered the correct
number of parameters.
Logic Statements
You could read in 20 values of x from a file by using a "do loop," where x is indexed. For example:
Do
100, i = 1, 20
read (1,*) x(i)
100 continue
The above would read
20 different values of x into memory from an unformatted (*) file
labeled as 1.
See above how to
label a file . The values of x must be a single column in the
file.
Warning:
The statement number
100 is written in columns 3, 4, and 5. If you wrote 100 in
columns 1, 2, and 3,
it would be read
as 10000.
To read values of x from a row in the file, use the command: read (1,*) x(i), (i=1, 20)
An alternative to a do loop is "do while":
PHI=0.0
DO WHILE (PHI.LT.360.0)
x=r*cos(PHI/57.29)
*
*
*
PHI=PHI+5
END DO
Or and "if" statement:
IF (PHI.LT.360) then
x=r*cos(PHI/57.29)
*
*
*
PHI=PHI+5
ELSE
continue ( or alternative
command lines go here)
ENDIF
Note: the arguments of trig functions must
be in radians. In the above commands, the
angle PHI (in degrees) is dividid by 57.29
to convert to radians.
Notes on formatting output or input:
First declare an
output/input file which can be imported into WORD or PICO for editing and
printing
or read into the
program.
open (2, file=' output.dat')
To read the data in the file:
read (2,*) x, y, z
The asterisk means to read the file as
is and not according to some specified format. If you want to
format the data in the file in some specific
way then use:
read (2,121) x,y,z
In the above 121 identifies the format
statement such as the one given below as 101. Also see below
for how to format data and set up a format
statement.
To write a row of column headings into an output file, such as,
Index Var1 Var2 X DELX OUTPUT,
Put the following command on a line somewhere
before you write the actual numbers to the file,
This needs to be done before a do loop
in which the actual data printing is done:
write (2,101)
101 format
( 10x,' Index', 8x,'Var1',8x, 'Var2',12x, 'X', 12x,'DELX', 8x,'OUTPUT',
/ )
The different values of nx (here 10x)
is the number of spaces to skip between headers and this
is determined by trial and error.
The slash skips a line.
A format statement, like the one
above, describes how the data are or will be formated
or arranged in an input or output file.
To write the data to this file correctly
aligned in the columns, use the following output
command in a Do loop after all variables
are computed but before any variables are
incremented in the loop:
write (2,102) I, Var1, Var2, X, DELX, OUTPUT
102
format (5x, I5, 2(f10.4,5x), f8.3, 5x, f6.3, 6x, f10.4)
You need to determine the values of nx
by trial and error so that all decimal places
are in the same column for each field
of data.
"I5" formats the variable I as an integer
number (no decimal point) that is less than
5 spaces long. This allows I to
be a value between 1 and 9999.
If more than 1 variable is of the same
format, you may lump together the size of the
fields, e.g. f10.4, and the spaces between
them, nx, as was done above for Var1 and Var2,
viz., 2(f10.4, 5x). In the term
"f10.4", f means floating point or a number with decimals,
10 is the size of the field in spaces,
and 4 is the number of decimal places in that field.
For example, when f10.4 is used
for the number 502.3245, the decimal point is always
counted as one of the 10 spaces in the
field. So the total field taken up by the above
number is 8 spaces. The 2 other
unused spaces in the f10 field are before the 5 not after
the last decimal place. You
need to take this into account when deciding what the
values are for nx to align the columns
of data under the header of the table.
All results from
your program must be professionally formatted in tables as explained
above.
If a table is longer than 1 page, the headers must be placed on each page.
You can control this
by setting up a counter and when the value exceeds
a certain number
of lines, you skip a page with the command
write (2, 103)
103 format (2x,
////) ,
where the number
of slashes is the remaining lines to be skipped at
the bottom of the
page + lines to be skipped at top of next page. This is found by
trial
and error.
Setting up a counter
within a do loop and use what is called an "If - Else -End" logic
sequence as shown
below:
J=0
Do 500 i =1, N
.
.
.
etc.
write
output to file command goes here, followed by:
J=J+1
If (J.eq.50) then
write (2,103)
103 format format
(2x, ////)
( the
following commands resets the counter for the next
page and sets up the printing of the
column headings
again )
J=0
write (2,104)
104 format
(2x, //, 'Table 2 Continued',/)
Else
continue
Endif
.
.
etc.
When writing to a
file, each time a WRITE command is encountered during execution,
such as in a DO
loop, values are written in the file as a new row, in successive order.
Only when you close
a file and then reopen it, or rerun the program, will you begin
writing into the
file at row 1.
At the end of a program,
you should close each file that you have opened by the following
statement:
Close (2)
This closes file 2.
The last command of your program must be "end"
A sample program
is given at the end of this document. You should try to compile and
run
the program.
However, to make it work you will need to type up an input file of fictious
data.
Library of Math Functions:
ex : exp(x)
ln x: alog(x)
sqare root of x: sqrt(x)
yx: y**x
log10 x: alog10(x)
cos x : cos(x)
sin x : sin(x), etc. for other trig functions.
arctan x : atan(x) (the angle x must be in radians, not degrees)
Very large numbers
may be entered thusly: y= 2.567E22, which is the equivalent
of 2.567 x 1022.
The numerical
limit for a variable is 1030 unless you declare it as real *8.
See above.
Sample Program
C This is a program
that computes the standard deviation of a set of measurements that should
C obey the law:
v=0.35+0.72*t(i)+5.30*t(i)**2, where i indexes a specific value for t.
Corresponding
C measurements
of v and t are read from an input file named input.txt. The number
of lines of data
C in the input
file is N, which is the first number in the file.
Dimension t(100), vmeas(100)
or real t(100), etc
Open (1, file='Input.txt')
read (1,*) N
vn=N
Do 100, i=1,N
read (1,*) t(i), vmeas(i)
print *, t(i),vmeas(i)
100 Continue
Sum = 0.0
Do 500 i=1,N
vcomp = 0.35+0.72*t(i)+5.30*t(i)**2
vres= vmeas(i) - vcomp
Sum = Sum +vres**2.0
print *, i, t(i),vmeas(i),vcomp,vres,Sum
500 Continue
sigma=sqrt(Sum/(vn-1.0))
print *, ' Std. Dev.=',sigma
close (1)
stop
end
END
OF MANUAL