⚡️ Speed up function gcd_recursive by 54%

[codeflash-ai]

📄 54% (0.54x) speedup for gcd_recursive in src/math/computation.py

⏱️ Runtime : 1.17 milliseconds → 758 microseconds (best of 302 runs)

📝 Explanation and details

The optimization replaces recursion with iteration to eliminate function call overhead. The original recursive implementation makes ~27,165 recursive function calls (as shown in the line profiler), each requiring stack frame creation, parameter passing, and return value handling. The iterative version uses a simple while loop with tuple assignment to achieve the same mathematical result.

Key changes:

• Replaced recursive calls with while b: loop
• Used tuple assignment a, b = b, a % b for the Euclidean algorithm steps
• Eliminated ~27k function call overhead operations

Why it's faster:

• Function calls in Python are expensive due to stack frame management and parameter validation
• The iterative approach reduces the profiled execution time from 13.76ms to 4.69ms (65% reduction)
• Loop operations are much faster than recursive calls in Python's interpreter

Performance characteristics:
The optimization shows consistent 10-60% speedups across test cases, with the largest gains on cases requiring more iterations (like large coprime numbers showing 50-60% improvement). Simple cases with immediate termination (like gcd(5, 0)) show minimal improvement since they avoid most recursive overhead anyway. The optimization is particularly effective for the large-scale tests, showing 23-66% improvements on bulk operations.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

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

# unit tests

# ----------- Basic Test Cases -----------

def test_gcd_basic_coprime():
    # Coprime numbers: GCD should be 1
    codeflash_output = gcd_recursive(7, 13) # 417ns -> 334ns (24.9% faster)
    codeflash_output = gcd_recursive(17, 29) # 375ns -> 250ns (50.0% faster)

def test_gcd_basic_common_divisor():
    # Numbers with common divisors
    codeflash_output = gcd_recursive(12, 18) # 333ns -> 291ns (14.4% faster)
    codeflash_output = gcd_recursive(100, 80) # 167ns -> 166ns (0.602% faster)
    codeflash_output = gcd_recursive(54, 24) # 166ns -> 125ns (32.8% faster)

def test_gcd_basic_equal_numbers():
    # GCD of a number with itself is the number
    codeflash_output = gcd_recursive(15, 15) # 250ns -> 208ns (20.2% faster)
    codeflash_output = gcd_recursive(0, 0) # 125ns -> 125ns (0.000% faster)

def test_gcd_basic_one_zero():
    # GCD of any number and 0 is the absolute value of the number
    codeflash_output = gcd_recursive(0, 5) # 292ns -> 250ns (16.8% faster)
    codeflash_output = gcd_recursive(5, 0) # 125ns -> 125ns (0.000% faster)
    codeflash_output = gcd_recursive(-7, 0) # 125ns -> 125ns (0.000% faster)
    codeflash_output = gcd_recursive(0, -8) # 208ns -> 166ns (25.3% faster)

def test_gcd_basic_one_as_argument():
    # GCD of any number and 1 is 1
    codeflash_output = gcd_recursive(1, 999) # 458ns -> 334ns (37.1% faster)
    codeflash_output = gcd_recursive(999, 1) # 167ns -> 166ns (0.602% faster)
    codeflash_output = gcd_recursive(-1, 999) # 292ns -> 292ns (0.000% faster)
    codeflash_output = gcd_recursive(999, -1) # 125ns -> 125ns (0.000% faster)

# ----------- Edge Test Cases -----------

def test_gcd_negative_numbers():
    # GCD should always be non-negative, even if inputs are negative
    codeflash_output = gcd_recursive(-12, -18) # 458ns -> 416ns (10.1% faster)
    codeflash_output = gcd_recursive(-100, 80) # 292ns -> 250ns (16.8% faster)
    codeflash_output = gcd_recursive(54, -24) # 333ns -> 250ns (33.2% faster)

def test_gcd_zero_and_zero():
    # GCD(0, 0) is mathematically undefined, but most implementations return 0
    codeflash_output = gcd_recursive(0, 0) # 166ns -> 166ns (0.000% faster)

def test_gcd_large_prime_and_small():
    # Large prime and small number
    codeflash_output = gcd_recursive(982451653, 2) # 375ns -> 292ns (28.4% faster)

def test_gcd_negative_and_zero():
    # GCD of negative and zero
    codeflash_output = gcd_recursive(-25, 0) # 166ns -> 166ns (0.000% faster)
    codeflash_output = gcd_recursive(0, -25) # 291ns -> 208ns (39.9% faster)

def test_gcd_one_negative_one_positive():
    # GCD of one negative and one positive number
    codeflash_output = gcd_recursive(-27, 9) # 291ns -> 250ns (16.4% faster)
    codeflash_output = gcd_recursive(27, -9) # 208ns -> 208ns (0.000% faster)

def test_gcd_both_negative():
    # Both arguments negative
    codeflash_output = gcd_recursive(-48, -18) # 458ns -> 375ns (22.1% faster)

