Edit Descriptors. Decimal form. Fw.d Exponential form Ew.d Ew.dEe Scientific form ESw.d ESw.dEe Engineering form ENw.d ENw.dEe.

Transcription

1 Format Edit Descriptors The tedious part of using Fortran format is to master many format edit descriptors. Each edit descriptor tells the system how to handle certain type of values or activity. Each value requires some positions. For example, an integer of four digits requires at least four positions to print. Therefore, the number of positions to be used is the most important information in an edit descriptor. We shall use the following convention of symbols: w: the number of positions to be used m: the minimum number of positions to be used d: the number of digits to the right of the decimal point e: the number of digits in the exponent part Although we may print a number using as many positions as you want, this is only for input/output. This number of positions is not the precision (i.e., the number of significant digits) of that number. To be more precisely, computers normally can store real numbers up to seven significant digits. This is the precision of real numbers. However, we can print a real number using 50 positions in which 25 positions are for the fraction part. This is only a way of describing the appearance and does not change the precision of real numbers. The following are the editor descriptors to be discussed. Purpose Edit Descriptors Reading/writing INTEGERs Iw Iw.m Reading/writing REALs Reading/writing LOGICALs Decimal form Fw.d Exponential form Ew.d Ew.dEe Scientific form ESw.d ESw.dEe Engineering form ENw.d ENw.dEe Reading/writing CHARACTERs A Aw Positioning Others Horizontal Lw nx Tabbing Tc TLc and TRc Vertical / Grouping r(...) Format Scanning Control : Sign Control Blank Control S, SP and SS BN and BZ Most edit descriptors can be repeated and several edit descriptors can be grouped into a group. For most of the cases, edit descriptors are separated by commas. The following is an example: CHARACTER(LEN=30) :: Format Format = "(5X, I5.2, F10.3, A, ES14.7)" READ(*,Format)... variables...

2 WRITE(*,Format)... variables and expressions... In the above example, format Format has five edit descriptors 5X, I5.2, F10.3, A and ES14.7. Adjacent edit descriptors are separated by a comma. The I Descriptor The Iw and Iw.m descriptors are for INTEGER output. The general form of these descriptors are as follows: The meaning of r, w and m are: riw and riw.m I is for INTEGER w is the width of field, which indicates that an integer should be printed with w positions. m indicates that at least m positions (of the w positions) must contain digits. If the number to be printed has fewer than m digits, leading 0s are filled. If the number has more than m digits, m is ignored and in this case Iw.m is equivalent to Iw. Examples Note that w must be positive and larger than or equal to m. Let us look at the following example. There are three INTEGER variables a, b and c with values 123, -123 and , respectively. In the following table, the WRITE statements are shown in the left and their corresponding output, all using five positions, are shown in the right. The F Descriptor The Fw.d descriptor is for REAL output. The general form is: rfw.d The meaning of r, w and d are: F is for REAL

3 w is the width of field, which indicates that a real number should be printed with w positions. d indicates the number of digits after the decimal point. More precisely, of these w positions, the right-most d positions are for the fraction part of a real number, and the d+1 position from the right is a decimal point. The remaining w-(d+1) positions are for the integral part. This is shown in the figure below: Examples Let us look at the following example. There are two REAL variables a and b with values and , respectively. In the following table, the WRITE statements are shown in the left and their corresponding output, all using five positions, are shown in the right. The E Descriptor The Ew.d and Ew.dEe descriptors are for REAL output. The printed numbers will be in an exponential form. The general form of these descriptors are discussed below. There are two more forms, ESw.d and ENw.d, which will be discussed at the bottom of this page. The meaning of r, w, d and e are: rew.d and rew.dee E is for REAL numbers in exponential forms. w is the width of field, which indicates that a real number should be printed with w positions. To print a number in an exponential form, it is first converted to a normalized form s0.xxx...xxx 10 sxx, where s is the sign of the number and the exponent and x is a digit. For example, , , and are converted to , , and The Ew.d descriptor generates real numbers in the following form:

