⚡️ Speed up function gcd_recursive by 48%

[codeflash-ai]

📄 48% (0.48x) speedup for gcd_recursive in src/math/number_theory.py

⏱️ Runtime : 3.45 milliseconds → 2.33 milliseconds (best of 33 runs)

📝 Explanation and details

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest  # used for our unit tests
from src.math.number_theory 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) # 917ns -> 542ns (69.2% faster)
    codeflash_output = gcd_recursive(17, 29) # 667ns -> 417ns (60.0% faster)

def test_gcd_basic_common_divisor():
    # Numbers with a non-trivial gcd
    codeflash_output = gcd_recursive(12, 8) # 667ns -> 500ns (33.4% faster)
    codeflash_output = gcd_recursive(100, 80) # 292ns -> 208ns (40.4% faster)
    codeflash_output = gcd_recursive(54, 24) # 291ns -> 167ns (74.3% faster)

def test_gcd_basic_identical_numbers():
    # GCD of identical numbers should be the number itself
    codeflash_output = gcd_recursive(15, 15) # 542ns -> 416ns (30.3% faster)
    codeflash_output = gcd_recursive(0, 0) # 209ns -> 166ns (25.9% faster)

def test_gcd_basic_one_zero():
    # GCD with one zero argument; should return the non-zero value
    codeflash_output = gcd_recursive(0, 7) # 625ns -> 458ns (36.5% faster)
    codeflash_output = gcd_recursive(7, 0) # 208ns -> 166ns (25.3% faster)
    codeflash_output = gcd_recursive(0, 0) # 166ns -> 125ns (32.8% faster)

def test_gcd_basic_one_is_one():
    # GCD with one as an argument
    codeflash_output = gcd_recursive(1, 5) # 667ns -> 500ns (33.4% faster)
    codeflash_output = gcd_recursive(5, 1) # 292ns -> 167ns (74.9% faster)
    codeflash_output = gcd_recursive(1, 1) # 250ns -> 125ns (100% faster)

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

def test_gcd_negative_numbers():
    # Negative numbers; GCD should be positive
    codeflash_output = gcd_recursive(-12, 8) # 750ns -> 583ns (28.6% faster)
    codeflash_output = gcd_recursive(12, -8) # 375ns -> 209ns (79.4% faster)
    codeflash_output = gcd_recursive(-12, -8) # 375ns -> 250ns (50.0% faster)
    codeflash_output = gcd_recursive(-7, 0) # 167ns -> 125ns (33.6% faster)
    codeflash_output = gcd_recursive(0, -7) # 334ns -> 167ns (100% faster)

def test_gcd_large_prime_and_one():
    # Large prime and 1; should return 1
    codeflash_output = gcd_recursive(982451653, 1) # 625ns -> 417ns (49.9% faster)
    codeflash_output = gcd_recursive(1, 982451653) # 375ns -> 291ns (28.9% faster)

def test_gcd_one_is_zero():
    # One argument is zero, the other negative
    codeflash_output = gcd_recursive(0, -42) # 708ns -> 459ns (54.2% faster)
    codeflash_output = gcd_recursive(-42, 0) # 250ns -> 208ns (20.2% faster)

def test_gcd_negative_and_positive_coprime():
    # Negative and positive coprime numbers
    codeflash_output = gcd_recursive(-13, 17) # 792ns -> 541ns (46.4% faster)
    codeflash_output = gcd_recursive(13, -17) # 417ns -> 292ns (42.8% faster)

def test_gcd_edge_case_min_int():
    # Edge case: minimum integer value (simulate 32-bit)
    min_int = -2**31
    codeflash_output = gcd_recursive(min_int, 2) # 833ns -> 500ns (66.6% faster)
    codeflash_output = gcd_recursive(2, min_int) # 2.08μs -> 1.29μs (61.2% faster)
    codeflash_output = gcd_recursive(min_int, 0) # 208ns -> 125ns (66.4% faster)

def test_gcd_zero_and_zero():
    # Both arguments zero
    codeflash_output = gcd_recursive(0, 0) # 375ns -> 292ns (28.4% faster)

def test_gcd_one_is_negative_one():
    # One argument is -1
    codeflash_output = gcd_recursive(-1, 7) # 708ns -> 500ns (41.6% faster)
    codeflash_output = gcd_recursive(7, -1) # 208ns -> 167ns (24.6% faster)
    codeflash_output = gcd_recursive(-1, -1) # 208ns -> 125ns (66.4% faster)

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

def test_gcd_large_numbers():
    # Large numbers with a known gcd
    a = 12345678901234567890
    b = 98765432109876543210
    # gcd(a, b) = 900000000090
    codeflash_output = gcd_recursive(a, b) # 1.83μs -> 1.04μs (75.9% faster)