def test_gcd_large_and_small():
    # Large and small numbers
    codeflash_output = gcd_recursive(10**12, 10**6) # 292ns -> 250ns (16.8% faster)

def test_gcd_zero_and_large():
    # Zero and large number
    codeflash_output = gcd_recursive(0, 10**9) # 292ns -> 250ns (16.8% faster)
    codeflash_output = gcd_recursive(10**9, 0) # 125ns -> 125ns (0.000% faster)

# ----------- Large Scale Test Cases -----------

def test_gcd_large_numbers():
    # Very large numbers, should not crash or overflow
    a = 123456789012345678901234567890
    b = 987654321098765432109876543210
    # GCD should be 900000000090
    codeflash_output = gcd_recursive(a, b) # 708ns -> 625ns (13.3% faster)

def test_gcd_large_numbers_prime():
    # Large prime numbers, GCD should be 1
    a = 15485863  # 1 millionth prime
    b = 32452843  # 2 millionth prime
    codeflash_output = gcd_recursive(a, b) # 958ns -> 750ns (27.7% faster)

def test_gcd_large_numbers_common_factor():
    # Large numbers with a large common factor
    a = 12345678901234567890
    b = 98765432109876543210
    # Both divisible by 10
    codeflash_output = gcd_recursive(a, b) # 583ns -> 542ns (7.56% faster)

def test_gcd_large_scale_loop():
    # Test GCD for a sequence of numbers, all multiples of 7
    for i in range(1, 1000):
        codeflash_output = gcd_recursive(7 * i, 7 * (i + 1)) # 161μs -> 121μs (33.0% faster)

def test_gcd_large_scale_varied():
    # Test GCD for many pairs (scalability)
    for i in range(1, 1000):
        a = i * 123456
        b = i * 789012
        expected = i * gcd_recursive(123456, 789012) # 483μs -> 291μs (66.1% faster)
        codeflash_output = gcd_recursive(a, b)

# ----------- Additional Robustness Checks -----------

def test_gcd_argument_order():
    # GCD should be commutative: gcd(a, b) == gcd(b, a)
    for a, b in [(18, 12), (0, 5), (100, 80), (54, 24), (7, 13), (0, 0)]:
        codeflash_output = gcd_recursive(a, b) # 1.08μs -> 1.04μs (4.23% faster)


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

# unit tests

# 1. Basic Test Cases

def test_gcd_basic_coprime():
    # Coprime numbers (no common divisors except 1)
    codeflash_output = gcd_recursive(7, 13) # 417ns -> 334ns (24.9% faster)
    codeflash_output = gcd_recursive(17, 31) # 333ns -> 250ns (33.2% faster)

def test_gcd_basic_non_coprime():
    # Non-coprime numbers (common divisors)
    codeflash_output = gcd_recursive(12, 18) # 333ns -> 292ns (14.0% faster)
    codeflash_output = gcd_recursive(100, 80) # 166ns -> 125ns (32.8% faster)
    codeflash_output = gcd_recursive(81, 27) # 125ns -> 125ns (0.000% faster)

def test_gcd_basic_same_numbers():
    # GCD of a number with itself is the number
    codeflash_output = gcd_recursive(5, 5) # 250ns -> 208ns (20.2% faster)
    codeflash_output = gcd_recursive(123456, 123456) # 208ns -> 208ns (0.000% faster)

def test_gcd_basic_one_is_zero():
    # GCD of (a, 0) is abs(a), and vice versa
    codeflash_output = gcd_recursive(0, 7) # 291ns -> 250ns (16.4% faster)
    codeflash_output = gcd_recursive(15, 0) # 125ns -> 125ns (0.000% faster)
    codeflash_output = gcd_recursive(0, 0) # 83ns -> 83ns (0.000% faster)

def test_gcd_basic_one_is_one():
    # GCD with 1 is always 1 (except both zero)
    codeflash_output = gcd_recursive(1, 999) # 417ns -> 375ns (11.2% faster)
    codeflash_output = gcd_recursive(999, 1) # 167ns -> 167ns (0.000% faster)

# 2. Edge Test Cases

def test_gcd_negative_inputs():
    # GCD should work with negative numbers, returning positive GCD
    codeflash_output = gcd_recursive(-12, 18) # 334ns -> 333ns (0.300% faster)
    codeflash_output = gcd_recursive(12, -18) # 333ns -> 291ns (14.4% faster)
    codeflash_output = gcd_recursive(-12, -18) # 291ns -> 250ns (16.4% faster)
    codeflash_output = gcd_recursive(-7, 0) # 83ns -> 83ns (0.000% faster)
    codeflash_output = gcd_recursive(0, -8) # 166ns -> 125ns (32.8% faster)

def test_gcd_zero_and_zero():
    # Edge case: both numbers are zero, should return zero
    codeflash_output = gcd_recursive(0, 0) # 166ns -> 166ns (0.000% faster)

def test_gcd_one_negative_one():
    # Edge case: one and negative one
    codeflash_output = gcd_recursive(1, -1) # 333ns -> 291ns (14.4% faster)
    codeflash_output = gcd_recursive(-1, 1) # 125ns -> 125ns (0.000% faster)
    codeflash_output = gcd_recursive(-1, -1) # 125ns -> 83ns (50.6% faster)

