⚡️ Speed up function monte_carlo_pi by 46%

[codeflash-ai]

📄 46% (0.46x) speedup for monte_carlo_pi in src/numerical/monte_carlo.py

⏱️ Runtime : 5.04 milliseconds → 3.45 milliseconds (best of 250 runs)

📝 Explanation and details

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

import math
import random

# imports
import pytest  # used for our unit tests
from src.numerical.monte_carlo import monte_carlo_pi

# unit tests

# --- Basic Test Cases ---


def test_monte_carlo_pi_typical_small_sample():
    """Test with a small number of samples to verify basic functionality."""
    codeflash_output = monte_carlo_pi(100)
    pi_estimate = codeflash_output  # 35.5μs -> 23.6μs (50.4% faster)


def test_monte_carlo_pi_typical_medium_sample():
    """Test with a medium number of samples for better accuracy."""
    codeflash_output = monte_carlo_pi(500)
    pi_estimate = codeflash_output  # 164μs -> 111μs (46.7% faster)


def test_monte_carlo_pi_typical_large_sample():
    """Test with a larger sample size for improved accuracy."""
    codeflash_output = monte_carlo_pi(1000)
    pi_estimate = codeflash_output  # 328μs -> 223μs (46.8% faster)


# --- Edge Test Cases ---


def test_monte_carlo_pi_one_sample():
    """Test with a single sample (edge case)."""
    codeflash_output = monte_carlo_pi(1)
    pi_estimate = codeflash_output  # 1.96μs -> 1.79μs (9.32% faster)


def test_monte_carlo_pi_zero_samples():
    """Test with zero samples (should raise ZeroDivisionError)."""
    with pytest.raises(ZeroDivisionError):
        monte_carlo_pi(0)  # 875ns -> 875ns (0.000% faster)


def test_monte_carlo_pi_negative_samples():
    """Test with a negative number of samples (should raise ValueError or return nonsense)."""
    # The function will run the loop zero times and return 0/negative, which is 0.0
    codeflash_output = monte_carlo_pi(-10)
    result = codeflash_output  # 667ns -> 709ns (5.92% slower)


def test_monte_carlo_pi_non_integer_samples():
    """Test with non-integer input (should raise TypeError)."""
    with pytest.raises(TypeError):
        monte_carlo_pi(3.14)  # 667ns -> 708ns (5.79% slower)


def test_monte_carlo_pi_extreme_randomness_seed():
    """Test determinism with a fixed random seed."""
    random.seed(42)
    codeflash_output = monte_carlo_pi(100)
    pi1 = codeflash_output  # 35.9μs -> 23.5μs (52.6% faster)
    random.seed(42)
    codeflash_output = monte_carlo_pi(100)
    pi2 = codeflash_output  # 33.0μs -> 22.0μs (49.9% faster)


def test_monte_carlo_pi_all_points_inside():
    """Test the case where all points are inside the circle (simulate)."""
    # Monkeypatch random.uniform to always return 0 (center)
    orig_uniform = random.uniform
    random.uniform = lambda a, b: 0
    codeflash_output = monte_carlo_pi(10)
    pi_estimate = codeflash_output  # 2.50μs -> 2.54μs (1.65% slower)
    random.uniform = orig_uniform  # restore


def test_monte_carlo_pi_all_points_outside():
    """Test the case where all points are outside the circle (simulate)."""
    # Monkeypatch random.uniform to always return 1 (edge, but outside for sum of squares)
    orig_uniform = random.uniform
    random.uniform = lambda a, b: 1
    codeflash_output = monte_carlo_pi(10)
    pi_estimate = codeflash_output  # 2.25μs -> 2.17μs (3.83% faster)
    random.uniform = orig_uniform  # restore


def test_monte_carlo_pi_boundary_points():
    """Test points exactly on the boundary (should count as inside)."""
    orig_uniform = random.uniform
    # Always return 1 for x, 0 for y (on the boundary)
    values = [1, 0] * 5

    def boundary_uniform(a, b):
        return values.pop(0)

    random.uniform = boundary_uniform
    codeflash_output = monte_carlo_pi(5)
    pi_estimate = codeflash_output  # 2.67μs -> 2.71μs (1.51% slower)
    random.uniform = orig_uniform


# --- Large Scale Test Cases ---


def test_monte_carlo_pi_large_sample():
    """Test with a large number of samples for robustness and scalability."""
    random.seed(12345)
    codeflash_output = monte_carlo_pi(1000)
    pi_estimate = codeflash_output  # 325μs -> 224μs (45.4% faster)


def test_monte_carlo_pi_performance():
    """Test that the function completes quickly for up to 1000 samples."""
    import time

    start = time.time()
    monte_carlo_pi(1000)  # 328μs -> 224μs (46.2% faster)
    elapsed = time.time() - start


