Upload
joy-rogers
View
215
Download
0
Tags:
Embed Size (px)
Citation preview
Today’s program
New stuff:– Recursion in F– Procedures as arguments– User-defined data types
Quiz #3
What is recursion?
Recursion in programming is a technique for defining a problem in terms of one or more smaller versions of the same problem.
The solution to the problem is built on the result(s) from the smaller version(s).
What is recursion?
Best known example:the factorial
n! = n (n-1)!0! = 1
That’s all you need to calculate n!
Recursive procedures
recursive function function_name(…) result(result)
Let’s use it to calculate n! Structure plan
• n = 0factorial_n = 1
• n > 0factorial_n = n * factorial(n-1)
• n < 0 Error! Return factorial_n = 0
Solution 1 recursive function factorial(n) result(factorial_n)
! Dummy argument and result variable integer, intent(in) :: n real :: factorial_n ! Determine whether further recursion is required select case(n) case(0) ! Recursion has reached the end factorial_n = 1.0 case(1:) ! More recursive calculation(s) required factorial_n = n*factorial(n-1) case default ! n is negative - return zero as an error indicator factorial_n = 0.0end function factorial
Solution 2 recursive subroutine factorial(n, factorial_n)
! Dummy arguments integer, intent(in) :: n real, intent(out) :: factorial_n ! Determine whether further recursion is required select case(n) case(0) ! Recursion has reached the end factorial_n = 1.0 case(1:) ! Recursive call(s) required ! to obtain (n-1)! call factorial(n-1, factorial_n) case default ! n is negative - return zero as an error indicator factorial_n = 0.0end subroutine factorial
Procedures as arguments
Up to now, procedures had as dummy arguments
real, integer, character, logical
andarrays with these types
But, what about a procedure as a dummy argument?
How to declare a procedure?
We have to provide information concerning the interface of the procedure
The interface block:interface
interface_bodyend interface
How to declare a procedure?
Example:
interface function dummy_fun(a, b) result(r) real, intent(in) :: a, b
real :: r end function dummy_funend interface
How to declare a procedure?
Example:
interface subroutine one_arg(x) real, intent(inout) :: x end subroutine one_arg recursive subroutine two_args(x, y) real, intent(inout) :: x, y end subroutine two_argsend interface
Couple of details...
Dummy procedure arguments in a function must be functions
All actual procedure arguments must be module procedures
It is not permissible for an intrinsic procedure to be an actual argument
Derived data types
You can create your own data types! They can be derived from:
– Intrinsic data types:integer, real, character,
logical
– Previously defined data types
Example
type, public :: person
character(len=12) :: first_name
character(len=1) :: middle_initial
character(len=12) :: last_name
integer :: age
character(len=1) :: sex ! M or F
character(len=5) :: tax_number
end type person
Putting data in a derived type variable
ali = person("Ali","M","Aktepe",56,"M","45645")
mukaddes =
person("Mukaddes"," ","Has",18,"F","12345")
veli = person("Veli","M","Karatepe",65,"M","34567")
This is a structure constructor
Using derived types to define new derived types type, public :: employee type(person) :: employee character(len=20) department real :: salaryend type employee
type(person) :: saadet saadet%employee%age = 34
Arrays of derived types type(person), dimension(1:12) ::
bil102class
Then:
bil102class(2)%sex = "M"
You can do operations on components:
bil102class(3)%age+bil102class(4)%age But no such operation is permissible:
bil102class(3) - bil102class(4)
Example:Let's do some geometry! Two derived types:
– point– line
Two functions:– distinct_points(p1,p2) result(distinct)– line_from_points(p1,p2) result(join_line)