How do I implement Tail recursion with my Fibonacci method?

Question

I\'m trying to compute large numbers of the Fibonacci sequence, hence why I am using big integer. I can get up to about 10000 the way it is, but I run out of stack space. I real

Answer 1

A simple recursion to achieve the series you want could be :

public class FibRecursion{

    private static BigInteger[] fval;

    public static void main(String[] args) {

        int index = 10;
        fval = new BigInteger[index];
        fib(0,1,0,index);
        System.out.println(Arrays.toString(fval));
    }

    public static void fib(long a, long b, int index, int endIndex ) {

        if (index >= endIndex) {

            return ;
        }

        fval[index] = BigInteger.valueOf(a).add(BigInteger.valueOf(b));
        index++;
        fib(b, a+b, index , endIndex);
    }
}

To avoid stack limitations, you can limit the recursion depth and do the resurrection in a few "pieces". Here is an example of a series of 50 elements, calculated with depth limited to 10 (RECURRSION_DEPTH = 10):

public class FibRecursion{

    private static BigInteger[] fval;
    //limit of the recursion depth. valid values are >=2
    private final static int RECURRSION_DEPTH = 10;

    public static void main(String[] args) {

        int index = 50;
        fval = new BigInteger[index];

        BigInteger aValue = BigInteger.valueOf(0);
        BigInteger bValue = BigInteger.valueOf(1);
        int startIndex = 0;
        int endIndex = RECURRSION_DEPTH;

        while (endIndex > startIndex) {

            fib(aValue,bValue,startIndex,endIndex);

            aValue = fval[endIndex-2];
            bValue = fval[endIndex-1];
            startIndex = endIndex;
            endIndex = Math.min(endIndex + RECURRSION_DEPTH, index);
        }

        System.out.println(Arrays.toString(fval));
    }

    //use BigInteger to avoid integer max value limitation 
    public static void fib(BigInteger a, BigInteger b, int index, int endIndex ) {

        if (index >= endIndex) {

            return ;
        }

        fval[index] = a.add(b);
        index++;
        fib(b, a.add(b), index , endIndex);
    }
}

This of course has other limitations, not related to stack size.