High Fibonacci numbers

Question

When I investigate Fibonacci's series

fib[n_] := fib[n] = fib[n - 1] + fib[n - 2]
fib[0] = fib[1] = 1;
Block[{$RecursionLimit = 10^4}, fib[10^3]]

I can evaluate it for n=10^3. However, if I do the following

fib[n_] := fib[n] = fib[n - 1] + fib[n - 2]
fib[0] = fib[1] = 1;
Block[{$RecursionLimit = 5*10^4}, fib[10^4]]

I get a beep, the kernel quits and the message "The kernel Local has quit (exited) during the course of an evaluation" shows up.

Is this error beep due to memory restrictions (since I memorize too many values)? However, I don't see anything in the Linux' top overview.

Answer 1

The kernel crashes due to stack overflow. It is not safe to recurse too deeply. Increasing $RecursionLimit to values that are too great (and actually recursing that deep) risks a crash.

(So yes, in a way it's due to insufficient memory, but it has nothing to do with memoization. It is due to insufficient stack space.)

From the documentation:

On most computers, each level of recursion uses a certain amount of stack space. $RecursionLimit allows you to control the amount of stack space that the Wolfram Language can use from within the Wolfram Language. On some computer systems, your whole Wolfram Language session may crash if you allow it to use more stack space than the computer system allows.

What you can do in the most general case using memoization is to invoke the functions with gradually increasing parameter values, allowing it to memoize the results. This will limit the depth of the recursion compared to the situation when you pass the highest parameter immediately.

Block[{$RecursionLimit = Infinity}, Table[fib[ 10^3 k], {k, 1, 10}]]

What you should try to do is transform the recursion into iteration. This also avoids the exponential complexity of fib without requiring memoization.

Nest[{Last[#], First[#] + Last[#]} &, {1, 1}, 10^5]

Of course, there are explicit formulas for Fibonacci numbers (though they're not necessarily easy to compute accurately) and Mathematica also has Fibonacci.

Answer 2

Even assuming that you were not aware of Fibonacci, you should generally investigate simple recursions using RSolve.

Clear[fib]

fib[n_] = fib[n] /. 
  RSolve[{fib[n] == fib[n - 1] + fib[n - 2], fib[0] == 1, fib[1] == 1}, 
    fib[n], n][[1]]

(* 1/2 (Fibonacci[n] + LucasL[n]) *)

fib[10^4] // N

(* 5.443837311356528*10^2089 *)

With this approach fib is also defined for non-integer and negative arguments.

fib /@ {-7, -3.5, 0, 3.5, 7}

(* {13, 0.0829962, 0, 2.40975, 13} *)

Note also that your initial value fib[0] == 1 is not consistent with the standard definition of Fibonacci

Fibonacci[0]

(* 0 *)

Using a revised initial value fib[0] == 0

Clear[fib]

fib[n_] = fib[n] /. 
  RSolve[{fib[n] == fib[n - 1] + fib[n - 2], fib[0] == 0, fib[1] == 1}, 
    fib[n], n][[1]]

(* Fibonacci[n] *)

% // FunctionExpand

(* ((1/2 (1 + Sqrt[5]))^n - (2/(1 + Sqrt[5]))^n Cos[n π])/Sqrt[5] *)

Answer 3

There are different ways of doing recursion. f[n] = f[n-1] + f[n-2] which needs to evaluate f[n-1] until it gets a value. You can see this as an ever expanding tree of recursion just to determine the value.

With tail recursion, its a function that calls itself, but the recursion is the last statement. So you would be passing the previous two numbers in your method call, along with which fibonacci number you want.

So example: fib(0, 1, 5) where 0 is fn-1, 1 is fn, and 5 is fib number 5 we want call stack would look like this fib(0,1,5) fib(1,1,4) fib(1,2,3) fib(2,3,2) fib(3,5,1) fib(5,8,0) And then it would return 8 (I might be off by one, but hopefully this is helps)

Google Tail recursion, that will help with your memory issues

Answer 4

A general answer from the computer science perspective:

Stack depth limits are common and exist for virtually all programming environments. As Nicolas pointed out, tail recursion is a technique for recursion which does not take up any stack space because the context of the current call (i.e. the variables in that function call's scope) are not needed for any future computations. While recursively defined functions are elegant and concise, it is sometimes necessary to write such functions iteratively to avoid stack depth limits. In theory, all recursive functions can be written iteratively.

As a desirable side effect, iterative implementations are often faster than their recursive counterparts because they cut out the overhead of making a function call and make the best use of CPU cache.