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

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

[Open Statement]   [Close Statement]   [Data Statement]   [Debugging Tools]   [Example Programs]   [Summary]   [Problems]   •   [Top]   [Records and Files]   [Units and File Connection]   [Read Statements]   [Write Statement]

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.

2.6  OPEN STATEMENT

[Close Statement]   [Data Statement]   [Debugging Tools]   [Example Programs]   [Summary]   [Problems]   •   [Top]   [Records and Files]   [Units and File Connection]   [Read Statements]   [Write Statement]   [Unformatted Input/Output Rules]

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

[Data Statement]   [Debugging Tools]   [Example Programs]   [Summary]   [Problems]   •   [Top]   [Records and Files]   [Units and File Connection]   [Read Statements]   [Write Statement]   [Unformatted Input/Output Rules]   [Open 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

[Debugging Tools]   [Example Programs]   [Summary]   [Problems]   •   [Top]   [Records and Files]   [Units and File Connection]   [Read Statements]   [Write Statement]   [Unformatted Input/Output Rules]   [Open Statement]   [Close 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.

2.9  DEBUGGING TOOLS

[Example Programs]   [Summary]   [Problems]   •   [Top]   [Records and Files]   [Units and File Connection]   [Read Statements]   [Write Statement]   [Unformatted Input/Output Rules]   [Open Statement]   [Close Statement]   [Data Statement]

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

[Summary]   [Problems]   •   [Top]   [Records and Files]   [Units and File Connection]   [Read Statements]   [Write Statement]   [Unformatted Input/Output Rules]   [Open Statement]   [Close Statement]   [Data Statement]   [Debugging Tools]

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

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

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 

2.11 SUMMARY

[Problems]   •   [Top]   [Records and Files]   [Units and File Connection]   [Read Statements]   [Write Statement]   [Unformatted Input/Output Rules]   [Open Statement]   [Close Statement]   [Data Statement]   [Debugging Tools]   [Example Programs]

• 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.

PROBLEMS

•   [Top]   [Records and Files]   [Units and File Connection]   [Read Statements]   [Write Statement]   [Unformatted Input/Output Rules]   [Open Statement]   [Close Statement]   [Data Statement]   [Debugging Tools]   [Example Programs]   [Summary]

1. 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.

2. 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= πr²h/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].

3. 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πr³/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].

4. 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?

5. 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= (A² + B²)^0.5]. Run the modified program and note the difference in the result, if any.

6. 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?

7. 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.

8. 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.

9. 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.

10. Write an interactive program to convert air temperature in degrees Farenheit to degrees Celsius [T^oC= (T^oF - 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?

11. 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.

12. 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.

13. The volume V of a spherical cap of radius r and height h is equal to: V= (1/3) πh²(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].

14. 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?

15. The area of a regular polygon of n sides, each of length b, is equal to: A= (1/4) nb²cot (π/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].