|
CHAPTER 2
BASIC INPUT/OUTPUT
Input/output operations (i.e., reading/writing data) are a
very important part of computer programming. This chapter
describes basic input/output operations, beginning with the
READ and WRITE statements.
The READ statement is an input statement; the WRITE
statement is an output statement. The OPEN statement is used to
open a file for reading or writing purposes. The CLOSE
statement reverses the action of the OPEN state ment. The DATA
statement is used to provide initial val ues for variables, or
in place of input data.
There are two types of input/output operations: (1)
unformatted, which do not follow a specific way of reading or
writing, and (2) formatted, which follow a specific way.
Unformatted input/output is much simpler than for matted. The
emphasis of this chapter is on unformatted input/output.
Chapter 6 describes formatted input/output in more detail.
2.1 RECORDS AND FILES
A record is the basic unit of input/output operations. A
record is a sequence of characters constituting one value, or a
sequence of values forming one line. For instance, a line on a
computer or terminal screen is usually considered to be a
record. When entering data, pressing the carriage RETURN key
signals the end of a record. In other words, the RETURN key is
a record separator.
Records are of two types: (1) unformatted, and (2)
formatted. Unformatted records do not follow a format
specification and they may be read or written only by unformatted input/output statements.
Formatted records follow a
format specification and they may be read or written only by
formatted input/output statements.
A file is a sequence of records forming an entity which can
be addressed by the operating system. Files can be either
external or internal. An external file is any file that exists
independently of the executable program. An internal file is
used for the purpose of transferring data from one location in
(internal) storage to another location in (internal) storage.
Input statements transfer data from external media (an
external file or the screen) or an internal file to internal
storage. This process is called reading, and it is accomplished with the READ statement.
Output statements transfer data from internal storage to
external media (an external file or the screen) or an internal
file. This process is called writing and it is accomplished
with the WRITE (or PRINT) statement.
Format specification is accomplished with a FORMAT
statement. A programmer choosing unformatted input/ output does
not need to specify FORMAT statements. In this case, the
processor controls how input data is read and how output data
is written.
A programmer choosing formatted input/output must use FORMAT
statements to read and/or write data. In this case, the
programmer retains control on how input data is read and how
output data is written.
As a general rule, it is good programming practice to use
unformatted records for input (reading) operations, and
formatted records for output (writing) operations. Unformatted
input frees the programmer or user from having to count columns
and blank spaces on a data record. Formatted output has the
advantage that it can be made to look exactly as desired.
Example: Unformatted and Formatted Input/Output
C234567890
C-----UNFORMATTED
INPUT/OUTPUT
READ(5,*) A,B,C
WRITE(6,*) A,B,C
C-----FORMATTED INPUT/OUTPUT
READ(5,10) A,B,C
WRITE(6,20) A,B,C |
2.2 UNITS AND FILE CONNECTION
Processors use certain numbers called logical units to con
nect to a file for input/output operations. Logical units can
vary from 1 to 100, allowing the simultaneous connection of up
to 100 files. The numbers 5 and 6 are the usual default
logical units for interactive screen input and output,
respectively. Other numbers in the range 1-100 can be arbitrarily chosen to connect to files.
The OPEN statement is used to connect a file to a unit. The
CLOSE statement is used to disconnect a file from a unit. A
file must not be connected to more than one unit at the same
time. A unit must not be connected to more than one file at the
same time.
Input data can either
- Reside in an input file, or
Be entered directly to the screen every time the program
is executed. This is called "interactive reading."
If the input data resides in an input file, the latter can
be read every time the program is executed. If the input data
does not reside in an input file, the data has to be entered anew every time the program is executed.
In general, a long input data stream (consisting of a large
number of records, say, more than 10) should reside in an input
file. On the other hand, a short input stream (say, a few
records) may be entered directly to the screen every time the
program is executed.
Output data can either
- Be written to an output file, or
- Be displayed directly on the screen every time the pro
gram is executed.
If the output data is written to an output file, it is effectively stored and can be referenced as many times as desired,
until such time when it is no longer needed and can be
deleted--i.e., erased from disk storage. If the output data is
displayed directly on the screen, it is available for immediate examination, but it is not stored.
In general, a long output stream should be written to an
output file, for immediate examination or long-term storage. On
the other hand, a short output stream may be displayed directly
on the screen, for immediate examination only.
The direct screen input/output mode is often referred to as
interactive mode. Typically, in the absence of a specific
instruction to the contrary, a processor will regard the interactive mode as the default input/output mode.
The numbers 5 and 6 are the usual default logical units for
interactive screen input and output, respectively. Throughout
this book, the units 5 and 6 will be taken in this context.
Things to watch for with regard to logical
units:
- Check your operating system's documentation
for the default (logical) units to be used for interactive input/output.
- Use these default units as appropriate in place of the default units indicated in Section
2.2.
|
2.3 READ STATEMENT
The READ statement is the data transfer input statement.
It has the typical form:
READ(UNIT=5,FMT=12) A,B,C
Note that the READ statement keyword is followed by UNIT= 5
and FMT= 12, enclosed within parentheses, and separated by a
comma. This statement will read the vari ables A, B, and C from
the file that is connected to unit 5 following the format
marked with the statement label 12. If interactive read is
connected to unit 5 (the usual default setting), the input data
is entered directly to the screen during program execution.
The above statement can also be written as:
READ(5,12) A,B,C
where the optional characters UNIT= and FMT= have been
omitted for simplicity. If these characters are omitted, the
following rules should be adhered to:
If UNIT= is omitted, the unit specifier must be the
first item on the list enclosed in parenthesis; and
If FMT= is omitted, the format specifier must be the
second item on the list enclosed in parenthesis, and the first
item must be the unit specifier without the character UNIT=.
The form
READ(*,12) A,B,C
will read variables A, B, and C using direct screen input
and following the format with statement label 12. The * in
place of the unit specifier stands for direct screen input,
i.e., interactive input.
The form
READ(5,*) A,B,C
will read variables A, B, and C from the file connected to
unit 5 and use unformatted input. The * in place of the format
label stands for unformatted input. An unformatted READ is also
referred to as a list-directed READ.
The form
READ(7,*) A,B,C
will connect an input file to unit 7 and use unformatted in
put. Since unit 7 is not normally used for interactive input,
the connection to unit 7 is accomplished with an OPEN statement
(see Section 2.5).
The unit specifier does not need to be a constant.
The form
READ(LU,*) A,B,C
will connect to a variable logical unit LU and use unformatted input. The value of LU should be defined in the source
program prior to the execution of this READ statement.
The READ statement has other specifiers, besides the unit
and format specifiers.
The form
READ(7,15,ERR=80,END=90) A,B,C
will read variables A, B, and C from the file connected to unit
7, following format labeled 15. In addition:
An error condition during input operation will branch
control to the statement labeled 80.
An end-of-file condition during input (i.e., no more records remaining to be read in the file) will branch control to statement 90.
The indicated statement labels (80 and 90) must exist
elsewhere in the program unit. Either ERR or END or both may be
specified in a READ statement. The characters ERR= and END=
preceding the label specifiers are required and cannot be
omitted.
2.4 WRITE STATEMENT
The WRITE statement is the data transfer output state ment.
Unlike the PRINT statement, which is permanently connected to
direct screen output, the WRITE statement may also be used to
write to a file. Therefore, the WRITE statament has more
flexibility, and is preferred by most programmers.
The WRITE statement has the typical form:
WRITE(UNIT=6,FMT=15) X,Y,Z
This statement will write the variables X, Y, and Z to the
file connected to unit 6 following the format labeled 15. When
unit 6 is connected to interactive write (default value), the
output data is displayed directly on the screen during program
execution.
The above statement can also be written as:
WRITE(6,15) X,Y,Z
where the optional characters UNIT= and FMT= have been
omitted for simplicity. In this case, the same rules as for the
READ statement apply.
The form
WRITE(*,15) X,Y,Z
will write variables X, Y, and Z using direct screen output
and following the format labeled 15. The * in place of the unit
specifier stands for direct screen output (interactive output).
The form
WRITE(6,*) X,Y,Z
will write variables X, Y, and Z to the file connected to
unit 6 and use unformatted output. The * in place of the format
label stands for unformatted output. An unformatted WRITE is
also referred to as a list-directed WRITE.
The form
WRITE(8,15) X,Y,Z
will connect to unit 8 and follow format 15. Since unit 8 is
not normally used for interactive output, the connection to
unit 8 is accomplished with an OPEN statement (see Section
2.5).
The unit specifier does not need to be a constant. The form
WRITE(LU,25) X,Y,Z
will connect
to unit LU and follow format 25. The value of LU should be
defined in the source program prior to the execution of this
WRITE statement.
The form
WRITE(9,40,ERR=90) X,Y,Z
will
write variables X, Y, and Z to the file connected to unit 9
following format labeled 40. An error condition during output
operation will branch control to statement labeled 90. The
indicated statement label (90) must exist elsewhere in the
program unit.
Algebraic expressions can also be listed in a WRITE
statement, as shown in the following example:
WRITE(6,20) 2*A,3.5*B
In this case, the first value written is equal to twice the
value of A; the second is equal to 3.5 times B.
Example Program: READ and WRITE Statements
C234567890
PROGRAM READ_WRITE
READ(5,*) A,B
READ(5,*,ERR=85) C
X= A + B
Y= B - C
Z= A/C
WRITE(6,*) 'X IS EQUAL TO ', X
WRITE(6,*) 'Y IS EQUAL TO ', Y
WRITE(6,*) 'Z IS EQUAL TO ', Z
85 WRITE(6,*) 'ERROR WHILE READING C'
END |
In the above program, the variables A, B, and C are read
directly into the screen (unit 5 specifier), the indicated
operations are performed, and the results are printed directly
onto the screen (unit 6 specifier). Assuming A = 10.8, B = 7.8,
and C = 3.2, the output would look like this:
X IS EQUAL TO 18.6000
Y IS EQUAL TO 4.60000
Z IS EQUAL
TO 3.37500 Note that if an error is encountered while
reading C, the output would simply look like this:
ERROR WHILE READING C
2.5 UNFORMATTED INPUT/OUTPUT RULES
The following rules are for unformatted input/output:
An input value or values should have no embedded blank
spaces (i.e., blanks in the middle), and should be separated
among themselves either by:
- a comma,
- one or more blank spaces, or
- a combination of one comma and one or more blank spaces
in any order.
Character constants should be enclosed by apostrophes
and separated among themselves in the same way as other
values.
During input, the processor is directed to read as many
values as variables are listed in the READ statement. This is
why unformatted input is also referred to as list- directed
READ.
- If, within one input record, m (the number of values
forming part of the record) matches n (the number of variables
listed in the READ statement), n = m values will be read.
- If, within one input record, m exceeds n, n values will
be read from that record and the remaining values (m - n) will
be ignored by the processor.
- If, within one input record, n exceeds m, m values will
be read from that record, and the remaining values (n - m)
will be read from at least one addi tional record. The values,
if any, remaining in the last record read will be ignored by
the processor.
During output, values are written with spacing and char
acteristics remaining under the control of the processor.
Things to watch for with regard
to unformatted input:
You should try to match the number of
variables listed in the READ statement with the number of
values contained in the input record.
If the number of variables listed in the
READ statement (see Section 2.3) does not match the number of
values in the input record, you are in effect either (a)
disregarding a trailing por tion of the input record, or (b)
reading more than one record, and may be disregarding a
trailing portion of the last record read.
|
2.6 OPEN STATEMENT
The OPEN statement initiates a connection between an
external file and a specified unit. It has the typical form:
OPEN(UNIT=5,FILE='A.DAT',STATUS='UNKNOWN')
This statement will connect the external file A.DAT (an
input data file) to unit 5. The character UNIT= is optional
only if the unit specifier (5) is the first item on the list
enclosed in parenthesis in the OPEN statement. In this case,
the previous statement reduces to:
OPEN(5,FILE='A.DAT',STATUS='UNKNOWN')
The status specifier can be OLD, NEW, SCRATCH, REPLACE, or
UNKNOWN. For some compilers, the status specifier may be
optional.
If OLD is specified, the file must exist
If NEW is specified, the file must not previously
exist; the file is created and the status is changed to OLD.
If REPLACE is specified and the file previously exists,
the file is deleted, a new file is created, and the status is
changed to OLD.
If SCRATCH is specified, the file is created, but it is
deleted at the termination of program execution.
If UNKNOWN is specified, the status varies with the
processor being used. Usually the processor tries status OLD
first; if the file is not found, the processor then uses NEW,
thereby creating a new file.
The file name specification can be omitted, as shown in the
following example:
OPEN(7,STATUS='UNKNOWN')
In this case, a default file name which is processor depend
ent (e.g., FOR007.DAT) is connected to unit 7. Another
option is to include an error specifier in the OPEN statement,
as in the following example:
OPEN(7,STATUS='UNKNOWN',ERR=97) If an error is
encountered during the execution of this OPEN statement,
control branches to the statement labeled 97.
Example: OPEN statement
C234567890
C-----OPEN STATEMENT
OPEN(UNIT=5,FILE='P.DAT',STATUS='UNKNOWN')
OPEN(UNIT=6,FILE='P.OUT',STATUS='UNKNOWN')
READ(5,*) A,B,C
WRITE(6,*) A,B,C
OPEN(UNIT=7,FILE='Q.DAT',STATUS='UNKNOWN')
OPEN(UNIT=8,FILE='Q.OUT',STATUS='UNKNOWN')
READ(7,*) D,E
WRITE(8,*) D,E
C-----END OF OPEN STATEMENT EXAMPLE |
This example connects file P.DAT to unit 5, file P.OUT to
unit 6, file Q.DAT to unit 7, and file Q.OUT to unit 8. It
reads from P.DAT at least one (and at most three) record(s)
containing values of variables A, B, and C. It writes to P.OUT
the values A, B, and C. It reads from Q.DAT at least one (and
at most two) record(s) containing values of variables D and E.
It writes to Q.OUT the values D and E. Note that each OPEN
statement physically precedes its respective READ or WRITE
statement.
2.7 CLOSE STATEMENT
The CLOSE statement disconnects an external file from a
specified unit; therefore, it reverses the action of the OPEN
statement.
After a unit has been disconnected from a file by the
execution of a CLOSE statement, either may be connected again
within the same executable program, either to the same unit or
file or to another unit or file.
The CLOSE statement takes the form:
CLOSE(UNIT=5,STATUS='KEEP')
This statement disconnects unit 5 from a file name and
keeps (i.e., saves) the file.
The status specifier can be KEEP or DELETE.
KEEP must not be specified for a file whose status
prior to the execution of the CLOSE statement is SCRATCH.
If DELETE is specified, the file will be erased after
the execution of the CLOSE statement.
If the status specifier is omitted, KEEP is assumed, un
less the file status is SCRATCH, in which case DELETE is
assumed.
The character UNIT= is optional if the unit specifier is
the first item on the list enclosed in parenthesis in the
CLOSE statement. In this case, the previous statement
simplifies to:
CLOSE(5,STATUS='KEEP')
The form
CLOSE(5)
will disconnect unit 5 from a file name and keep the file
(unless the file status is SCRATCH, see above).
If desired, an error specifier may be included in the CLOSE
statement. For instance, in
CLOSE(5,ERR=98)
an error condition encountered during the execution of this
CLOSE statement will branch control to the statement labeled
98.
At termination of program execution (for reasons other than
an error condition), all connected units are automati cally
closed. Therefore, it is usually not necessary to explicitly
close units at the end of a source program.
2.8 DATA STATEMENT
The DATA statement is used to provide initial values for
variables. It takes the typical form:
DATA A,B,C /12.,23.4,-45./
This statement assigns to variables A, B, and C the initial
values 12., 23.4, and -45., respectively. The slashes (/) de
limiting (enclosing) the values are required, as well as the
commas used to separate them. The number of values en
compassed within the slashes (/) must equal the number of
variables immediately following the keyword DATA.
Another way to write a DATA statement is the following:
DATA A,B,C /3*10./
All three variables A, B, and C have been initialized with
the value 10. using a repeat factor (3 in this case). The
repeat factor must be a positive integer. The above statement
is equivalent to:
DATA A,B,C /10., 10., 10./
DATA statements are used:
to assign initial values to variables whose values will
be later modified during program execution, or
to assign the proper values to constants that will not
vary from one program application to the next.
DATA statements can be interspersed among executable
statements (see Figure 1.1). However, it is good pro gramming
practice, for easy reference, to place all DATA statements
together, immediately preceding the executable portion of the
source program or subprogram.
Things to watch for with regard to
DATA statements:
-
Make sure that the number of variables matches
the number of assigned values.
-
Be sure to include two slashes (/), one preceding and another following the listed values.
-
Be sure to separate the variables and values with
commas.
-
If you use a repeat factor, confirm that it is
a positive integer, and that the number of values (including
those repeated with a repeat factor) matches the number of
variables.
-
For easy reference, consider placing all DATA
statements together, preferably immediately preceding the
executable statements.
|
2.9 DEBUGGING TOOLS
This section introduces the programmer to debugging and
debugging tools. This section should be used as a continu ing
reference. However, effective debugging is learned by
compiling and running many programs successfully. Al though
initially a slow process, debugging skills improve with
practice.
All Fortran programs need to be debugged before they can be
used effectively. Debugging refers to the process of re moving
errors, whatever their source. Success in programming depends
on how fast and how thoroughly the pro grammer is able to
identify and correct errors that may arise in the course of
normal program development. Debugging is both an art and a
science, and experience is essential to success. However,
thorugh a careful study of the nature of these errors, and of
the strategies to correct them, the programmer can acquire the
tools and develop the confidence to effectively debug Fortran
programs.
Errors in Fortran program development and execution can be
categorized into four classes:
Class I: Errors in statement spelling and/or syntax.
Class II: Errors in compatibility in input/output opera
tions.
Class III: Errors in logic and compatibility within and
between program units.
Class IV: Errors in input values.
Class I errors are common during the early stages of
program development, and are relatively easy to debug. During
compilation, Fortran compilers generate a list file which is
available to the user upon demand. A list file has the same
name as the Fortran file, but a different file extension. For
example, the list file for MYPROG.FOR is MYPROG.LIS.
(MYPROG.LST for some compilers). The list file lists the source program and flags the
line(s) which contain spelling or syntax errors, e.g., a
missing closing parenthesis. Usually, the error is to be found
within the flagged line, but sometimes, it is found in the
line immediately preceding or following. Careful examination
of the flagged lines and their immediate vicinity should take
care of most if not all Class I errors.
Class II errors are a little harder to debug than
Class I errors. In formatted input/output (Chapter 6), the
processor is extremely unforgiving, and will not tolerate
incompatibilities between READ/WRITE and FORMAT state ments.
For instance, the most common Class II error results from an
attempt to read a real variable using an integer format, or
viceversa. Fortunately, Class II errors produce runtime error
messages which generally point the programmer in the right
direction as far as error diagnosis is concerned. In
unformatted input/output, the processor is more forgiving, but
the drawback here is that some errors may go undetected.
Class III errors are more difficult to debug than
either Class I or Class II errors. A Class III error could be
one of logic or compatibility. During runtime, the processor
will usually flag a Class III logic error, helping the user to
di agnose it. A typical example of a Class III logic error is
an attempt to divide by zero. The best way to debug this type
of error is to identify the problem line and the source of the
error, and to fix it. The WRITE statement and the D_LINES
Fortran command qualifier (see Section 1.1) should be used
freely to help identify the problem line.
Unlike a Class III logic error, the processor will usually
not flag a Class III compatibility error. In other words, a
program could be compiled, linked, and run, apparently
successfully, with the processor being unable to discern and
flag a Class III compatibility error.
An example of this type of error is that associated with
the im proper addressing of storage locations, e.g., errors in
subprogram argument lists or in COMMON statements. The best
way to debug a Class III compatibility error is to test the
program against a "benchmark," i.e., a problem for
which the solution is known beforehand. The user should also
ask himself is the result is reasonable. If the answer to this
question is NO, a compatibility error may be at work. While
short programs (say, up to 100 source lines) can be readily
tested for Class III compatibility errors, long programs may
not. This is why long programs should be segmented into
subprograms (Chapter 9), and the subprograms tested
separately.
Class IV errors could be the most difficult to
detect, because no help can be expected to come from the
proces sor. This type of error occurs when a value entered
into storage is, due to an oversight, not what it was
intended. For example, assume a variable has a value of 3.92.
By mistake, the value is entered as 3.29. This type of error
can only be corrected through careful scrutiny of the input
file.
2.10 EXAMPLE PROGRAMS
Example Program 1: Use of DATA Statement and Connection to
an Output File (for later printing) The following program uses
a DATA statement to assign specific values (3. and 4.) to the
two sides of a right trian gle. Then it proceeds to calculate
the hypotenuse using the intrinsic function SQRT(X) and to
write all three values to an output file named SIDE_C.OUT. (An
intrinsic function is a commonly used function that is
supplied as part of the FORTRAN library. For a list, refer to
Section 5.4). Note that this is only an example. Normally,
input would not be performed with a DATA statement, but
rather, via an input file (Example 2) or directly to the
screen (Example 3).
The optional PROGRAM statement is at the top; the END
statement is at the bottom. The DATA statement precedes all
executable statements for the sake of improved readability.
The OPEN statement connects unit 6 to file SIDE_C.OUT and
precedes all WRITE statements. All WRITE statements are
unformatted.
Using operating system commands, the output file
(SIDE_C.OUT) can be examined by editing it, typing it (to the
screen), or printing it (obtaining a hard copy).
Example Program 1: Data Statement And Output File
C234567890
PROGRAM HYPOTENUSE_1
DATA SIDEA,SIDEB /3.,4./
OPEN(6,FILE='SIDE_C.OUT',STATUS='UNKNOWN')
X= SIDEA**2 + SIDEB**2
SIDEC= SQRT(X)
WRITE(6,*)'SIDE A IS EQUAL TO ',SIDEA
WRITE(6,*)'SIDE B IS EQUAL TO ',SIDEB
WRITE(6,*)'SIDE C IS EQUAL TO ',SIDEC
END
|
Example Program 2: Connection to Input and Output
Files
The following program reads the values of the two sides of
a right triangle from an input file SIDES.DAT. It proceeds to
calculate the hypotenuse using the intrinsic function SQRT(X)
and to write the value of the hypotenuse to an output file
SIDE_C.OUT.
Note the order of statements in this program. The PROGRAM
statement is at the top. The END statement is at the bottom.
An OPEN statement connects unit 5 to input file SIDES.DAT and
precedes the READ statement. An other OPEN statement connects
unit 6 to output file SIDE_C.OUT and precedes the WRITE statement. Both READ and
WRITE statements are unformatted. There is no need for STOP or
CLOSE statements in this example.
Using an editor, the input file (SIDES.DAT) should be
created before running this program. Otherwise, the vari ables
SIDEA and SIDEB would be undefined at running time. After
running the program, the generated output file (SIDE_C.OUT)
can be examined by editing it, typing it (to the screen), or
printing it (obtaining a hard copy).
Example Program 2: Connection to Input and Output
Files
C234567890
PROGRAM HYPOTENUSE_2
OPEN(5,FILE='SIDES.DAT',STATUS='UNKNOWN')
OPEN(6,FILE='SIDES.OUT',STATUS='UNKNOWN')
READ(5,*) SIDEA, SIDEB
X= SIDEA**2 + SIDEB**2
SIDEC= SQRT(X)
WRITE(6,*)'SIDE C IS EQUAL TO ',SIDEC
END |
Example Program 3: Direct Screen Input and Output
The following program reads the values of the two sides of
a right triangle directly from the screen (direct screen or
interactive input). It proceeds to calculate the hypotenuse
using the intrinsic function SQRT(X) and to write the value of
the hypotenuse directly to the screen (direct screen or
interactive output).
Note the following features of this program:
The PROGRAM statement is at the top; the END state ment
is at the bottom.
Each of the two READ statements is immediately pre
ceded by a WRITE statement containing an input prompt, which
is a character constant displayed on the screen to prompt the
user to enter the requested input data.
This program generates its own input prompts by means
of an unformatted WRITE.
Example Program 3: Direct Screen Input and Output
C234567890
PROGRAM HYPOTENUSE_3
WRITE(6,*) 'ENTER SIDE A: '
READ(5,*) SIDEA
WRITE(6,*) 'ENTER SIDE B: '
READ(5,*) SIDEB
X= SIDEA**2 + SIDEB**2
SIDEC= SQRT(X)
WRITE(6,*)'SIDE C IS EQUAL TO ',SIDEC
END |
Example Program 4: Direct Screen Input with Formatted
Input Prompts
The only difference between this example and the previous
one is that the input prompts have been formatted to per mit
the input data to follow the input prompt on the same line.
Although formally treated in Chapter 6, this example serves
the purpose of introducing the student to some sim ple and
useful formatting techniques.
The input prompts are generated with a special formatted
WRITE containing (1) an edit descriptor 1X, to properly
specify carriage control, (2) a character field descriptor A,
which specifies that the value to be written is a character
constant, and (3) an edit descriptor $, which suppresses the
normal carriage return, thereby permitting the input data to
follow the input prompt on the same line.
Example Program 4: Direct Screen Input with Formatted
Input Prompts
C234567890
PROGRAM HYPOTENUSE_4
WRITE(6,'(1X,A,$)') 'ENTER SIDE A: '
READ(5,*) SIDEA
WRITE(6,'(1X,A,$)') 'ENTER SIDE B: '
READ(5,*) SIDEB
X= SIDEA**2 + SIDEB**2
SIDEC= SQRT(X)
WRITE(6,*)'SIDE C IS EQUAL TO ',SIDEC
END |
2.11 SUMMARY
This chapter introduces five basic and important state
ments: READ, WRITE, OPEN, CLOSE, and DATA.
These are all executable statements; therefore, they
should follow all nonexecutable statements in a program unit.
The READ and WRITE statements are used for input and
output, respectively. The OPEN and CLOSE statements
are used to connect and disconnect files to and from units,
respectively, and to prepare them for input and output
operations. There is no need to need to explicitly
disconnect files at the end of a source program.
The DATA statement is used to provide initial values
for variables, either because initial values are needed, or
because these values are intended to remain constant
throughout the execution of the source program.
It is
good programming practice to place all DATA statements
together, immediately preceding the executable portion of the
source program.
CHAPTER 2 -- PROBLEMS
Write an interactive program (direct screen input and
output) to calcu late the volume of a cylinder of diameter
DIA= 2 in., and height HEI= 3 in. Use input prompts as needed.
Output should include the following label: THE VOLUME OF THE
CYLINDER IS, followed by the actual volume, in turn followed
by the label CUBIC INCHES.
Write an interactive program (direct screen input and
output) to calcu late the volume of a cone of base diameter
DIA= 3.5 cm and height HEI= 5.5 cm. (The volume of a cone is
V= πr2h/3). Use input prompts as needed. Output should
include the following label: THE VOLUME OF THE CONE IS,
followed by the actual volume, in turn followed by the label
CUBIC CENTIMETERS. [Hint: Use 0.3333333 to express the factor
1/3 to an accuracy of 7 significant digits, typical of most
computers].
Write an interactive program to calculate the volume of a
sphere of ra dius RADIUS= 0.6 ft. (The volume of a sphere is
V= 4πr3/3). Use an input prompt as needed. Output should
include the following label: THE VOLUME OF THE SPHERE IS,
followed by the actual volume, in turn followed by the label
CUBIC FEET. [Hint: Use 1.333333 to ex press the factor 4/3 to
an accuracy of 7 significant digits, typical of most
computers].
Using your screen editor, type the program of Example 1
in Section 2.10 using instead the following data: SIDEA= 15.,
SIDEB= 20. Run the program and look at the contents of the
output file SIDE_C.OUT. Then, modify the program to write the
results using only one WRITE state ment (instead of three).
[Hint: Use the continuation field]. Run the program and
compare the new output with the previous output. What can you
conclude about the unformatted WRITE?
Using your screen editor, type the program of Example 2
in Section 2.10. Run the program with the following input
data: SIDEA= 48., SIDEB= 62. Then, modify the program to
calculate the square root without resorting to the intrinsic
function SQRT. [Hint: Use C= (A2 + B2)0.5]. Run the modified
program and note the difference in the result, if any.
Using your screen editor, type the program of Example 3
in Section 2.10. Run the program with the following input
data: SIDEA= 134., SIDEB= 258. Then, modify the program by
omitting the edit descriptor 1X and run the program again.
Observe what happens this time: The first letter of the input
prompt has disappeared! Can you fix this with out putting back
the edit descriptor? [Hint: Include a leading blank space as
part of the character constant defining the prompt]. What can
you conclude about the purpose of the edit descriptor?
Repeat Problem 1 instead connecting to input and output
files. Before running the program, create the input file and
use your screen editor to enter the data. After running the
program, look at the output file to examine your results.
Repeat Problem 2 instead connecting to input and output
files. Before running the program, create the input file and
use your screen editor to enter the data. After running the
program, look at the output file to examine your results.
Repeat Problem 3 instead connecting to input and output
files. Before running the program, create the input file and
use your screen editor to enter the data. After running the
program, look at the output file to examine your results.
Write an interactive program to convert air temperature
in degrees Farenheit to degrees Celsius [ToC= (ToF -
32)/1.8]. Use the variable names TDFAR for input and TDCEL
for output, and the following input prompt: PLEASE ENTER AIR
TEMPERATURE (IN DEGREES FARENHEIT): . Use the edit descriptor
$ to suppress carriage return after the input prompt. Precede
the output with the following label: THE AIR TEMPERATURE (IN
DEGREES CELSIUS) IS: . Run your program first with TDFAR= 103,
and then, with TDFAR= 104. What can you conclude about the
unformatted WRITE?
Write a program to calculate the value of eγ, where e is
the natural log base and γ is Euler's constant (γ = 0.5772157).
Use the intrinsic function EXP(X) from Table 5.4. Write the
result to an output file connected to unit 8, preceded by the
label THE VALUE OF E**GAMMA IS: . Use an OPEN statement that
omits the file name specification. Type the default file name
for examination; for example, the file FOR008.DAT.
Write an interactive program (direct screen input and
output) to convert a given trigonometric angle in degrees to
radians. Use the variable names DEGREE for input and RADIAN
for output, and the following input prompt: PLEASE ENTER
TRIGONOMETRIC ANGLE (IN DEGREES):. Use the edit descriptor $
to suppress carriage return after the input prompt. Precede
the output with the following label: THE ANGLE (IN RADIANS)
IS: . Run your program first with DEGREE= 355, and then, with
DEGREE= 360.
The volume V of a spherical cap of radius r and height h
is equal to:
V= (1/3) πh2(3r - h). Write an interactive program to
perform this calculation. Run your program with RAD= 3
inches, and HEI= 1.4 inches. Output should include the
following label: THE VOLUME OF THE SPHERICAL CAP IS, followed
by the actual volume, in turn followed by the label CUBIC
INCHES. [Hint: Use 0.3333333 to express 1/3 to an accuracy of
7 significant digits, typical of most computers].
Repeat Problem 13 disregarding the hint and using 1/3
instead. What happens in this case? What can you surmise from
this exercise? How can you fix it?
The area of a regular polygon of n sides, each of length
b, is equal to: A= (1/4) nb2cot (π/n). Write an interactive
program to perform this calculation. Run your program using
NSIDES= 6 and BLENGT= 4 cm. Output should include the
following label: THE AREA OF THE REGULAR POLYGON IS, followed
by the actual area, in turn fol lowed by the label SQUARE
CENTIMETERS. [Hint: Use 0.25 instead of 1/4, and express the
cotangent in terms of the intrinsic functions SIN(X) and
COS(X) of Table 5.4].
|