1 / 39

Chapter 6 Programming with Functions

Chapter 6 Programming with Functions. FUNCTIONS. Intrinsic Functions (or called library functions) Function Subprograms: programmer-defined functions. Function Subprograms. The subprogram can be made accessible to a program, called the main program, in three ways: Internal subprogram

tvannoy
Download Presentation

Chapter 6 Programming with Functions

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Chapter 6Programming with Functions

  2. FUNCTIONS • Intrinsic Functions (or called library functions) • Function Subprograms: programmer-defined functions

  3. Function Subprograms • The subprogram can be made accessible to a program, called the main program, in three ways: • Internal subprogram • Module subprogram • External subprogram

  4. Argument Association (Figure 6.1)

  5. Fundamental Scope Principle • The scope of an entity is the program or subprogram in which it is declared. • Scope Rule 1: An item declared within a subprogram is not accessible outside that subprogram. • Scope Rule 2: A global entity is accessible throughout the main program and in any internal subprogram in which no local entity has the same name as the global item.

  6. Saving the Values of Local Variables • The values of local variables in subprogram are not retained from one execution of subprogram to the next unless either: 1. they are initialized in their declarations, or 2. The are declared to have the SAVE attribute.

  7. Saving the Values of Local Variables FUNCTION F (......) INTEGER :: Count = 0 ...... ...... Count = Count + 1 ...... ...... END FUNCTION F (......) or by using SAVE statement

  8. Declaring a Function’s Type • FUNCTION Atomic_Number (X, Y) • INTEGER :: Atomic_Number • REAL, INTENT (IN) :: X, Y • ……….. ……….. ……….. • ……….. ……….. ……….. • END FUNCTION Atomic_Number • INTEGER FUNCTION Atomic_Number (X, Y) • REAL, INTENT (IN) :: X, Y • ……….. ……….. ……….. • ……….. ……….. ……….. • END FUNCTION Atomic_Number

  9. Introduction to Modules (模組) • MODULE module-name • CONTAINS • subprogram_1 • subprogram_2 • ． • ． • ． • subprogram_n • END MODULE module-name Purpose: Packages subprogram_1, subprogram_2, ．．．, subprogram_n together into a library that can be used in any other program unit.

  10. Using Module: USE Statement Forms: • USE module-name • USE module-name, ONLY: list • USE module-name, rename-list • Examples: Figure 6.8 and Figure 6.9 • USE Temperature_Library, ONLY: Fahr_to_Celsius

  11. Compiling and Linking Programs and Modules

  12. Compiling and Linking Programs and Modules • Compilation, in which the source program is translated to an equivalent machine-language, called an object program, which is stored in an object file. • Linking, in which any references to functions contain a module are linked to their definitions in that module, creating an executable program, which is stored in an executable file.

  13. Compiling and Linking Programs and Modules • Separate compilation of program’s source file, creating an object file. • Separate compilation of the module, creating a different object file. • Linking the function calls the program’s object file to function definitions in the module’s object file, creating an executable program.

  14. External Functions EXTERNAL (外界的) SUBPROGRAMS Example: Figure 6.10 INTERFACES (界面) • Internal subprogram: explicit (明確的) interface • External subprogram: implicit (不明確的；含蓄的) interface • To ensure that a compiler can perform the necessary consistency check, it is desirable that external subprograms have explicit interfaces.

  15. Interface Blocks • Interface blocks can be used to provide these explicit interfaces. • INTERFACE • Interface-body • END INTERFACE Example: Figure 6.11

  16. Chapter 7 Programming with Subroutines

  17. Programming with Subprograms • Subprograms in Fortran can be either functions or subroutines. • Complex problems are best solved by dividing them into simpler sub-problems and designing subprograms to solve these sub-problems.

  18. Subroutine Subprogram subroutine heading specification part execution part END SUBROUTINE statement • Subroutine Heading : SUBROUTINE subroutine-name (formal-argument-list) • CALL Statement: CALL SUBROUTINE subroutine-name (actual-argument-list)

  19. Example: Displaying an Angle in Degrees • An angular measurement in degrees, minutes, and seconds, say 100° 30' 36″ is equivalent to 100.510° CALL PrintDegrees(NumDegrees, & NumMinutes, NumSeconds)

  20. Figure 7.1: Displaying an Angle in Degrees SUBROUTINE PrintDegrees (Degrees, Minutes, Seconds) INTEGER, INTENT(IN) :: Degrees, Minutes, Seconds PRINT 10, Degrees, Minutes, Seconds, & REAL(Degrees) + REAL(Minutes)/60.0 + & REAL(Seconds)/3600.0 10 FORMAT (1X, I3, " degrees", I3, " minutes", I3, & " seconds" / 1X, "is equivalent to" / 1X, F7.3, & " degrees") END SUBROUTINE PrintDegrees

  21. Subroutine Subprograms Subroutine subprograms have many features in common with function subprograms: • They are program units designed to perform particular tasks under the control of some other program unit. • The have the same basic form: each consists of a heading, a specification part, an execution part, and an END statement. • They may be internal, module, or external subprogram

  22. Subroutine Subprograms The different, however, in the following respects: • Functions are designed to return a single value to the program unit that references them. • Subroutines often return more than one value, or they may return no value at all but simple perform some task such as displaying a list of instructions to the user. • Functions return values via function names; subroutines return values via arguments. • A function is referenced by using its name in an expression, where a subroutine is referenced by a CALL statement.

  23. Example of a Subroutine That Returns Values: Converting Coordinates Figure 7.3 x = r × cos θ y = r × sin θ !-Convert_to_Rectangular--------------------------------------------- ! Subroutine to convert polar coordinates (R, Theta) to rectangular ! coordinates (X, Y). ! ! Accepts: Polar coordinates R and Theta (in radians) ! Returns: Rectangular coordinates X and Y !--------------------------------------------------------------------

  24. Converting Coordinates SUBROUTINE Convert_to_Rectangular(R, Theta, X, Y) REAL, INTENT(IN) :: R, Theta REAL, INTENT(OUT) :: X, Y X = R * COS(Theta) Y = R * SIN(Theta) END SUBROUTINE Convert_to_Rectangular

  25. Argument Association CALL Convert_to_Rectangular & (RCoord, TCoord, & XCoord, YCoord) INTENT (IN) attribute INTENT (OUT) attribute INTENT (INOUT) attribute

  26. 7.3 Random numbers Generators • Some initial value called seed is required to begin the process of generating random numbers • Each random number produced is used in computation of the next random number. • Fortran 90 provides the subroutine RANDOM_SEED to initial the random number generator RANDOM_NUMBER, which is a subroutine that produces random real numbers uniformly distributed over the range 0 to 1.

  27. Example Dice Tossing (Figure 7.6) ! Seed the random number generator CALL RANDOM_SEED ．．．．．．． CALL RANDOM_NUMBER(R1) CALL RANDOM_NUMBER(R2) Die_1 = 1 + INT(6*R1) Die_2 = 1 + INT(6*R2) Pair = Die_1 + Die_2

  28. Normal Distributions

  29. Probabilities for Dice Tossing

  30. 7.6 Subprograms as Arguments

  31. Subprograms as Arguments In our examples of subprograms that far, the actual arguments have been constants, variables, or expressions, but Fortran also permits functions and subroutine as arguments for other subprograms. In this case, the function or subroutine must be a module subprogram, an external subprogram, or an intrinsic subprogram. Also, no INTENT attribute is used for formal argument that is a subprogram.

  32. Module containing a function Integrand (Figures 7.11 & 7.12) MODULE Integrand_Function CONTAINS FUNCTION Integrand(X) REAL :: Integrand REAL, INTENT(IN) :: X Integrand = EXP(X**2) END FUNCTION Integrand END MODULE Integrand_Function

  33. Module Subprograms as Arguments PROGRAM Definite_Integral_2 USE Integrand_Function IMPLICIT NONE REAL :: A, B INTEGER :: Number_of_Subintervals WRITE (*, '(1X, A)', ADVANCE = "NO") & "Enter the interval endpoints and the # of subintervals: " READ *, A, B, Number_of_Subintervals CALL Integrate(Integrand, A, B, Number_of_Subintervals)

  34. External Subprograms as Arguments type, EXTERNAL ::function-name Figure 7.13, p. 480

  35. Intrinsic Subprograms as Argument Integrand = SIN (x) Figure 7.14, p. 481

  36. Interface Blocks INTERFACE FUNCTION Integrand(X) REAL :: Integrand REAL, INTENT(IN) :: X END FUNCTION Integrand END INTERFACE

  37. Interface Blocks (Figure 7.15, p. 483) REAL FUNCTION Integrand(X) REAL, INTENT(IN) :: X Integrand = EXP(X**2) END FUNCTION Integrand

  38. 7.7 Optional and Keyword Arguments of Subprograms • A + BX + CX2 +DX3 + EX4 FUNCTION Polynomial (X, A, B, C, D, E) REAL ::Polynomial REAL, INTENT (IN) ::X, A, B, C, D, E Polynomial = A + B*X + C*X**2 & + D*X**3 + E*X**4 END FUNCTION Polynomial

  39. Keyword Arguments (Figure 7.16) FUNCTION Polynomial(X, A, B, C, D, E) REAL :: Polynomial REAL, INTENT(IN) :: X, A REAL, INTENT(IN), OPTIONAL :: B, C, D, E Polynomial = A IF (PRESENT(B)) Polynomial = Polynomial + B*X IF (PRESENT(C)) Polynomial = Polynomial + C*X**2 IF (PRESENT(D)) Polynomial = Polynomial + D*X**3 IF (PRESENT(E)) Polynomial = Polynomial + E*X**4 END FUNCTION Polynomial

More Related