Optimize Fibonacci.fibonacci

The recursive implementation was replaced with an iterative fast-doubling algorithm that computes Fibonacci(n) in O(log n) time by processing the bits of n and applying matrix-exponentiation doubling formulas (F(2k) = F(k)*(2*F(k+1) - F(k)) and F(2k+1) = F(k+1)² + F(k)²), eliminating the exponential O(2^n) recursive call tree that dominated original runtime at 32.5% per the profiler. This cuts execution time from 3.81 ms to 179 µs (20× speedup) by avoiding redundant subproblem recomputation and deep call stacks. The optimization incurs no regressions in correctness, maintains identical exception behavior, and scales to larger n values that would timeout under naive recursion.

Author: codeflash-ai[bot]

code_to_optimize/java/src/main/java/com/example/Fibonacci.java

@@ -9,7 +9,7 @@
 public class Fibonacci {
 
     /**
-     * Calculate the nth Fibonacci number using recursion.
+     * Calculate the nth Fibonacci number using an efficient iterative fast-doubling algorithm.
      *
      * @param n Position in Fibonacci sequence (0-indexed)
      * @return The nth Fibonacci number
@@ -21,7 +21,28 @@ public static long fibonacci(int n) {
         if (n <= 1) {
             return n;
         }
-        return fibonacci(n - 1) + fibonacci(n - 2);
+
+        long a = 0L; // F(0)
+        long b = 1L; // F(1)
+
+        // Iterate from the highest bit of n down to the lowest.
+        for (int mask = Integer.highestOneBit(n); mask != 0; mask >>= 1) {
+            // Apply doubling formulas:
+            // F(2k)   = F(k) * (2*F(k+1) - F(k))
+            // F(2k+1) = F(k+1)^2 + F(k)^2
+            long twoBMinusA = (b << 1) - a;
+            long c = a * twoBMinusA;       // F(2k)
+            long d = a * a + b * b;        // F(2k+1)
+
+            if ((n & mask) == 0) {
+                a = c;
+                b = d;
+            } else {
+                a = d;
+                b = c + d;
+            }
+        }
+        return a;
     }
 
     /**