⚡️ Speed up function gcd_recursive by 23%

[codeflash-ai]

📄 23% (0.23x) speedup for gcd_recursive in src/math/computation.py

⏱️ Runtime : 16.7 microseconds → 13.7 microseconds (best of 1273 runs)

📝 Explanation and details

Here is an optimized version of your gcd_recursive function. The major speedup comes from removing recursion, which avoids the Python function call overhead and possible stack overflows for large arguments. Euclid's algorithm is implemented iteratively below.

This function produces identical results to your original recursive version but runs much faster, especially for large inputs, and is no longer limited by Python's recursion depth.

✅ Correctness verification report:

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

🌀 Generated Regression Tests Details

import pytest  # used for our unit tests
from src.math.computation import gcd_recursive

# unit tests

def test_basic_functionality():
    # Simple Positive Integers
    codeflash_output = gcd_recursive(48, 18)
    codeflash_output = gcd_recursive(100, 75)

def test_edge_cases_zero_input():
    # Zero Input
    codeflash_output = gcd_recursive(0, 0)
    codeflash_output = gcd_recursive(0, 5)
    codeflash_output = gcd_recursive(10, 0)

def test_edge_cases_negative_integers():
    # Negative Integers
    codeflash_output = gcd_recursive(-48, 18)
    codeflash_output = gcd_recursive(48, -18)
    codeflash_output = gcd_recursive(-48, -18)

def test_edge_cases_identical_numbers():
    # Identical Numbers
    codeflash_output = gcd_recursive(7, 7)
    codeflash_output = gcd_recursive(-7, -7)

def test_prime_numbers():
    # Co-prime Numbers
    codeflash_output = gcd_recursive(13, 17)
    codeflash_output = gcd_recursive(29, 31)

def test_large_numbers():
    # Large Integers
    codeflash_output = gcd_recursive(123456, 789012)
    codeflash_output = gcd_recursive(987654321, 123456789)

def test_performance_and_scalability():
    # Very Large Numbers
    codeflash_output = gcd_recursive(10**12, 10**15)
    codeflash_output = gcd_recursive(10**18, 10**9)

def test_special_mathematical_properties():
    # Multiples
    codeflash_output = gcd_recursive(100, 25)
    codeflash_output = gcd_recursive(81, 27)

def test_mixed_sign_inputs():
    # Mixed Sign Numbers
    codeflash_output = gcd_recursive(-48, 18)
    codeflash_output = gcd_recursive(48, -18)

def test_edge_cases_small_numbers():
    # Small Integers
    codeflash_output = gcd_recursive(1, 1)
    codeflash_output = gcd_recursive(1, 0)
    codeflash_output = gcd_recursive(0, 1)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import pytest  # used for our unit tests
from src.math.computation import gcd_recursive

# unit tests

def test_positive_integers():
    """Test GCD with positive integers."""
    codeflash_output = gcd_recursive(48, 18)
    codeflash_output = gcd_recursive(56, 98)
    codeflash_output = gcd_recursive(101, 103)

def test_negative_integers():
    """Test GCD with negative integers."""
    codeflash_output = gcd_recursive(-48, 18)
    codeflash_output = gcd_recursive(56, -98)
    codeflash_output = gcd_recursive(-101, -103)

def test_zero_inputs():
    """Test GCD with zero inputs."""
    codeflash_output = gcd_recursive(0, 0)
    codeflash_output = gcd_recursive(0, 18)
    codeflash_output = gcd_recursive(56, 0)

def test_identical_numbers():
    """Test GCD with identical numbers."""
    codeflash_output = gcd_recursive(42, 42)
    codeflash_output = gcd_recursive(-42, -42)

def test_one_as_input():
    """Test GCD with one as an input."""
    codeflash_output = gcd_recursive(1, 999)
    codeflash_output = gcd_recursive(999, 1)

def test_prime_numbers():
    """Test GCD with prime numbers."""
    codeflash_output = gcd_recursive(17, 19)
    codeflash_output = gcd_recursive(13, 26)

def test_large_integers():
    """Test GCD with large integers."""
    codeflash_output = gcd_recursive(1234567890, 9876543210)
    codeflash_output = gcd_recursive(1000000000, 500000000)

def test_performance_check():
    """Test GCD performance with very large numbers."""
    codeflash_output = gcd_recursive(10**18, 10**9)
    codeflash_output = gcd_recursive(10**18 + 1, 10**9 + 1)

def test_negative_and_zero():
    """Test GCD with negative and zero inputs."""
    codeflash_output = gcd_recursive(-48, 0)
    codeflash_output = gcd_recursive(0, -18)

def test_negative_and_positive():
    """Test GCD with negative and positive inputs."""
    codeflash_output = gcd_recursive(-48, 18)
    codeflash_output = gcd_recursive(56, -98)

def test_very_large_scale():
    """Test GCD with very large scale numbers."""
    codeflash_output = gcd_recursive(10**18, 10**17)
    codeflash_output = gcd_recursive(10**18, 10**18 - 1)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from src.math.computation import gcd_recursive

def test_gcd_recursive():
    gcd_recursive(-315, -611)

To edit these changes git checkout codeflash/optimize-gcd_recursive-maa0y3lo and push.