General Computer Science 320201 GenCS I & II Lecture ... - Kwarc

generally: fn+1 := fn + fn−1 plus start conditions
easy to program in SML:
fun fib (0) = 0 |fib (1) = 1 | fib (n:int) = fib (n-1) + fib(n-2);
Let us look at the recursion relation: {〈n, n − 1〉, 〈n, n − 2〉 | n ∈ N} (it is a tree!)
4
3 2
2 1 1 0
1 0
6
5 4
3
3 2
2 1 2 1 1 0
1 0 1 0
c○: Michael Kohlhase 106
Another thing we see by looking at the recursion relation is that the value fib(k) is computed
n−k+1 times while computing fib(k). All in all the number of recursive calls will be exponential
in n, in other words, we can only compute a very limited initial portion of the Fibonacci sequence
(the first 41 numbers) before we run out of time.
The main problem in this is that we need to know the last two Fibonacci numbers to compute
the next one. Since we cannot “remember” any values in functional programming we take
advantage of the fact that functions can return pairs of numbers as values: We define an auxiliary
function fob (for lack of a better name) does all the work (recursively), and define the function
fib(n) as the first element of the pair fob(n).
The function fob(n) itself is a simple recursive procedure with one! recursive call that returns
the last two values. Therefore, we use a let expression, where we place the recursive call in the
declaration part, so that we can bind the local variables a and b to the last two Fibonacci numbers.
That makes the return value very simple, it is the pair (b,a+b).
A better Fibonacci Function
Idea: Do not re-compute the values again and again!
keep them around so that we can re-use them.
(e.g. let fib compute the two last two numbers)
fun fob 0 = (0,1)
| fob 1 = (1,1)
| fob (n:int) =
let
val (a:int, b:int) = fob(n-1)
in
(b,a+b)
end;
fun fib (n) = let val (b:int,_) = fob(n) in b end;
Works in linear time! (unfortunately, we cannot see it, because SML Int are too small)
c○: Michael Kohlhase 107
If we run this function, we see that it is indeed much faster than the last implementation. Unfortunately,
we can still only compute the first 44 Fibonacci numbers, as they grow too fast, and we
reach the maximal integer in SML.
Fortunately, we are not stuck with the built-in integers in SML; we can make use of more
sophisticated implementations of integers. In this particular example, we will use the module
58