How do I implement Tail recursion with my Fibonacc

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 realize I can increase stack and heap space, but it is my understanding that tail recursion can get around the space issue. Here is my code..

public class FibRecursion{

static BigInteger[] fval;

public static void main(String[] args) {

    int index;

    Scanner input = new Scanner(System.in);

    index = input.nextInt();


    fval = new BigInteger[index + 1];


    System.out.println(fib_rec(index));


}


public static BigInteger fib_rec(int index){


    BigInteger result = BigInteger.ONE;

    if(index <= 2){
        return result;
    }

    else{
        if(fval[index] != null){
            result=fval[index];
        }
        else{
            result = fib_rec(index-1).add(fib_rec(index-2));

            fval[index] = result;

        }
        return result;
    }
}  
}

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.