Question

I’m trying to understand recursions and caching much better and still I’m making interesting progress(I’m a bit slow at times). I’m having small problems understanding this code:

# Fibonacci recursive with result storage

class FibonacciStorage:
    _storage = { 0:1, 1:1 }
    @staticmethod
    def _fib(number):
        try: # is this already calculated
            return FibonacciStorage._storage[number]   #searches dict, and if value exists then return it
        except KeyError:
            result = FibonacciStorage._fib(number-1) + FibonacciStorage._fib(number-2)  #this is the actual Fibonacci Formula
            FibonacciStorage._storage[number] = result  #adds result to dictionary
            #print FibonacciStorage._storage #this shows the storage list growing with each iteration.
            return result
    @staticmethod
    def fib(number):  #first function, it has two asserts to basically make sure number is whole/positive and if its okay passes it to _fib(where the real work is done)
        # only do the assert statements once
        assert(isinstance(number,int)),"Needs a whole number" 
        assert(number>0),"Needs a positive whole number"
        return FibonacciStorage._fib(number)

# use a more readable name
getFib = FibonacciStorage.fib

print getFib(50)

I found this code on the net and tried to comment each line to understand what it is actually doing. I don’t understand how this is a recursion, it does loop through the code until the correct result is given but I don’t see how its calling itself.

I thought it was this line, at first: result = FibonacciStorage._fib(number-1) + FibonacciStorage._fib(number-2) but I’m confused because my print FibonacciStorage._storage line shows the storage cache growing and growing, yet the line below it is a return function. I suspect I do not understand how return result is actually somehow triggering the recursion again.

I’m also not sure how the storage dictionary is making this program go so fast. My simple recursions of the fib sequence take a long time(even when I save the data) but in this case if you do a print getFib(200) its instant. How is the caching making it so fast?

So to sum up, two questions:

1) How is the recursion actually being triggered? If my print statement is being accessed on each loop?

2) How is caching speeding this up over other fib sequences? Is the class structure or @staticmethod making a difference? For example, this seems instant while the ones on http://en.literateprograms.org/Fibonacci_numbers_(Python) have a slight delay.

3) Maybe also out of intrest, can a fibnocci type algo scale(split up and run in parallel) just out of intrest or are they limited to one process?

Any insight would be helpful.

Answer 1

(1) The recursive call is on this line:

result = FibonacciStorage._fib(number-1) + FibonacciStorage._fib(number-2)
//                   here ^                        and here ^

You’re right, this is “the actual Fibonacci formula”, which is recursive by definition.

(2) Caching is speeding it up immensely. What’s making a difference is the persistent object _storage, which is saving you a spectacular amount of duplicate work. Consider:

                                 fib(4)
                               /        \
                          fib(3)   +     fib(2)
                         /    \          /     \
                    fib(2) + fib(1)   fib(1) + fib(0)
                    /    \
               fib(1) + fib(0)

This is just fib(4), and you can already see the redundancy. By simply caching the integer values of fib(3) and fib(4), you’ll reduce the number of calculations required for fib(5) from 7 to 1. And the savings only grow as you go higher.