4 Examples In the following table, the WRITE statements use different E edit descriptors to print the value of The WRITE statements are shown in the left and their corresponding output, all using 12 positions, are shown in the right. Editor Descriptor ESw.d and ESw.dEe Scientists write the exponential form in a slightly different way. This ES edit descriptor is for printing a real number in scientific form, which has a non-zero digit as the integral part. If the number is a zero, then all digits printed will be zero. The following shows the printed form: The L Descriptor The Lw descriptor is for LOGICAL output. While Fortran uses.true. and.false. to indicate logical values true and false, respectively, the output only show T and F. The general form of this descriptor is as follows: The meaning of r and w are: rlw L is for LOGICAL w is the width of field, which indicates that a logical value should be printed with w positions. The output of a LOGICAL value is either T for.true. or F for.false. The single character value is shown in the right-most position and the remaining w-1 positions are filled with spaces. The is shown in the figure below.

5 Examples Let us look at the following example. There are two LOGICAL variables a and b with values.true. and.false., respectively. In the following table, the WRITE statements are shown in the left and their corresponding output are shown in the right. The A Descriptor The A and Aw descriptors are for CHARACTER output. The general form of these descriptors are as follows: The meaning of r and w are: ra and raw A is for CHARACTER w is the width of field, which indicates that a character string should be printed with w positions. The output of the character string depends on two factors, namely the length of the character string and the value of w. Here are the rules: o If w is larger than the length of the character string, all characters of the string can be printed and are right-justified. Also, leading spaces will be added. The following example prints the string "12345" of length 5 (i.e., five characters) using A6. o WRITE(*,'(A6)') "12345" Since w is larger than the length of the string, all five characters are printed and right-justified. The result is shown below: Examples Let us look at the following example. CHARACTER(LEN=5) :: a = "12345" CHARACTER :: b = "*" In the following table, the WRITE statements are shown at the left and their corresponding output are shown at the right.

6 Functions and Modules Syntax In addition to intrinsic functions, Fortran allows you to design your own functions. A Fortran function, or more precisely, a Fortran function subprogram, has the following syntax: type FUNCTION function-name (arg1, arg2,..., argn) [specification part] [execution part] [subprogram part] END FUNCTION function-name Example: Problem Statement Write a program to compute the cubes of 1, 2, 3,..., 10 in both INTEGER and REAL types. It is realcube() for computing the cube of a required to write a function intcube() for computing the cube of an integer and a function real. Solution! ! This program display the cubes of INTEGERs and! REALs. The cubes are computed with two functions:! PROGRAM Cubes INTEGER, PARAMETER :: Iterations = 10 INTEGER :: i REAL :: x DO i = 1, Iterations x = i WRITE(*,*) i, x, intcube(i), realcube(x) END DO CONTAINS

7 ! ! INTEGER FUNCTION intcube() :! This function returns the cube of the argument.! INTEGER FUNCTION intcube(number) INTEGER, INTENT(IN) :: Number intcube = Number*Number*Number END FUNCTION intcube! ! REAL FUNCTION realcube() :! This function returns the cube of the argument.! REAL FUNCTION realcube(number) REAL, INTENT(IN) :: Number realcube = Number*Number*Number END FUNCTION realcube END PROGRAM Cubes. Program Input and Output The following is the output from the above program. 1, 1., 1, 1. 2, 2., 8, 8. 3, 3., 27, 27. 4, 4., 64, 64. 5, 5., 125, , 6., 216, , 7., 343, , 8., 512, , 9., 729, , 10., 1000, What is a Module? In many previous example, there are several internal functions packed at the end of the main program. In fact, many of them such as Factorial(), Combinatorial(), GCD(), and Prime() are general functions that can also be used in other programs. To provide the programmers with a way of packing commonly used functions into a few tool-boxes, Fortran 90 has a new capability called modules. It has a syntactic form very similar to a main program, except for something that are specific to modules. Syntax The following is the syntax of a module: MODULE module-name

