Week 8

1. Week 8 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 factorialn! = n (n-1)!0! = 1 • That’s all you need to calculaten!

4. Recursive procedures • recursivefunction 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

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. recursivefunctionfactorial(n) result(factorial_n) ! Dummy argument and result variableinteger, intent(in) :: nreal :: factorial_n ! Determine whether further recursion is requiredselectcase(n)case(0) ! Recursion has reached the end factorial_n = 1.0case(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.0endfunction factorial

8. Solution 2 Write a subroutine for n! Using “select case” structure. recursivesubroutinefactorial(n, factorial_n) ! Dummy argumentsinteger, intent(in) :: nreal, intent(out) :: factorial_n ! Determine whether further recursion is requiredselectcase(n)case(0) ! Recursion has reached the end factorial_n = 1.0case(1:) ! Recursive call(s) required ! to obtain (n-1)! callfactorial(n-1, factorial_n)case default ! n is negative - return zero as an error indicator factorial_n = 0.0endsubroutine factorial

9. Procedures as arguments • Up to now, procedures had as dummy argumentsreal, integer, character, logicaland 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_bodyend interface

11. How to declare a procedure? • Example:interfacefunction dummy_fun(a, b) result(r)real, intent(in) :: a, breal :: rendfunction dummy_funend interface

12. How to declare a procedure? • Example:interfacesubroutine one_arg(x)real, intent(inout) :: xendsubroutine one_argrecursivesubroutine two_args(x, y)real, intent(inout) :: x, yendsubroutine two_argsend 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 todeclare 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_typecomponent_definition . . . endtypenew_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 typeperson

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 :: employeetype(person) :: employeecharacter(len=20) departmentreal :: salaryend 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)

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

25. program example_8_1_1 ! variable declaration real:: result integer :: n print *,"enter n value" read *, n ! result = factorial(n) call factorials(n,result) print *,n,"!=", result end program example_8_1_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) requires factorial_n = n*factorial(n-1) case default ! n is negative - return zero as an error indicator factorial_n = 0.0 end select end function factorial

26. program example_8_1_2! variable declaration real:: result integer :: n print *,"enter n value" read *, n call factorial(n,result) print *,n,"!=", result end program example_8_1_2 recursive subroutine factorial(n, factorial_n)! dummy argument and result variable 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) factorial_n = n*factorial_n case default ! n is negative - return zero as an error indicator factorial_n = 0.0 end select end subroutine factorial

27. Write a module that sorts given v vector in an ascending order