def test_gcd_large_coprime_numbers():
    # Large coprime numbers
    a = 9999999967  # prime
    b = 10000000019  # prime
    codeflash_output = gcd_recursive(a, b) # 1.71μs -> 1.25μs (36.6% faster)

def test_gcd_large_multiple_of_each_other():
    # One is a multiple of the other
    a = 10**18
    b = 10**9
    codeflash_output = gcd_recursive(a, b) # 625ns -> 458ns (36.5% faster)
    codeflash_output = gcd_recursive(b, a) # 541ns -> 292ns (85.3% faster)

def test_gcd_large_and_zero():
    # Large number and zero
    a = 10**18
    codeflash_output = gcd_recursive(a, 0) # 375ns -> 292ns (28.4% faster)
    codeflash_output = gcd_recursive(0, a) # 500ns -> 333ns (50.2% faster)

def test_gcd_large_negative_numbers():
    # Large negative numbers
    a = -10**18
    b = -10**9
    codeflash_output = gcd_recursive(a, b) # 666ns -> 458ns (45.4% faster)

def test_gcd_large_prime_and_large_composite():
    # Large prime and large composite with known gcd
    prime = 982451653
    composite = prime * 123456
    codeflash_output = gcd_recursive(prime, composite) # 708ns -> 583ns (21.4% faster)
    codeflash_output = gcd_recursive(composite, prime) # 292ns -> 167ns (74.9% faster)

# ----------- Property-Based and Miscellaneous -----------

@pytest.mark.parametrize("a,b", [
    (0, 0),
    (0, 999),
    (999, 0),
    (17, 0),
    (0, -17),
    (-17, 0),
])
def test_gcd_zero_behavior(a, b):
    # GCD with zero should return the absolute value of the non-zero argument
    codeflash_output = gcd_recursive(a, b) # 2.75μs -> 2.00μs (37.6% faster)

@pytest.mark.parametrize("a,b", [
    (123, 456),
    (456, 123),
    (999, 1001),
    (1001, 999),
    (100, 10),
    (10, 100),
])
def test_gcd_commutativity(a, b):
    # GCD should be commutative: gcd(a, b) == gcd(b, a)
    codeflash_output = gcd_recursive(a, b) # 4.92μs -> 3.71μs (32.6% faster)

def test_gcd_recursive_depth():
    # Test deep recursion does not crash for reasonable inputs
    # (Python's default recursion limit is ~1000)
    a = 9876543210
    b = 123456789
    codeflash_output = gcd_recursive(a, b); result = codeflash_output # 875ns -> 625ns (40.0% faster)

def test_gcd_mutation_resistance():
    # If the implementation is mutated to use addition instead of modulo, this will fail
    codeflash_output = gcd_recursive(123, 456) # 1.00μs -> 750ns (33.3% faster)
    codeflash_output = gcd_recursive(456, 123) # 625ns -> 333ns (87.7% faster)
    codeflash_output = gcd_recursive(123, 0) # 167ns -> 125ns (33.6% faster)
    codeflash_output = gcd_recursive(0, 123) # 292ns -> 167ns (74.9% faster)
# 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.number_theory import gcd_recursive

# unit tests

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

def test_gcd_basic_positive_numbers():
    # Basic test: gcd of two coprime numbers
    codeflash_output = gcd_recursive(7, 13) # 875ns -> 542ns (61.4% faster)
    # Basic test: gcd where one divides the other
    codeflash_output = gcd_recursive(12, 36) # 334ns -> 209ns (59.8% faster)
    # Basic test: gcd of two equal numbers
    codeflash_output = gcd_recursive(15, 15) # 208ns -> 125ns (66.4% faster)
    # Basic test: gcd of two numbers with common divisor
    codeflash_output = gcd_recursive(24, 36) # 375ns -> 250ns (50.0% faster)
    # Basic test: gcd of zero and a positive number
    codeflash_output = gcd_recursive(0, 17) # 292ns -> 167ns (74.9% faster)
    codeflash_output = gcd_recursive(17, 0) # 167ns -> 125ns (33.6% faster)

def test_gcd_basic_negative_numbers():
    # Negative numbers: gcd should be positive
    codeflash_output = gcd_recursive(-24, 36) # 708ns -> 500ns (41.6% faster)
    codeflash_output = gcd_recursive(24, -36) # 542ns -> 333ns (62.8% faster)
    codeflash_output = gcd_recursive(-24, -36) # 583ns -> 333ns (75.1% faster)
    codeflash_output = gcd_recursive(-12, 0) # 208ns -> 125ns (66.4% faster)
    codeflash_output = gcd_recursive(0, -12) # 250ns -> 125ns (100% faster)