def test_gcd_large_prime_and_one():
    # Edge case: large prime and 1
    codeflash_output = gcd_recursive(982451653, 1) # 333ns -> 250ns (33.2% faster)
    codeflash_output = gcd_recursive(1, 982451653) # 291ns -> 250ns (16.4% faster)

def test_gcd_large_prime_and_zero():
    # Edge case: large prime and 0
    codeflash_output = gcd_recursive(982451653, 0) # 167ns -> 167ns (0.000% faster)
    codeflash_output = gcd_recursive(0, 982451653) # 291ns -> 208ns (39.9% faster)

def test_gcd_a_divides_b():
    # Edge case: a divides b exactly
    codeflash_output = gcd_recursive(12, 36) # 375ns -> 292ns (28.4% faster)
    codeflash_output = gcd_recursive(36, 12) # 166ns -> 125ns (32.8% faster)

def test_gcd_both_even():
    # Edge case: both numbers are even
    codeflash_output = gcd_recursive(48, 64) # 375ns -> 333ns (12.6% faster)

def test_gcd_both_odd():
    # Edge case: both numbers are odd
    codeflash_output = gcd_recursive(21, 35) # 375ns -> 333ns (12.6% faster)

def test_gcd_large_difference():
    # Edge case: large difference between a and b
    codeflash_output = gcd_recursive(1000000, 3) # 334ns -> 292ns (14.4% faster)
    codeflash_output = gcd_recursive(3, 1000000) # 333ns -> 208ns (60.1% faster)

# 3. Large Scale Test Cases

def test_gcd_large_numbers():
    # Large numbers, but not exceeding recursion limit
    codeflash_output = gcd_recursive(123456789012345, 9876543210) # 1.54μs -> 1.12μs (37.0% faster)
    codeflash_output = gcd_recursive(10**12, 10**10) # 292ns -> 250ns (16.8% faster)

def test_gcd_large_coprime():
    # Large coprime numbers
    codeflash_output = gcd_recursive(999999937, 999999929) # 458ns -> 375ns (22.1% faster)

def test_gcd_large_composite():
    # Large composite numbers with a common divisor
    codeflash_output = gcd_recursive(1234567890 * 17, 9876543210 * 17) # 625ns -> 459ns (36.2% faster)

def test_gcd_large_power_of_two():
    # Large powers of two
    codeflash_output = gcd_recursive(2**100, 2**80) # 458ns -> 375ns (22.1% faster)

def test_gcd_large_power_of_two_and_one():
    # Large power of two and 1
    codeflash_output = gcd_recursive(2**100, 1) # 333ns -> 291ns (14.4% faster)

def test_gcd_large_numbers_one_zero():
    # Large number and zero
    codeflash_output = gcd_recursive(10**18, 0) # 167ns -> 166ns (0.602% faster)
    codeflash_output = gcd_recursive(0, 10**18) # 333ns -> 208ns (60.1% faster)

def test_gcd_large_numbers_negative():
    # Large negative numbers
    codeflash_output = gcd_recursive(-10**12, 10**10) # 416ns -> 333ns (24.9% faster)
    codeflash_output = gcd_recursive(10**12, -10**10) # 208ns -> 209ns (0.478% slower)
    codeflash_output = gcd_recursive(-10**12, -10**10) # 208ns -> 167ns (24.6% faster)

# 4. Parameterized Tests for Scalability

@pytest.mark.parametrize("a,b,expected", [
    (2**500, 2**400, 2**400),  # very large powers of two
    (10**300 + 1, 10**300, 1), # large coprime numbers
    (999999937 * 1234567, 999999937 * 7654321, 999999937), # large common factor
    (1234567890123456789, 9876543210987654321, 9), # large numbers with small GCD
])
def test_gcd_parameterized_large_scale(a, b, expected):
    # Parameterized large scale tests
    codeflash_output = gcd_recursive(a, b) # 3.25μs -> 2.62μs (23.8% faster)

# 5. Regression/Mutation Protection

def test_gcd_mutation_protection():
    # If the recursive call is reversed, the output will be wrong for asymmetric inputs
    codeflash_output = gcd_recursive(100, 25) # 292ns -> 291ns (0.344% faster)
    codeflash_output = gcd_recursive(25, 100) # 209ns -> 250ns (16.4% slower)
    codeflash_output = gcd_recursive(101, 10) # 167ns -> 125ns (33.6% faster)
    # If abs is omitted in base case, negative inputs would fail
    codeflash_output = gcd_recursive(-101, 10) # 250ns -> 208ns (20.2% faster)
    codeflash_output = gcd_recursive(101, -10) # 333ns -> 291ns (14.4% faster)
    codeflash_output = gcd_recursive(-101, -10) # 167ns -> 166ns (0.602% faster)
# 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(272, -169)

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_0fmmmqp5/tmpasqq6_nv/test_concolic_coverage.py::test_gcd_recursive	792ns	667ns	18.7%✅

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