⚡️ Speed up function fibonacci by 33%

[codeflash-ai]

📄 33% (0.33x) speedup for fibonacci in code_to_optimize_js/fibonacci.js

⏱️ Runtime : 22.7 microseconds → 17.0 microseconds (best of 250 runs)

📝 Explanation and details

The optimized code achieves a 33% speedup by replacing the O(n) iterative algorithm with an O(log n) fast-doubling algorithm based on matrix exponentiation properties of Fibonacci numbers.

Key Optimization:

• Original approach: Iterates linearly from 2 to n, computing each Fibonacci number sequentially (O(n) time)

• Optimized approach: Uses the fast-doubling identities:

  • F(2k) = F(k) × (2×F(k+1) - F(k))
  • F(2k+1) = F(k)² + F(k+1)²

  This effectively processes the binary representation of n, doubling the index at each step and conditionally advancing by 1, requiring only O(log n) iterations.

Why It's Faster:
For n=1000, the original code executes ~999 loop iterations, while the optimized version executes only ~10 iterations (log₂(1000) ≈ 10). Each iteration performs a constant number of arithmetic operations, so the logarithmic reduction in iterations directly translates to performance gains.

Behavior Preservation:

• The Math.floor(n) ensures non-integer inputs > 1 are handled identically to the original (which implicitly floors via integer loop bounds)
• The early return for n ≤ 1 maintains the original behavior for edge cases (negatives, fractionals, 0, 1)

Test Results:

• Small inputs (n ≤ 20): Both algorithms are nearly instant; the optimization overhead is negligible
• Large inputs (n = 100-1000): The logarithmic complexity shows clear advantages as demonstrated by the 33% speedup in the benchmark and the consistent sub-100ms performance in the "extremely large input" test
• The Fibonacci identity tests (f(n) = f(n-1) + f(n-2)) pass with high precision, confirming correctness is maintained

Impact:
This optimization is particularly valuable when fibonacci() is called with large values or invoked repeatedly in performance-critical paths. The constant-space usage and deterministic behavior make it a drop-in replacement with no observable side effects beyond improved performance.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

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

