⚡️ Speed up function gcd_recursive by 17%

[codeflash-ai]

📄 17% (0.17x) speedup for gcd_recursive in src/math/computation.py

⏱️ Runtime : 14.9 microseconds → 12.7 microseconds (best of 1417 runs)

📝 Explanation and details

Here is an optimized version of your program. Recursive function calls incur overhead and are generally slower than their iterative counterparts, especially in Python. By switching to an iterative solution, the program runs significantly faster and also avoids the risk of stack overflows for large inputs.

• The function retains the exact same signature and return values.
• The docstring (comment) is preserved and slightly generalized since it's no longer recursive. If required by you, the word "recursion" can be strictly kept.
• The iterative approach is much faster and more memory-efficient than recursion in Python.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 42 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():
    """Test basic functionality with positive integers."""
    codeflash_output = gcd_recursive(48, 18)  # Common divisor is 6
    codeflash_output = gcd_recursive(101, 10)  # Prime numbers, GCD is 1

def test_edge_cases_zero_values():
    """Test edge cases where one or both inputs are zero."""
    codeflash_output = gcd_recursive(0, 0)  # Both zero, conventionally undefined
    codeflash_output = gcd_recursive(0, 5)  # GCD of zero and positive number
    codeflash_output = gcd_recursive(7, 0)  # GCD of positive number and zero

def test_edge_cases_equal_values():
    """Test edge cases where both numbers are equal."""
    codeflash_output = gcd_recursive(9, 9)  # Both numbers are the same
    codeflash_output = gcd_recursive(100, 100)  # Both numbers are the same

def test_negative_values():
    """Test with negative integers."""
    codeflash_output = gcd_recursive(-48, 18)  # Negative and positive
    codeflash_output = gcd_recursive(48, -18)  # Positive and negative
    codeflash_output = gcd_recursive(-48, -18)  # Both negative

def test_prime_numbers():
    """Test with prime numbers."""
    codeflash_output = gcd_recursive(13, 17)  # Both are primes, GCD is 1
    codeflash_output = gcd_recursive(29, 7)  # Both are primes, GCD is 1

def test_large_scale():
    """Test with large integers for performance."""
    codeflash_output = gcd_recursive(1234567890, 987654321)  # Large numbers
    codeflash_output = gcd_recursive(2**20, 2**15)  # Powers of two

def test_coprime_numbers():
    """Test with coprime numbers."""
    codeflash_output = gcd_recursive(35, 64)  # No common divisors
    codeflash_output = gcd_recursive(14, 15)  # No common divisors

def test_multiples():
    """Test where one number is a multiple of the other."""
    codeflash_output = gcd_recursive(100, 25)  # 100 is a multiple of 25
    codeflash_output = gcd_recursive(81, 27)  # 81 is a multiple of 27

def test_mixed_sign_numbers():
    """Test with mixed positive and negative numbers."""
    codeflash_output = gcd_recursive(-42, 56)  # Mixed signs
    codeflash_output = gcd_recursive(42, -56)  # Mixed signs
# 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_basic_functionality():
    """Test basic functionality with positive integers."""
    codeflash_output = gcd_recursive(48, 18)
    codeflash_output = gcd_recursive(101, 10)

def test_zero_inputs():
    """Test cases where one or both inputs are zero."""
    codeflash_output = gcd_recursive(0, 5)
    codeflash_output = gcd_recursive(7, 0)
    codeflash_output = gcd_recursive(0, 0)

def test_equal_inputs():
    """Test cases where both inputs are equal."""
    codeflash_output = gcd_recursive(12, 12)
    codeflash_output = gcd_recursive(100, 100)

def test_prime_numbers():
    """Test cases with prime numbers."""
    codeflash_output = gcd_recursive(13, 17)
    codeflash_output = gcd_recursive(29, 37)

def test_negative_inputs():
    """Test cases with negative integers."""
    codeflash_output = gcd_recursive(-48, 18)
    codeflash_output = gcd_recursive(48, -18)
    codeflash_output = gcd_recursive(-48, -18)

def test_large_numbers():
    """Test cases with large integers to evaluate performance."""
    codeflash_output = gcd_recursive(1234567890, 987654321)
    codeflash_output = gcd_recursive(99999999999999, 123456789)

def test_coprime_numbers():
    """Test cases with co-prime numbers."""
    codeflash_output = gcd_recursive(14, 15)
    codeflash_output = gcd_recursive(35, 64)

def test_multiples():
    """Test cases where one number is a multiple of the other."""
    codeflash_output = gcd_recursive(21, 7)
    codeflash_output = gcd_recursive(100, 25)

def test_boundary_values():
    """Test boundary values and small numbers."""
    codeflash_output = gcd_recursive(1, 1)
    codeflash_output = gcd_recursive(1, 0)

def test_performance_and_scalability():
    """Test performance and scalability with large datasets."""
    codeflash_output = gcd_recursive(10**18, 10**9)
    # Use large random numbers and ensure the function completes in reasonable time
    codeflash_output = gcd_recursive(987654321012345678, 123456789)
# 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-maa7muy9 and push.