def test_gcd_basic_mixed_signs():
    # Mixed signs: gcd should be positive
    codeflash_output = gcd_recursive(-21, 14) # 750ns -> 500ns (50.0% faster)
    codeflash_output = gcd_recursive(21, -14) # 500ns -> 292ns (71.2% faster)

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

def test_gcd_edge_zero_zero():
    # Both numbers zero: mathematically undefined, but conventionally return 0
    codeflash_output = gcd_recursive(0, 0) # 375ns -> 292ns (28.4% faster)

def test_gcd_edge_one():
    # gcd with 1
    codeflash_output = gcd_recursive(1, 999) # 750ns -> 541ns (38.6% faster)
    codeflash_output = gcd_recursive(999, 1) # 333ns -> 167ns (99.4% faster)
    codeflash_output = gcd_recursive(-1, 999) # 500ns -> 333ns (50.2% faster)
    codeflash_output = gcd_recursive(999, -1) # 208ns -> 125ns (66.4% faster)

def test_gcd_edge_prime_numbers():
    # Two large primes
    codeflash_output = gcd_recursive(101, 103) # 750ns -> 500ns (50.0% faster)
    codeflash_output = gcd_recursive(101, 101) # 209ns -> 125ns (67.2% faster)

def test_gcd_edge_large_and_small():
    # Large number and small number
    codeflash_output = gcd_recursive(1_000_000, 2) # 583ns -> 458ns (27.3% faster)
    codeflash_output = gcd_recursive(2, 1_000_000) # 500ns -> 250ns (100% faster)

def test_gcd_edge_negative_and_zero():
    # Negative with zero
    codeflash_output = gcd_recursive(-100, 0) # 375ns -> 292ns (28.4% faster)
    codeflash_output = gcd_recursive(0, -100) # 417ns -> 333ns (25.2% faster)

def test_gcd_edge_min_int():
    # Test with minimum integer values
    codeflash_output = gcd_recursive(-2**31, 2**31) # 959ns -> 667ns (43.8% faster)

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

def test_gcd_large_numbers():
    # Large coprime numbers
    a = 999_983  # large prime
    b = 999_979  # another large prime
    codeflash_output = gcd_recursive(a, b) # 792ns -> 583ns (35.8% faster)

    # Large numbers with common divisor
    a = 1_000_000_000
    b = 500_000_000
    codeflash_output = gcd_recursive(a, b) # 334ns -> 208ns (60.6% faster)

    # Large numbers with GCD 10
    a = 10**9 + 10
    b = 10**9
    codeflash_output = gcd_recursive(a, b) # 333ns -> 250ns (33.2% faster)

def test_gcd_large_scale_sequential():
    # Test GCD of sequence of numbers with a common factor
    base = 123456
    for i in range(1, 1001):
        codeflash_output = gcd_recursive(base * i, base) # 180μs -> 124μs (44.8% faster)

def test_gcd_large_scale_coprimes():
    # Test GCD of sequence of coprime numbers
    for i in range(2, 1001):
        codeflash_output = gcd_recursive(i, i+1) # 268μs -> 168μs (59.6% faster)

def test_gcd_large_scale_zero():
    # Test GCD of zero with many numbers
    for i in range(-1000, 0):
        codeflash_output = gcd_recursive(0, i) # 177μs -> 123μs (43.9% faster)
        codeflash_output = gcd_recursive(i, 0)

def test_gcd_large_scale_negative():
    # Test GCD of negative numbers in a range
    for i in range(-1000, 0):
        for j in range(-1000, 0):
            # Only test a few to avoid excessive loops
            if abs(i) % abs(j) == 0 or abs(j) % abs(i) == 0:
                expected = min(abs(i), abs(j))
                codeflash_output = gcd_recursive(i, j)

# -----------------
# Mutation-sensitive Test Cases
# -----------------

def test_gcd_mutation_sensitivity():
    # Test that the order of arguments doesn't affect result
    for a, b in [(18, 24), (100, 25), (7, 13), (0, 15), (15, 0)]:
        codeflash_output = gcd_recursive(a, b) # 2.33μs -> 1.29μs (80.6% faster)
    # Test that function always returns non-negative result
    for a, b in [(-18, -24), (100, -25), (-7, 13), (0, -15), (-15, 0)]:
        codeflash_output = gcd_recursive(a, b) # 1.58μs -> 1.17μs (35.7% 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.number_theory import gcd_recursive

def test_gcd_recursive():
    gcd_recursive(21, -76)

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