// unit tests
describe('fibonacci', () => {
    // Basic Test Cases
    describe('Basic functionality', () => {
        test('should handle normal input', () => {
            // Basic known values for small n (these should be exact and are within JS safe integer range)
            expect(fibonacci(0)).toBe(0);    // base case 0
            expect(fibonacci(1)).toBe(1);    // base case 1
            expect(fibonacci(2)).toBe(1);    // 0,1,1
            expect(fibonacci(3)).toBe(2);    // 0,1,1,2
            expect(fibonacci(4)).toBe(3);
            expect(fibonacci(5)).toBe(5);
            expect(fibonacci(10)).toBe(55);  // commonly known
            expect(fibonacci(20)).toBe(6765); // within safe integer
        });

        test('should be deterministic (pure) for repeated calls', () => {
            // Repeated calls should return the same result (no internal state)
            const first = fibonacci(50);
            const second = fibonacci(50);
            expect(first).toBe(second);
            // also ensure type is number
            expect(typeof first).toBe('number');
        });
    });

    // Edge Test Cases
    describe('Edge cases', () => {
        test('should handle n <= 1 branch correctly (including fractional and negative values)', () => {
            // According to the implementation, any n <= 1 is returned as-is.
            // This catches surprising behavior like fractional inputs in (0,1] and negative numbers.
            expect(fibonacci(1)).toBe(1);        // boundary
            expect(fibonacci(0)).toBe(0);        // boundary
            expect(fibonacci(0.5)).toBe(0.5);    // fractional in (0,1) returned unchanged
            expect(fibonacci(-1)).toBe(-1);      // negative values are returned as-is
            expect(fibonacci(-42)).toBe(-42);    // another negative
            // Very small negative fractional
            expect(fibonacci(-0.1)).toBeCloseTo(-0.1, 12);
        });

        test('should treat non-integer n > 1 as if using floor(n) for the loop bound', () => {
            // The loop uses integer i and checks i <= n, so for n > 1 but non-integer
            // the effect is equivalent to computing fibonacci(Math.floor(n))
            expect(fibonacci(4.9)).toBe(fibonacci(4));
            expect(fibonacci(7.0001)).toBe(fibonacci(7));
            expect(fibonacci(2.9999)).toBe(fibonacci(2)); // 2.999.. -> floor 2
        });

        test('should return a number for various unexpected but valid JS inputs', () => {
            // Guard against throwing for odd but possible inputs (the implementation does not throw)
            expect(typeof fibonacci(NaN)).toBe('number');      // NaN comparisons result in branch-through
            expect(typeof fibonacci(undefined)).toBe('number'); // undefined handled without throwing
            // Note: We do not assert particular values here because behavior is implementation-specific,
            // but we ensure no exceptions are thrown and a number is returned.
        });
    });

    // Large Scale Test Cases
    describe('Performance tests', () => {
        test('should handle large inputs efficiently and obey Fibonacci identity for large n', () => {
            // Choose n = 1000. The implementation will run ~999 loop iterations (within the 1000-iteration guideline).
            // We check:
            // - result is finite
            // - result is positive and larger than significantly smaller indices
            // - Fibonacci identity fib(n) ≈ fib(n-1) + fib(n-2) holds (within floating-point tolerance)
            const n = 1000;
            const f1000 = fibonacci(n);
            const f999 = fibonacci(n - 1);
            const f998 = fibonacci(n - 2);

            // sanity checks
            expect(Number.isFinite(f1000)).toBe(true);
            expect(typeof f1000).toBe('number');
            expect(f1000).toBeGreaterThan(0);

            // Fibonacci identity: fib(n) == fib(n-1) + fib(n-2)
            // Use a relative tolerance because of floating-point rounding at large magnitudes.
            const sum998999 = f999 + f998;
            // If the computed f1000 is zero (shouldn't be), protect division by zero.
            const relDiff = f1000 === 0 ? Math.abs(f1000 - sum998999) : Math.abs(f1000 - sum998999) / Math.abs(f1000);
            expect(relDiff).toBeLessThan(1e-12);

            // Additionally, ensure monotonic growth for a sampled set of increasing large indices.
            const sampleIndices = [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000];
            const values = sampleIndices.map(i => fibonacci(i));
            for (let i = 1; i < values.length; i++) {
                // Each subsequent Fibonacci number in the sample should be >= previous (strictly > in practice)
                expect(values[i]).toBeGreaterThan(values[i - 1]);
            }
        });

        test('should compute several large values without excessive time or memory (sampled)', () => {
            // Compute a handful of large Fibonacci numbers (keeps total work reasonable)
            // This test focuses on not throwing and staying performant for a few large inputs.
            const inputs = [250, 500, 750, 1000];
            const results = inputs.map(i => {
                // Each call performs at most i iterations; the cumulative work is modest.
                return { i, v: fibonacci(i) };
            });

            // Basic assertions: results are finite numbers and strictly increasing with index
            for (let j = 0; j < results.length; j++) {
                expect(Number.isFinite(results[j].v)).toBe(true);
                expect(typeof results[j].v).toBe('number');
                if (j > 0) {
                    expect(results[j].v).toBeGreaterThan(results[j - 1].v);
                }
            }
        });
    });
});

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

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

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

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

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

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

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

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

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

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

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

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

        test('should return 144 for input 12', () => {
            expect(fibonacci(12)).toBe(144);
        });
    });

    // Edge Test Cases
    describe('Edge cases', () => {
        test('should handle negative numbers by returning the input value', () => {
            // The function treats n <= 1 as base case, so negative numbers return themselves
            expect(fibonacci(-1)).toBe(-1);
        });

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

        test('should handle very small positive numbers', () => {
            expect(fibonacci(0)).toBe(0);
            expect(fibonacci(1)).toBe(1);
        });

        test('should maintain sequence integrity for consecutive numbers', () => {
            // Verify that fib(n-1) + fib(n-2) = fib(n) for basic cases
            const fib5 = fibonacci(5);
            const fib6 = fibonacci(6);
            const fib7 = fibonacci(7);
            expect(fib5 + fib6).toBe(fib7);
        });

        test('should handle sequence integrity for mid-range numbers', () => {
            const fib10 = fibonacci(10);
            const fib11 = fibonacci(11);
            const fib12 = fibonacci(12);
            expect(fib10 + fib11).toBe(fib12);
        });

        test('should return correct value for boundary transition (n=1 to n=2)', () => {
            expect(fibonacci(1)).toBe(1);
            expect(fibonacci(2)).toBe(1);
        });
    });

    // Large Scale Test Cases
    describe('Performance tests', () => {
        test('should handle moderately large input (n=50) efficiently', () => {
            const startTime = performance.now();
            const result = fibonacci(50);
            const endTime = performance.now();
            
            // Verify the result is correct (50th fibonacci number)
            expect(result).toBe(12586269025);
            
            // Ensure execution time is reasonable (should be very fast)
            expect(endTime - startTime).toBeLessThan(10);
        });

        test('should handle large input (n=100) efficiently', () => {
            const startTime = performance.now();
            const result = fibonacci(100);
            const endTime = performance.now();
            
            // Verify the result is correct (100th fibonacci number)
            expect(result).toBe(354224848179261915075);
            
            // Ensure execution time is reasonable
            expect(endTime - startTime).toBeLessThan(10);
        });

        test('should handle very large input (n=500) without performance degradation', () => {
            const startTime = performance.now();
            const result = fibonacci(500);
            const endTime = performance.now();
            
            // Verify result is a number
            expect(typeof result).toBe('number');
            expect(result).toBeGreaterThan(0);
            
            // Ensure execution time is reasonable (linear algorithm)
            expect(endTime - startTime).toBeLessThan(50);
        });

        test('should handle extremely large input (n=1000) efficiently', () => {
            const startTime = performance.now();
            const result = fibonacci(1000);
            const endTime = performance.now();
            
            // Verify result is a valid number and positive
            expect(typeof result).toBe('number');
            expect(result).toBeGreaterThan(0);
            
            // Ensure linear time complexity - execution should still be fast
            expect(endTime - startTime).toBeLessThan(100);
        });

        test('should process multiple large fibonacci calls sequentially', () => {
            const values = [50, 100, 150];
            const startTime = performance.now();
            
            const results = values.map(n => fibonacci(n));
            
            const endTime = performance.now();
            
            // Verify all results are positive and in increasing order
            expect(results[0]).toBeLessThan(results[1]);
            expect(results[1]).toBeLessThan(results[2]);
            
            // Ensure total execution time is reasonable
            expect(endTime - startTime).toBeLessThan(50);
        });

        test('should maintain accuracy for large numbers without overflow issues', () => {
            // Test a sequence of large numbers to ensure accuracy
            const result1 = fibonacci(80);
            const result2 = fibonacci(81);
            const result3 = fibonacci(82);
            
            // Verify fibonacci property: F(n-1) + F(n-2) = F(n)
            expect(result1 + result2).toBe(result3);
        });
    });
});

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