1. Improving on building blocks Recursive procedures
Week 9
Improving on building blocks
Recursive procedures

2. What is recursion? Recursion is an important mathematical concept.
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).

3. What is recursion?
Best known example: the factorial n! = n (n-1)! 0! = 1
That’s all you need to calculate n!

4. Recursive procedures Let’s use it to calculate n! Structure plan
recursive function function_name(…) result(result)
Let’s use it to calculate n!
Structure plan
n = 0 factorial_n = 1
n > 0 factorial_n = n * factorial(n-1)
n < 0 Error! Return factorial_n = 0

5. Example ! Factorial,function to calculate factorials recursively
! * accepts : integer n => 0
! * returns : n !
function factorial (n) result (n)
integer : : fact, i
integer, intent (in) : : n
fact = 1
do i = 2, n
fact = fact * i
end do
 end function factorial

6. Example ! Factorial, function to calculate factorials recursively
! * accepts : integer n => 0
! * returns : n !
recursive function factorial (n) result (n)
integer : : fact
integer, intent (in) : : n
if ( n == 0 ) then
fact = 1
else
fact = n * factorial (n-1)
end if
 end function factorial

7. Solution 1 Write a function for n! Using “select case” structure.
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 = 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.0 end function factorial

8. Solution 2 Write a subroutine for n! Using “select case” structure.
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 = 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.0 end subroutine factorial

9. Procedures as arguments
Up to now, procedures had as dummy arguments real, integer, character, logical and arrays with these types
But, what about a procedure as a dummy argument?

10. How to declare a procedure?
We have to provide information concerning the interface of the procedure
The interface block: interface interface_body end interface

11. How to declare a procedure?
Example: interface function dummy_fun(a, b) result(r) real, intent(in) :: a, b real :: r end function dummy_fun end interface

12. 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_args end interface

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

14. Derived data types: Creating your own data
You can create your own data types!
They can be derived from:
Intrinsic data types: integer, real, character, logical
Previously defined data types
F provides the programmers to create their own data type to supplement the above-given intrinsic types.

15. Derived data types and structures
As mentioned before, arrays are used to store elements of the same type. Sometimes items needed to be processed, are not all of the same type.
A data consisting a date for example, has two different types :
·        the month name of character type
·        the day and year of integer type
Another example can be given a record (measurement) captured using a computer, might contain
·        an user’s name in character strings
·        a password in character strings
·        an identification number of integer type
·        captured record of real type

16. Derived data types and structures
F provides a “derived data type” in order to declare a “structure” used to store items of different types.
The position in the structure, in which these data items are stored, are called the “components of the structure”.
It is possible to store a name component, a password component, etc. in a structure using the form of,
type, public :: new_type component_definition
end type new_type

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

18. Example Now you can declare variable of type person:
type ( type­_name ) : : list_of_identifiers
type(person) :: ali, mukaddes, veli

19. Be careful... Declaratins need access to the type definition
Place definitions in a module

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

21. Refering to components
variable%component
structure_name % component_name
Example: ali%last_name mukaddes%age veli%first_name

22. Using derived types to define new derived types
type, public :: employee type(person) :: employee character(len=20) department real :: salary end type employee
type(person) :: saadet
saadet%employee%age = 34

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