8 [specification part] CONTAINS [internal-functions] END MODULE module-name The differences between a program and a module are the following: The structure of a module is almost identical to the structure of a program. However, a module starts with the keyword MODULE and ends with END MODULE rather than PROGRAM and END PROGRAM. A module has specification part and could contain internal function; but, it does not have any statements between the specification part and the keyword CONTAINS. Consequently, a module does not contains statements to be executed as in a program. A module can only contain declarations and functions to be used by other modules and programs. This is perhaps one of the most important difference. As a result, a module cannot exist alone; it must be used with other modules and a main program Short Examples Here are some short examples of modules: The following is a very simple module. It has the specification part and does not have any internal function. The specification part has two REAL PARAMETERs, namely PI and g and one INTEGER variable Counter. MODULE SomeConstants REAL, PARAMETER :: PI = REAL, PARAMETER :: g = 980 INTEGER :: Counter END MODULE SomeConstants The following module SumAverage does not have any specification part (hence no ); but it does contain two functions, Sum() and Average(). Please note that function Average() uses Sum() to compute the sum of three REAL numbers. MODULE SumAverage CONTAINS REAL FUNCTION Sum(a, b, c) REAL, INTENT(IN) :: a, b, c Sum = a + b + c END FUNCTION Sum REAL FUNCTION Average(a, b, c) REAL, INTENT(IN) :: a, b, c Average = Sum(a,b,c)/2.0 END FUNCTION Average END MODULE SumAverage The following module DegreeRadianConversion contains two PARAMETERs, PI and Degree180, and two functions DegreeToRadian() and RadianToDegree(). The two PARAMETERs are used in the conversion functions. Note that these parameters are global to the two functions. See scope rules for the details. MODULE DegreeRadianConversion

9 REAL, PARAMETER :: PI = REAL, PARAMETER :: Degree180 = REAL FUNCTION DegreeToRadian(Degree) REAL, INTENT(IN) :: Degree DegreeToRadian = Degree*PI/Degree180 END FUNCTION DegreeToRadian REAL FUNCTION RadianToDegree(radian) REAL, INTENT(IN) :: Radian RadianToDegree = Radian*Degree180/PI END FUNCTION RadianToDegree END MODULE DegreeRadianConversion Problem Statement The combinatorial coefficient C(n,r) is defined as follows: where 0 <= r <= n must hold. Write a module that contains two functions: (1) Factorial() and (2) Combinatorial(). The former computes the factorial of its argument, while the latter uses the former to compute the combinatorial coefficient. Then, write a main program that uses this module. Solution The following is the desired module:! MODULE FactorialModule! This module contains two procedures: Factorial(n) and! Combinatorial(n,r). The first computes the factorial of an integer! n and the second computes the combinatorial coefficient of two! integers n and r. MODULE FactorialModule CONTAINS! FUNCTION Factorial() :! This function accepts a non-negative integers and returns its! Factorial. INTEGER FUNCTION Factorial(n) INTEGER, INTENT(IN) :: n! the argument INTEGER :: Fact, i! result

10 Fact = 1! initially, n!=1 DO i = 1, n! this loop multiplies Fact = Fact * i! i to n! END DO Factorial = Fact END FUNCTION Factorial! FUNCTION Combinarotial():! This function computes the combinatorial coefficient C(n,r).! If 0 <= r <= n, this function returns C(n,r), which is computed as! C(n,r) = n!/(r!*(n-r)!). Otherwise, it returns 0, indicating an! error has occurred. INTEGER FUNCTION Combinatorial(n, r) INTEGER, INTENT(IN) :: n, r INTEGER :: Cnr IF (0 <= r.and. r <= n) THEN! valid arguments? Cnr = Factorial(n) / (Factorial(r)*Factorial(n-r)) ELSE! no, Cnr = 0! zero is returned END IF Combinatorial = Cnr END FUNCTION Combinatorial END MODULE FactorialModule Here is the main program:! PROGRAM ComputeFactorial:! This program uses MODULE FactorialModule for computing factorial! and combinatorial coefficients. PROGRAM ComputeFactorial USE FactorialModule! use a module INTEGER :: N, R WRITE(*,*) 'Two non-negative integers --> ' READ(*,*) N, R WRITE(*,*) N, WRITE(*,*) R, '! = ', Factorial(N) '! = ', Factorial(R) IF (R <= N) THEN! if r <= n, do C(n,r) WRITE(*,*) 'C(', N, ',', R, ') = ', Combinatorial(N, R) ELSE! otherwise, do C(r,n) WRITE(*,*) 'C(', R, ',', N, ') = ', Combinatorial(R, N) END IF END PROGRAM ComputeFactorial. Program Input and Output

