Some Advanced Features of Procedures

Recursion Recursive Calls –A procedure can call itself (Self Recursion) –A can call B, B calls C, etc, Z calls A (Mutual Recursion) Powerful Abstraction –Many functions are recursive in nature –Factorial, Fibonacci, etc. fact(0) = 1 fact(n+1) = (n+1) * fact(n) fib(0) = 1 fib(1) = 1 fib(n+2) = fib(n+1) + fib(n) Such functions can be directly encoded

Complex control Flow Recursive functions abstracts out complex control flow –Different instance of the same procedure exists at a time –Termination and resumption of different instances correctly –Last called is exited first ( Last In First Out LIFO) –Use of stack data structure (stack overflow) –A lot of overhead in implementation

Factorial Example Program fact Implicit none integer:: N, z read *, N call fct(N, z) print *, z contains recursive subroutine fct(M, y) implicit none integer, intent(in):: M integer, intent(out):: y if (M >= 1) then call fct(M - 1, y) y = M * y else y = 1 endif end subroutine end program

Recursive Function Program fact implicit none integer:: N, z read *, N z = fct(N) print *, z contains recursive integer function fct(M) result(answer) implicit none integer:: M, answer if (M /= 0) then answer = M * fct(M - 1) else answer = 1 endif end function end program

Fibonacci Numbers Program fibonacci implicit none integer:: N, z read *, N call fib(N, z) print *, z contains recursive subroutine fib(M, y) implicit none integer, intent(in):: M integer, intent(out):: y integer:: y1, y2 if (M > 1) then call fib(M - 1, y1) call fib(M - 1, y2) y = y1 + y2 else y = 1 endif end subroutine end program

Tower of Hanoi Problem Initial Configuration Original pole Final poleSpare pole

Final Configuration Original poleSpare poleFinal pole

Rules Only one disc can be moved at a time bigger disc never placed over a smaller one only one temporary pole How to solve the problem?

Divide and Conquer Reduce the problem size! How? Consider the following situation: Original pole Finalpolesparepole

Sub problems How to transfer smaller (n-1) discs from initial pole to temporary pole? How to transfer smaller (n-1) discs to the final pole from temporary pole? These two problems are similar but with the problem size reduced and the initial and final poles being different How to solve the sub problems? –Reduce further down (recursion) When (n-1) = 1, the problem becomes trivial

Sub problems Algorithm hanoi_tower (ndisks, init_pole, spare_pole, fin_pole) 1.If (ndisks > 0) then 1.1 hanoi_tower(ndisks - 1, init_pole, fin_pole, spare_pole) 1.2 transfer_disk(init_pole, fin_pole) 1.3 hanoi_tower(ndisks - 1, spare_pole, init_pole, fin_pole) end When the first argument is 0, no action, only empty recursive calls Simplify by removing the recursive calls for the case ndiscs = 1

Fortran Solution requires modeling the problem domain Need software models for all real objects Discs, poles, movements etc. Discs as numbers, poles as stacks, movements as pushes and pops

Quick Sort quick sort is another sorting algorithm which when implemented properly gives the fastest known sorting algorithm for random inputs useful for sorting arrays rather than lists main idea – pick one element, put it in its correct position, all elements < than it to its left and others to its right recursively sort left and right halves expressed easily using recursion

Quick Sort recursive subroutine quick_sort(a) implicit none integer, dimension(:), intent(inout) :: a integer :: i,n n = size(a) if ( n > 1) then call partition(a,i) call quick_sort(a(:i-1)) call quick_sort(a(i+1:)) end if contains

Partition subroutine partition(a,j) integer, dimension(:), intent(inout) :: a integer,intent(out) :: j integer :: i,temp i = 1 ; j = size(a) do if ( i > j ) exit if (a(i) > a(1)) exit i = i+1 end do

Partition do if ((j < i).or. (a(j) <= a(1))) exit j = j-1 end do if ( i >= j) exit temp = a(i) a(i) = a(j) a(j) = temp end do temp = a(j) ; a(j) = a(1) ; a(1) = temp end subroutine partition end subroutine quick_sort

Tail Recursion Any number of recursive calls Complex control flow Difficult to understand Linear Recursion Tail recursion –The recursive call occurs as the last statement –Can be easily translated to iterative programs General recursive programs can also be translated to iterative programs But this requires, in general, a stack (FIFO data structure) Computationally expensive

Keyword Parameters The actual parameter list should match the dummy parameter list in order might prove to be cumbersome when argument lists are large keyword argument is a solution to this problem Suppose test(first, second, third)... end subroutine test the following calls are legal: test(3, 6, 7) test(first = 3, third = 7, second = 6) test(3, third = 7, second = 6) Explicit interface for the procedure required Declare it in a module which can be `used' by the calling routine

Optional Parameters Parameters can be optional Declare –integer, intent(in), optional:: limit The actual argument for limit can be left out in a call and default values can be used A logical function to test whether an optional argument is present or not if (PRESENT(limit) then... else... endif