def test_monte_carlo_pi_stability_multiple_runs():
    """Test stability: multiple runs with same seed and sample size yield same result."""
    random.seed(999)
    results = [monte_carlo_pi(1000) for _ in range(3)]  # 329μs -> 224μs (46.9% faster)


# --- Additional Robustness Tests ---


@pytest.mark.parametrize("num_samples", [2, 10, 50, 100, 500, 1000])
def test_monte_carlo_pi_monotonic_accuracy(num_samples):
    """Test that accuracy improves as sample size increases."""
    random.seed(2024)
    codeflash_output = monte_carlo_pi(num_samples)
    pi_estimate = codeflash_output  # 553μs -> 380μs (45.4% faster)


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import math
import random

# imports
import pytest
from src.numerical.monte_carlo import monte_carlo_pi

# unit tests

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


def test_small_sample_known_seed():
    """Test with a small number of samples and fixed random seed for determinism."""
    random.seed(42)
    codeflash_output = monte_carlo_pi(10)
    result = codeflash_output  # 5.71μs -> 4.25μs (34.3% faster)


def test_typical_sample_size():
    """Test with a typical sample size and fixed seed."""
    random.seed(123)
    codeflash_output = monte_carlo_pi(100)
    result = codeflash_output  # 35.5μs -> 22.8μs (55.5% faster)


def test_return_type():
    """Test that the function returns a float."""
    random.seed(1)
    codeflash_output = monte_carlo_pi(50)
    result = codeflash_output  # 18.9μs -> 12.8μs (47.6% faster)


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


def test_non_integer_samples():
    """Test that non-integer samples raises TypeError."""
    with pytest.raises(TypeError):
        monte_carlo_pi(3.5)  # 708ns -> 708ns (0.000% faster)


def test_string_samples():
    """Test that string input raises TypeError."""
    with pytest.raises(TypeError):
        monte_carlo_pi("100")  # 709ns -> 708ns (0.141% faster)


def test_one_sample():
    """Test with one sample, should return either 0.0 or 4.0."""
    random.seed(7)
    codeflash_output = monte_carlo_pi(1)
    result = codeflash_output  # 2.21μs -> 2.00μs (10.4% faster)


def test_extreme_seed():
    """Test with an extreme seed value to check determinism."""
    random.seed(999999)
    codeflash_output = monte_carlo_pi(10)
    result = codeflash_output  # 5.54μs -> 4.25μs (30.4% faster)


def test_maximum_float_int():
    """Test with maximum integer less than 1000 (edge of allowed size)."""
    random.seed(0)
    codeflash_output = monte_carlo_pi(999)
    result = codeflash_output  # 330μs -> 225μs (46.4% faster)


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


def test_large_sample_accuracy():
    """Test that the estimate gets closer to math.pi with a large number of samples."""
    random.seed(2024)
    codeflash_output = monte_carlo_pi(1000)
    result = codeflash_output  # 330μs -> 224μs (46.9% faster)


def test_large_sample_type_and_range():
    """Test type and range for large sample size."""
    random.seed(12345)
    codeflash_output = monte_carlo_pi(1000)
    result = codeflash_output  # 329μs -> 224μs (46.9% faster)


def test_large_sample_determinism():
    """Test that repeated calls with the same seed and sample size give the same result."""
    random.seed(555)
    codeflash_output = monte_carlo_pi(1000)
    result1 = codeflash_output  # 329μs -> 223μs (47.5% faster)
    random.seed(555)
    codeflash_output = monte_carlo_pi(1000)
    result2 = codeflash_output  # 325μs -> 222μs (46.3% faster)


def test_large_sample_variance():
    """Test that changing the seed changes the result for large sample size."""
    random.seed(111)
    codeflash_output = monte_carlo_pi(1000)
    result1 = codeflash_output  # 324μs -> 225μs (43.9% faster)
    random.seed(222)
    codeflash_output = monte_carlo_pi(1000)
    result2 = codeflash_output  # 320μs -> 222μs (44.2% faster)


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


@pytest.mark.parametrize("bad_input", [None, [], {}, (), set()])
def test_bad_types_raise_typeerror(bad_input):
    """Test that various bad types raise TypeError."""
    with pytest.raises(TypeError):
        monte_carlo_pi(bad_input)  # 3.12μs -> 3.58μs (12.8% slower)


def test_return_value_bounds():
    """Test that the return value is always between 0 and 4 for valid input."""
    random.seed(42)
    for n in [1, 10, 100, 500, 999]:
        codeflash_output = monte_carlo_pi(n)
        result = codeflash_output  # 526μs -> 360μs (46.0% 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.numerical.monte_carlo import monte_carlo_pi


def test_monte_carlo_pi():
    monte_carlo_pi(2)

🔎 Click to see Concolic Coverage Tests

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_p1tsg1eg/tmpun37s81y/test_concolic_coverage.py::test_monte_carlo_pi	2.08μs	1.75μs	19.0%✅

To edit these changes git checkout codeflash/optimize-monte_carlo_pi-mjhvtxz0 and push.