11 The following is the output from the above program. Two non-negative integers --> ! = ! = 24 C(13,4) = 221 Subroutines YYYYMMDD to Year, Month, Day Conversion Problem Statement In data processing, the year, month and day information are usually written as yyyymmdd, where the first four digits are Year, the fifth and sixth digits are Month, and the last two digits are Day. For example, means April 8, 1971, and means January 1, Write a program to read an integer in the form of yyyymmdd and extract the values of Year, Month and Day. Do it with an external subroutine. Solution! PROGRAM YYYYMMDDConversion:! This program uses an external subroutine Conversion() to convert! an integer value in the form of YYYYMMDD to Year, Month and Day. PROGRAM YYYYMMDDConversion INTERFACE! interface block SUBROUTINE Conversion(Number, Year, Month, Day) INTEGER, INTENT(IN) :: Number INTEGER, INTENT(OUT) :: Year, Month, Day END SUBROUTINE Conversion END INTERFACE INTEGER :: YYYYMMDD, Y, M, D DO! loop until a zero is seen WRITE(*,*) "A YYYYMMDD (e.g., ) please (0 to stop) -> " READ(*,*) YYYYMMDD! read in the value IF (YYYYMMDD == 0) EXIT! if 0, then bail out CALL Conversion(YYYYMMDD, Y, M, D)! do conversation WRITE(*,*) "Year = ", Y WRITE(*,*) "Month = ", M WRITE(*,*) "Day = ", D WRITE(*,*) END DO END PROGRAM YYYYMMDDConversion! display results

12 ! SUBROUTINE Conversion():! This external subroutine takes an integer input Number in the! form of YYYYMMDD and convert it to Year, Month and Day. SUBROUTINE Conversion(Number, Year, Month, Day) INTEGER, INTENT(IN) :: Number INTEGER, INTENT(OUT) :: Year, Month, Day Year = Number / Month = MOD(Number, 10000) / 100 Day = MOD(Number, 100) END SUBROUTINE Conversion. Program Input and Output The following is the output from the above program for the input 3.0, 6.0 and 8.0: A YYYYMMDD (e.g., ) please (0 to stop) -> Year = 1997 Month = 10 Day = 26 A YYYYMMDD (e.g., ) please (0 to stop) -> Year = 2016 Month = 1 Day = 31 A YYYYMMDD (e.g., ) please (0 to stop) -> Year = 1901 Month = 1 Day = 3 A YYYYMMDD (e.g., ) please (0 to stop) -> 0 Use of arrays and array sections The English word "array" is translated into Swedish as "fält", which, retranslated into English, is "field". It is possible therefore, that we may use the word field either by mistake, or as a suitable name of a specific array. A new feature of Fortran 90 is that you can work directly with a whole array or an array section without explicit (or implicit) DO-loops. In the old Fortran you could in some circumstances work directly with a whole array, but then only during I/O processing. An array is defined to have a shape, given by its number of dimensions, called "rank", and the extent of each dimension. Two arrays agree if they have the same shape. Operations are normally done element by element. Please note that the rank of an array is the number of dimensions and has nothing to do with the mathematical rank of a matrix!

