⚡️ Speed up function fibonacci by 1,408%

[codeflash-ai]

📄 1,408% (14.08x) speedup for fibonacci in code_to_optimize_js/fibonacci.js

⏱️ Runtime : 220 microseconds → 14.6 microseconds (best of 250 runs)

📝 Explanation and details

The optimized code achieves a 1408% speedup (220μs → 14.6μs) by replacing the exponential-time recursive algorithm with two specialized paths:

Key Optimizations

1. Iterative Fast Path for Integers (O(n) vs O(2^n))
The original naive recursion has exponential time complexity because it recomputes the same Fibonacci values repeatedly. For example, fibonacci(5) calls fibonacci(3) twice, fibonacci(2) three times, etc.

The optimized version detects non-negative integers (the common case) and uses an iterative loop that computes each Fibonacci number exactly once, storing only the last two values. This transforms O(2^n) time complexity into O(n) with O(1) memory.

2. Memoized Recursion Fallback
For non-integer inputs or edge cases, the code uses a shared cache (fibonacci._cache) to store previously computed results. This ensures that even if recursion is needed, each unique input is calculated only once, preventing exponential blowup.

Why This Works in JavaScript

• Integer detection (Number.isInteger(n) && n >= 2) efficiently routes the common case to the fast path
• Function property caching (fibonacci._cache) persists across calls without polluting global scope
• Map-based memoization provides O(1) lookup for cached values
• The iterative loop avoids function call overhead entirely for integers

Test Case Performance

The optimization particularly benefits:

• Large integers (fibonacci(20-25)): Tests that would time out with naive recursion now complete instantly
• Repeated calls: The memoization cache makes subsequent calls with the same input nearly free
• Sequential calculations: Tests computing fibonacci(15-20) in sequence benefit from both the fast path and any cached values

The base cases (n ≤ 1) maintain identical behavior, and the memoization fallback preserves correctness for any unusual inputs while still providing significant speedup over pure recursion.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 51 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

🌀 Click to see Generated Regression Tests

const { fibonacci } = require('../fibonacci');

describe('fibonacci', () => {
    // Basic Test Cases
    describe('Basic functionality', () => {
        test('should return 0 for n = 0', () => {
            expect(fibonacci(0)).toBe(0);
        });

        test('should return 1 for n = 1', () => {
            expect(fibonacci(1)).toBe(1);
        });

        test('should return 1 for n = 2 (first two elements sum)', () => {
            expect(fibonacci(2)).toBe(1);
        });

        test('should return 2 for n = 3', () => {
            expect(fibonacci(3)).toBe(2);
        });

        test('should return 3 for n = 4', () => {
            expect(fibonacci(4)).toBe(3);
        });

        test('should return 5 for n = 5', () => {
            expect(fibonacci(5)).toBe(5);
        });

        test('should return 8 for n = 6', () => {
            expect(fibonacci(6)).toBe(8);
        });

        test('should return 13 for n = 7', () => {
            expect(fibonacci(7)).toBe(13);
        });

        test('should return 21 for n = 8', () => {
            expect(fibonacci(8)).toBe(21);
        });

        test('should return 55 for n = 10', () => {
            expect(fibonacci(10)).toBe(55);
        });

        test('should return 89 for n = 11', () => {
            expect(fibonacci(11)).toBe(89);
        });
    });

    // Edge Test Cases
    describe('Edge cases', () => {
        test('should handle negative numbers by returning the input', () => {
            // Based on the function logic, n <= 1 returns n
            expect(fibonacci(-1)).toBe(-1);
        });

        test('should handle negative large numbers', () => {
            expect(fibonacci(-10)).toBe(-10);
        });

        test('should return exactly n when n equals 0', () => {
            expect(fibonacci(0)).toStrictEqual(0);
        });

        test('should return exactly n when n equals 1', () => {
            expect(fibonacci(1)).toStrictEqual(1);
        });

        test('should handle boundary between base case and recursion', () => {
            // n = 2 is the first value requiring recursion
            expect(fibonacci(2)).toBe(fibonacci(1) + fibonacci(0));
        });

        test('should consistently return same value for same input', () => {
            const result1 = fibonacci(7);
            const result2 = fibonacci(7);
            expect(result1).toBe(result2);
        });

        test('should handle consecutive fibonacci numbers correctly', () => {
            const fib9 = fibonacci(9);
            const fib8 = fibonacci(8);
            const fib7 = fibonacci(7);
            // fib(9) should equal fib(8) + fib(7)
            expect(fib9).toBe(fib8 + fib7);
        });
    });

    // Large Scale Test Cases
    describe('Performance tests', () => {
        test('should calculate fibonacci(20) without timeout', () => {
            const result = fibonacci(20);
            expect(result).toBe(6765);
        });

        test('should calculate fibonacci(25) within reasonable time', () => {
            const startTime = Date.now();
            const result = fibonacci(25);
            const endTime = Date.now();
            
            expect(result).toBe(75025);
            // Should complete within 5 seconds even with naive recursion
            expect(endTime - startTime).toBeLessThan(5000);
        });

        test('should return correct value for fibonacci(22)', () => {
            expect(fibonacci(22)).toBe(17711);
        });

        test('should return correct value for fibonacci(23)', () => {
            expect(fibonacci(23)).toBe(28657);
        });

        test('should return correct value for fibonacci(24)', () => {
            expect(fibonacci(24)).toBe(46368);
        });

        test('should maintain correctness for sequence from 15 to 20', () => {
            const expectedSequence = [610, 987, 1597, 2584, 4181, 6765];
            const actualSequence = [];
            
            for (let i = 15; i <= 20; i++) {
                actualSequence.push(fibonacci(i));
            }
            
            expect(actualSequence).toEqual(expectedSequence);
        });

        test('should handle rapid consecutive calls', () => {
            const results = [];
            for (let i = 0; i <= 15; i++) {
                results.push(fibonacci(i));
            }
            
            // Verify sequence integrity
            for (let i = 2; i < results.length; i++) {
                expect(results[i]).toBe(results[i - 1] + results[i - 2]);
            }
        });

        test('should produce increasing values for increasing input', () => {
            const fib10 = fibonacci(10);
            const fib15 = fibonacci(15);
            const fib20 = fibonacci(20);
            
            expect(fib10).toBeLessThan(fib15);
            expect(fib15).toBeLessThan(fib20);
        });
    });
});

To edit these changes git checkout codeflash/optimize-fibonacci-mkhj6jww and push.