Added memoization to fibonaaci with recursion. Also added handling of long overrun in all calculations

Author: Justin Wetherell

src/com/jwetherell/algorithms/sequence/FibonacciSequence.java

@@ -12,7 +12,7 @@ public class FibonacciSequence {
     private static final double PHI = (1 + Math.sqrt(5)) / 2; // Golden ratio
 
     public static final long fibonacciSequenceUsingLoop(int n) {
-        long[] array = new long[n + 1];
+        final long[] array = new long[n + 1];
         int counter = 0;
         while (counter <= n) {
             long r = 0;
@@ -21,22 +21,61 @@ public static final long fibonacciSequenceUsingLoop(int n) {
             } else if (counter == 1) {
                 r = 1;
             }
+            // If r goes below zero then we have run out of bits in the long
+            if (r < 0)
+                throw new IllegalArgumentException("Run out of bits in long, n="+n);
             array[counter] = r;
             counter++;
         }
 
         return array[n];
     }
 
+    /**
+     * Recursion with memoization
+     */
     public static final long fibonacciSequenceUsingRecursion(int n) {
-        if (n == 0 || n == 1) return n;
-        return fibonacciSequenceUsingRecursion(n - 1) + fibonacciSequenceUsingRecursion(n - 2);
+        // Using the array to store values already computed
+        final long[] array = new long[n + 1];
+        return fibonacciSequenceUsingRecursion(array,n);
+    }
+
+    private static final long fibonacciSequenceUsingRecursion(long[] array, int n) {
+        if (n == 0 || n == 1) 
+            return n;
+
+        // If array already has a value then it has previously been computed
+        if (array[n] != 0)
+            return array[n];
+
+        final String exception = "Run out of bits in long, n="+n;
+
+        final long r1 = fibonacciSequenceUsingRecursion(array, (n - 1));
+        array[n-1] = r1; // memoization
+        // If r1 goes below zero then we have run out of bits in the long
+        if (r1 < 0)
+            throw new IllegalArgumentException(exception);
+
+        final long r2 = fibonacciSequenceUsingRecursion(array, (n - 2));
+        array[n-2] = r2; // memoization
+        // If r2 goes below zero then we have run out of bits in the long
+        if (r2 < 0)
+            throw new IllegalArgumentException(exception);
+
+        final long r = r1 + r2;
+        // If r goes below zero then we have run out of bits in the long
+        if (r < 0)
+            throw new IllegalArgumentException("Run out of bits in long, n="+n);
+
+        array[n] = r; // memoization
+
+        return r;
     }
 
     public static final long fibonacciSequenceUsingMatrixMultiplication(int n) {
         // m = [ 1 , 1 ]
-        // [ 1 , 0 ]
-        long[][] matrix = new long[2][2];
+        //     [ 1 , 0 ]
+        final long[][] matrix = new long[2][2];
         matrix[0][0] = 1;
         matrix[0][1] = 1;
         matrix[1][0] = 1;
@@ -52,23 +91,26 @@ public static final long fibonacciSequenceUsingMatrixMultiplication(int n) {
         while (counter > 0) {
             temp = multiplyMatrices(matrix, temp);
             // Subtract an additional 1 the first time in the loop because the
-            // first multiplication is
-            // actually n -= 2 since it multiplying two matrices
+            // first multiplication is actually n -= 2 since it multiplying two matrices
             counter -= (counter == n) ? 2 : 1;
         }
-        return temp[0][1];
+        final long r = temp[0][1];
+        // If r goes below zero then we have run out of bits in the long
+        if (r < 0)
+            throw new IllegalArgumentException("Run out of bits in long, n="+n);
+        return r;
     }
 
     private static final long[][] multiplyMatrices(long[][] A, long[][] B) {
-        long a = A[0][0];
-        long b = A[0][1];
-        long c = A[1][0];
-        long d = A[1][1];
+        final long a = A[0][0];
+        final long b = A[0][1];
+        final long c = A[1][0];
+        final long d = A[1][1];
 
-        long e = B[0][0];
-        long f = B[0][1];
-        long g = B[1][0];
-        long h = B[1][1];
+        final long e = B[0][0];
+        final long f = B[0][1];
+        final long g = B[1][0];
+        final long h = B[1][1];
 
         B[0][0] = a * e + b * g;
         B[0][1] = a * f + b * h;
@@ -79,6 +121,10 @@ private static final long[][] multiplyMatrices(long[][] A, long[][] B) {
     }
 
     public static final long fibonacciSequenceUsingBinetsFormula(int n) {
-        return (long) Math.floor(Math.pow(PHI, n) * INVERSE_SQUARE_ROOT_OF_5 + 0.5);
+        final long r = (long) Math.floor(Math.pow(PHI, n) * INVERSE_SQUARE_ROOT_OF_5 + 0.5);
+        // If r hits max value then we have run out of bits in the long
+        if (r == Long.MAX_VALUE)
+            throw new IllegalArgumentException("Run out of bits in long, n="+n);
+        return r;
     }
 }

src/com/jwetherell/algorithms/sequence/test/Sequences.java

@@ -44,6 +44,34 @@ public void testFibonacci() {
         assertTrue("Fibonacci Sequence Using Binet's formula error. result="+result+" check="+check, (result==check));
     }
 
+    @Test(expected=IllegalArgumentException.class)
+    public void testFibonacciLoopExceptions() {
+        // COMPUTE FIBONACCI SEQUENCE
+        int element = 93;
+        FibonacciSequence.fibonacciSequenceUsingLoop(element);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testFibonacciRecursionExceptions() {
+        // COMPUTE FIBONACCI SEQUENCE
+        int element = 93;
+        FibonacciSequence.fibonacciSequenceUsingRecursion(element);
+   }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testFibonacciMatrixExceptions() {
+        // COMPUTE FIBONACCI SEQUENCE
+        int element = 93;
+        FibonacciSequence.fibonacciSequenceUsingMatrixMultiplication(element);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testFibonacciBinetsExceptions() {
+        // COMPUTE FIBONACCI SEQUENCE
+        int element = 93;
+        FibonacciSequence.fibonacciSequenceUsingBinetsFormula(element);
+    }
+
     @Test
     public void testLongestCommonSubSequences() {
         // LONGEST COMMON SUBSEQUENCE