13 In the following simple example I show how you can assign matrices with simple statements like B = A, how you can use the intrinsic matrix multiplication MATMUL and the addition SUM, and how you can use the array sections (in the example below I use array sections which are vectors). PROGRAM ARRAY_EXAMPLE INTEGER REAL, DIMENSION (4,4) DO I = 1, 4 END DO DO J = 1, 4 A(I, J) = (I-1.2)**J END DO :: I, J :: A, B, C, D, E! calculate a test matrix B = A*A! element for element multiplication CALL PRINTF(A,4) ; CALL PRINTF(B,4) C = MATMUL(A, B)! internal matrix multiplication DO I = 1, 4! explicit matrix multiplication DO J = 1, 4 D(I, J) = SUM( A(I,:)*B(:,J) ) END DO END DO CALL PRINTF(C,4) ; CALL PRINTF(D,4) E = C - D! comparison of the two methods CALL PRINTF(E,4) CONTAINS SUBROUTINE PRINTF(A, N)! print an array INTEGER :: N, I REAL, DIMENSION (N, N) :: A DO I = 1, N WRITE(*,' (4E15.6)') A(I,:) END DO WRITE(*,*)! write the blank line END SUBROUTINE PRINTF END PROGRAM ARRAY_EXAMPLE Read and Write (internal file) Sometimes it is convenient in a Fortran program to use files for accessing or storing data - especially when large amounts of data are involved. Too much keyboard input during the run of a program leads to mistakes and tedium, while too much screen output has similar consequences. Putting data into files - both for input and output - is a more leisurely and less error-prone approach. Open The open command is used to open files - that is, it makes files available so that Fortran can read or write to them. The simplest form of the command is open (unit = number, file = "name"). In place of number you insert a positive integer (but not 6) to be used to refer to the file, and instead of name you insert the name of the file. Here are examples of open commands: open (unit = 2, file = "scores") open (unit = 7, file = "a:scores.txt")

14 open (unit = 5, file = "h:primes") open (unit = 24, file = "c:divisors.dat"). Fortran uses the unit number to access the file with later read and write statements. Several files can be open at once, but each must have a different number. There is one thing to remember about numbering a file - you cannot use the number 6, as GNU Fortran reserves that number to refer to the screen. Note that quotes enclose the filename. If you do not specify the drive of the file, or if you specify the same drive upon which GNU Fortran is installed, GNU Fortran will by default assume the file is located on the same drive and in the same directory from where Fortran is running. If you specify a drive letter different from where GNU Fortran is installed, it will look for or place the file in the main root directory of the specified drive. Unfortunately you cannot specify a directory address - the compiler will produce an error message if you do. Observe that you do not include a backslash before the file name - nor do you put a space on either side of the colon after the drive letter. If the named file does not already exist, Fortran will create it; if it does exist, Fortran will replace it. (So don't mistakenly give the file the same name as another important file!) Close The close command is used to close one or more files - examples are close (5), close (1, 3, 8). The first of these commands closes the file numbered 5, while the second closes the three files numbered 1, 3, and 8. It is not necessary to close files; all files will automatically be closed when an end or stop statement is executed. However, in programs handling large amounts of data it can be prudent to close files before the end of the program in order to avoid possible memory problems and to increase efficiency. Write (to Files) The write command is used to write data to a file. For example, the command write (7,*) works like a print * command, except that data is written to the file numbered 7 instead of to the screen. The two statements print *, "The solutions to the equation are : ", x1, x2 write (7,*) "The solutions to the equation are : ", x1, x2 produce exactly the same output, except that the first writes to the screen and the second to file number 7. The command "write (7,*)" on a line by itself serves as a line feed, skipping a line in the file numbered 7 before the next writing to that file. You can also use write statements in conjunction with format statements to write to a file; this gives you better control of formatting. In the following, the first number in "write (7,5)" refers to the file number and the second to the label of the format statement: write (7,5) "The solutions are ", x1, " and ", x2 5 format (a,f16.10,a,f16.10) The "write (7,5)" command works exactly like the similar command "write (*,5)", except that in the former output is directed to file number 7, and in the latter to the screen.

15 Each execution of a write command writes to a single line in a file. The next write command will write to a new line. Here is a program that finds and prints to a file the divisors of an integer n : program divisors c This program finds the divisors of an integer input by the user. c The divisors are printed to a file. integer n, k, d(10) open (unit = 1, file = "divisors") print *, "Enter a positive integer :" read *, n write (1,*) "Here are the divisors of ", n, " :" k = 0 do i = 1, n if (mod(n,i).eq. 0) then k = k + 1 d(k) = i end if if (k.eq. 10) then write (1,5) (d(j), j = 1, 10) k = 0 end if end do write (1,5) (d(j), j = 1, k) 5 format (10i7) close (1) print *, "The divisors are listed in the file 'divisors'. Bye." end Note that the program counts the divisors, storing them in an array d, until 10 are accumulated; then it prints these 10 on a single line, reserving 7 places for each divisor. It then begins a new count and repeats the procedure until all divisors are found. The last write statement prints whatever divisors are left over after the last full line of 10. The close statement, included here for demonstration only, is unnecessary, as the program is all but finished at that point and the end statement will automatically close the file anyway. Read (from Files) The read statement is used to read data from a file. Generally data is read from a file in the standard way, line-by-line and from left to right. But you must remember that each read statement begins reading a new line, whether or not the preceding read statement used all the data in the preceding line. Suppose for example that a file is numbered 7, and that the first two lines of the file contain the data (separated by commas) 1.23, 4.56, 7.89

16 11, 13, "Sally" If the first two read statements in the program are read (7,*) x, y, z read (7,*) m, n, first, then the program assigns x = 1.23, y = 4.56, z = 7.89, m = 11, n = 13, first = "Sally". The variables will have to be declared in the program to correspond with the data assigned them by the read statements. For instance, in the above situation x, y, and z will have been declared real variables, m and n integers, and "first" a character variable. Failure to match variable types with data types will most likely lead to error messages. It is possible that a program does not know beforehand the length of a file. If data is being read from a loop, there is a way to exit the loop when all data in the file has been read, thereby avoiding a program hang-up. One simply modifies the read statement to something like read (7,*,end=10). This command instructs Fortran to read the next line in the file numbered 7, but to jump to the statement labelled 10 in the program in the event that the last line in that file has already been read. You can also use format specifiers in read statements, but this can be somewhat tedious and we will not go into the details. As but one example, suppose you want to make the assignments n = 77, x = , y = 67.8, where n is an integer and x and y are real variables. Then you may use the read and format statements read (7,5) n, x, y 5 format (i2,f5.2,f3.1), and in file number 7 place the corresponding line of data Fortran will read and separate the data, insert appropriate decimal points, and assign it to the variables. But as you can see the method is confusing and perhaps not worth the effort. Home Work: Problem Statement 1 Write a program that for x = 2.0, 1.8, 1.6, 1.4,..., 0.8, 0.6, 0.4 and 0.2, prints the sequence number of the value (i.e., 1, 2, 3 and so on), the value itself, and its LOG(x) four times using E, E with three digits for the exponent, ES and EN descriptors. You should generate the output as shown below E E E E-03

17 E E E E E E E E-03 : : : E E E E+00 Problem Statement 2. We have discussed Newton's Method for computing the square root of a positive number. Let the given number be b and let x be a rough guess of the square root of b. Newton's method suggests that a better guess, New x can be computed as follows: One can start with b as a rough guess and compute New x; from New x, one can generate a even better guess, until two successive guesses are very close. Either one could be considered as the square root of b. Write a function MySqrt() that accepts a formal argument and uses Newton's method to computes its square root. Then, write a main program that reads in an initial value, a final value, and a step size, and computes the square roots of these successive values with Newton'e method and Fortran's SQRT() function, and determines the absolute error. Problem Statement 3. A file is to contain a list of names and nick names, to each of which there corresponds a telephone number (students in our class). Write a program which opens this file and new file and copies the list from old file to new file, closing it for use in a new program. Problem Statement 4 Given the array declaration. REAL, Dimension (50,20) :: A a) Write array sections representing i) the first roe of A; ii) the last column of A; iii) every second element in each row and column; Problem Statement 5.

18 Using only array syntax (not DO statement) write a program which a) define an array to have 100 elements; b) assigns to the elements the values 1,2,3, 100 c) reads two integer values in the range 1 to 100; d) reverses the order of the elements of array in the range specified by the two values. Problem Statement 6 It is known that 1 cm is equal to inch and 1 inch is equal to 2.54 cm. Write a program to convert 0, 0.5, 1, 1.5,..., 8, 8.5, 9, 9.5, and 10 from cm to inch and from inch to cm.