⚡️ Speed up function bisection_method by 21%

[codeflash-ai]

📄 21% (0.21x) speedup for bisection_method in src/numpy_pandas/numerical_methods.py

⏱️ Runtime : 193 microseconds → 159 microseconds (best of 210 runs)

📝 Explanation and details

The optimization eliminates redundant function evaluations by caching function values at the interval endpoints.

Key changes:

• Cached endpoint evaluations: Instead of calling f(a) repeatedly in the loop condition f(a) * fc < 0, the code now stores fa = f(a) and fb = f(b) initially and updates them when the interval changes (fa = fc or fb = fc).
• Reduced function calls: The original code called f(a) on every iteration (line showing 1021 hits with 244ms total time), while the optimized version uses the cached fa value, eliminating these repeated calls.

Why it's faster:
The bisection method repeatedly evaluates the function at interval endpoints to determine which half contains the root. Since the endpoint values don't change until the interval is updated, caching them avoids redundant computation. Function evaluation is often the bottleneck in numerical methods, especially for complex functions.

Performance characteristics:

• Best gains on functions requiring significant computation time (test cases with quadratic, polynomial, and trigonometric functions show 20-45% speedups)
• Minimal impact on very simple functions like linear equations (some tests show slight slowdowns due to variable assignment overhead)
• Most effective for test cases requiring many iterations, where the cumulative savings from avoided function calls compound

The 21% overall speedup comes from reducing the total function evaluations from ~2081 calls to ~1113 calls in typical usage patterns.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import math  # for test functions
# function to test
from typing import Callable

# imports
import pytest  # used for our unit tests
from src.numpy_pandas.numerical_methods import bisection_method

# unit tests

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

def test_basic_linear_root():
    # f(x) = x, root at x=0
    codeflash_output = bisection_method(lambda x: x, -1, 1); root = codeflash_output # 958ns -> 1.00μs (4.20% slower)

def test_basic_quadratic_root():
    # f(x) = x^2 - 4, roots at x = -2 and x = 2
    codeflash_output = bisection_method(lambda x: x**2 - 4, 0, 3); root = codeflash_output # 9.79μs -> 7.50μs (30.6% faster)

def test_basic_negative_interval():
    # f(x) = x^2 - 9, root at x = -3
    codeflash_output = bisection_method(lambda x: x**2 - 9, -5, 0); root = codeflash_output # 10.0μs -> 7.29μs (37.1% faster)

def test_basic_nonzero_epsilon():
    # f(x) = x - 1, root at x = 1, with larger epsilon
    codeflash_output = bisection_method(lambda x: x - 1, 0, 2, epsilon=1e-3); root = codeflash_output # 1.04μs -> 1.12μs (7.47% slower)

def test_basic_max_iter_limit():
    # f(x) = x, root at x=0, with low max_iter
    codeflash_output = bisection_method(lambda x: x, -1, 1, epsilon=1e-10, max_iter=1); root = codeflash_output # 875ns -> 917ns (4.58% slower)

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

def test_edge_no_sign_change():
    # f(x) = x^2 + 1, always positive, should raise ValueError
    with pytest.raises(ValueError):
        bisection_method(lambda x: x**2 + 1, -2, 2) # 792ns -> 834ns (5.04% slower)

def test_edge_root_at_endpoint_a():
    # f(x) = x - 2, root at x=2, interval [2, 5]
    codeflash_output = bisection_method(lambda x: x - 2, 2, 5); root = codeflash_output # 15.6μs -> 12.1μs (29.0% faster)

def test_edge_root_at_endpoint_b():
    # f(x) = x + 3, root at x=-3, interval [-5, -3]
    codeflash_output = bisection_method(lambda x: x + 3, -5, -3); root = codeflash_output # 6.50μs -> 5.12μs (26.8% faster)

def test_edge_interval_is_point():
    # f(x) = x, root at x=0, interval [0, 0]
    codeflash_output = bisection_method(lambda x: x, 0, 0); root = codeflash_output # 792ns -> 833ns (4.92% slower)

def test_edge_function_with_multiple_roots_in_interval():
    # f(x) = x^3 - x, roots at x=0, x=1, x=-1
    # Interval [-2, 2] contains all three roots, but bisection will find one
    codeflash_output = bisection_method(lambda x: x**3 - x, -2, 2); root = codeflash_output # 1.29μs -> 1.42μs (8.76% slower)

def test_edge_large_epsilon():
    # f(x) = x - 10, root at x=10, with huge epsilon
    codeflash_output = bisection_method(lambda x: x - 10, 5, 15, epsilon=1); root = codeflash_output # 1.25μs -> 1.21μs (3.39% faster)

def test_edge_small_max_iter():
    # f(x) = x - 1, root at x=1, with max_iter=2
    codeflash_output = bisection_method(lambda x: x - 1, 0, 2, max_iter=2); root = codeflash_output # 1.04μs -> 1.08μs (3.79% slower)



def test_edge_function_with_infinite():
    # f(x) returns inf at endpoint, should propagate error
    def f(x):
        if x == 0:
            return float('inf')
        return x
    with pytest.raises(ValueError):
        bisection_method(f, 0, 1) # 1.17μs -> 1.21μs (3.39% slower)

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

def test_large_scale_high_precision():
    # f(x) = x - 0.123456789, root at x=0.123456789, with very small epsilon
    codeflash_output = bisection_method(lambda x: x - 0.123456789, 0, 1, epsilon=1e-12, max_iter=1000); root = codeflash_output # 6.88μs -> 6.00μs (14.6% faster)

def test_large_scale_max_iter_1000():
    # f(x) = x - 0.5, root at x=0.5, max_iter=1000
    codeflash_output = bisection_method(lambda x: x - 0.5, 0, 1, epsilon=1e-15, max_iter=1000); root = codeflash_output # 1.17μs -> 1.17μs (0.000% faster)

def test_large_scale_on_long_interval():
    # f(x) = x - 100, root at x=100, interval [0, 200]
    codeflash_output = bisection_method(lambda x: x - 100, 0, 200, epsilon=1e-8); root = codeflash_output # 1.21μs -> 1.21μs (0.083% slower)

def test_large_scale_nonlinear_function():
    # f(x) = sin(x), root at x=0, interval [-1, 1]
    codeflash_output = bisection_method(math.sin, -1, 1, epsilon=1e-12); root = codeflash_output # 1.33μs -> 1.33μs (0.075% slower)

def test_large_scale_polynomial_degree_5():
    # f(x) = x^5 - 1, root at x=1, interval [0, 2]
    codeflash_output = bisection_method(lambda x: x**5 - 1, 0, 2, epsilon=1e-10); root = codeflash_output # 1.38μs -> 1.46μs (5.69% slower)

def test_large_scale_function_with_many_iterations():
    # f(x) = x^2 - 2, root at sqrt(2), interval [1, 2], max_iter=1000
    codeflash_output = bisection_method(lambda x: x**2 - 2, 1, 2, epsilon=1e-12, max_iter=1000); root = codeflash_output # 10.1μs -> 7.25μs (39.7% faster)

def test_large_scale_root_far_from_zero():
    # f(x) = x - 999, root at x=999, interval [900, 1000]
    codeflash_output = bisection_method(lambda x: x - 999, 900, 1000, epsilon=1e-8); root = codeflash_output # 6.67μs -> 5.29μs (26.0% faster)

def test_large_scale_extremely_small_interval():
    # f(x) = x - 0.0001, root at x=0.0001, interval [0.00009, 0.00011]
    codeflash_output = bisection_method(lambda x: x - 0.0001, 0.00009, 0.00011, epsilon=1e-12); root = codeflash_output # 1.08μs -> 1.12μs (3.73% slower)

def test_large_scale_extremely_large_interval():
    # f(x) = x - 1e6, root at x=1e6, interval [0, 2e6]
    codeflash_output = bisection_method(lambda x: x - 1e6, 0, 2e6, epsilon=1e-5); root = codeflash_output # 1.21μs -> 1.21μs (0.000% faster)


#------------------------------------------------
import math
import time
# function to test
# src/numpy_pandas/numerical_methods.py
from typing import Callable

# imports
import pytest
from src.numpy_pandas.numerical_methods import bisection_method

# unit tests

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

def test_linear_root():
    # f(x) = x, root at 0
    codeflash_output = bisection_method(lambda x: x, -1, 1); root = codeflash_output # 1.08μs -> 1.08μs (0.000% faster)

def test_quadratic_root():
    # f(x) = x^2 - 4, roots at -2 and 2
    codeflash_output = bisection_method(lambda x: x**2 - 4, 0, 3); root = codeflash_output # 9.50μs -> 7.21μs (31.8% faster)

def test_negative_interval():
    # f(x) = x^2 - 9, roots at -3 and 3, test negative interval
    codeflash_output = bisection_method(lambda x: x**2 - 9, -4, 0); root = codeflash_output # 1.79μs -> 1.79μs (0.000% faster)

def test_nonzero_epsilon():
    # f(x) = x - 0.5, root at 0.5, use a looser epsilon
    codeflash_output = bisection_method(lambda x: x - 0.5, 0, 1, epsilon=1e-4); root = codeflash_output # 1.25μs -> 1.29μs (3.25% slower)

def test_max_iter_exact():
    # f(x) = x, root at 0, set max_iter to 1 (should return midpoint)
    codeflash_output = bisection_method(lambda x: x, -1, 1, epsilon=0, max_iter=1); result = codeflash_output # 1.46μs -> 1.38μs (6.04% faster)

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

def test_no_sign_change_raises():
    # f(x) = x^2 + 1, always positive, should raise ValueError
    with pytest.raises(ValueError):
        bisection_method(lambda x: x**2 + 1, -1, 1) # 833ns -> 834ns (0.120% slower)

def test_root_at_endpoint_a():
    # f(x) = x, root at 0, interval [0, 1]
    codeflash_output = bisection_method(lambda x: x, 0, 1); root = codeflash_output # 12.6μs -> 10.9μs (15.3% faster)

def test_root_at_endpoint_b():
    # f(x) = x - 2, root at 2, interval [1, 2]
    codeflash_output = bisection_method(lambda x: x - 2, 1, 2); root = codeflash_output # 6.50μs -> 5.21μs (24.8% faster)


def test_small_interval():
    # f(x) = x, root at 0, interval [-1e-8, 1e-8]
    codeflash_output = bisection_method(lambda x: x, -1e-8, 1e-8); root = codeflash_output # 1.12μs -> 1.08μs (3.78% faster)

def test_large_interval():
    # f(x) = x - 1, root at 1, interval [-1e6, 1e6]
    codeflash_output = bisection_method(lambda x: x - 1, -1e6, 1e6); root = codeflash_output # 9.29μs -> 7.08μs (31.2% faster)

def test_max_iter_limit():
    # f(x) = x, root at 0, but set max_iter=2 so it can't converge
    codeflash_output = bisection_method(lambda x: x, -1, 1, epsilon=1e-20, max_iter=2); result = codeflash_output # 1.12μs -> 1.12μs (0.000% faster)

def test_non_monotonic_function():
    # f(x) = sin(x), root at 0, interval [-1, 1]
    codeflash_output = bisection_method(math.sin, -1, 1); root = codeflash_output # 1.21μs -> 1.33μs (9.38% slower)

def test_function_with_float_precision():
    # f(x) = x - 1e-12, root at 1e-12, interval [0, 1e-10]
    codeflash_output = bisection_method(lambda x: x - 1e-12, 0, 1e-10, epsilon=1e-20); root = codeflash_output # 5.62μs -> 4.79μs (17.4% faster)


def test_opposite_signs_but_no_root():
    # f(x) = 1/x, interval [-1, 1], opposite signs, but discontinuous at 0
    # Should not raise, but may return 0 (division by zero), so catch ZeroDivisionError
    with pytest.raises(ZeroDivisionError):
        bisection_method(lambda x: 1/x, -1, 1) # 1.50μs -> 1.46μs (2.81% faster)


def test_function_returns_inf():
    # f(x) = inf for all x, should raise ValueError since sign check fails
    def f(x): return float('inf')
    with pytest.raises(ValueError):
        bisection_method(f, -1, 1) # 1.12μs -> 1.17μs (3.52% slower)

def test_function_with_discontinuity_inside_interval():
    # f(x) = 1/(x-0.5), discontinuity at x=0.5, interval [0, 1]
    # Should find root at x=0, but may raise ZeroDivisionError if midpoint hits 0.5
    with pytest.raises(ZeroDivisionError):
        bisection_method(lambda x: 1/(x-0.5), 0, 1, epsilon=1e-16, max_iter=100) # 1.83μs -> 1.96μs (6.38% slower)

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

def test_large_max_iter_and_small_epsilon():
    # f(x) = x - 1e-5, root at 1e-5, interval [0, 1], small epsilon, large max_iter
    codeflash_output = bisection_method(lambda x: x - 1e-5, 0, 1, epsilon=1e-12, max_iter=1000); root = codeflash_output # 6.92μs -> 5.75μs (20.3% faster)

def test_large_interval_and_high_precision():
    # f(x) = x - 123456.789, root at 123456.789, interval [0, 1e6], small epsilon
    codeflash_output = bisection_method(lambda x: x - 123456.789, 0, 1e6, epsilon=1e-8, max_iter=1000); root = codeflash_output # 7.04μs -> 6.08μs (15.7% faster)

def test_performance_large_max_iter():
    # f(x) = x - 0.5, root at 0.5, run with max_iter=1000
    start = time.time()
    codeflash_output = bisection_method(lambda x: x - 0.5, 0, 1, epsilon=1e-15, max_iter=1000); root = codeflash_output # 1.08μs -> 1.17μs (7.12% slower)
    duration = time.time() - start

def test_many_small_roots():
    # f(x) = sin(1000x), roots at multiples of pi/1000, interval [0, 0.01]
    # There are many roots, but should find the first one at x=0
    codeflash_output = bisection_method(lambda x: math.sin(1000*x), 0, 0.0035); root = codeflash_output # 7.96μs -> 6.29μs (26.5% faster)

def test_highly_oscillatory_function():
    # f(x) = sin(500x), interval [0, 0.01], first root at x=0
    codeflash_output = bisection_method(lambda x: math.sin(500*x), 0, 0.001); root = codeflash_output # 18.9μs -> 13.0μs (45.2% faster)

def test_large_scale_precision():
    # f(x) = x - 1e-8, root at 1e-8, interval [0, 0.1], very small epsilon
    codeflash_output = bisection_method(lambda x: x - 1e-8, 0, 0.1, epsilon=1e-14, max_iter=1000); root = codeflash_output # 7.00μs -> 5.79μs (20.9% 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.numpy_pandas.numerical_methods import bisection_method
import pytest

def test_bisection_method():
    bisection_method(((x := [0.0, 0.0, 0.0]), lambda *a: x.pop(0) if len(x) > 1 else x[0])[1], 0.0, 0.0, epsilon=0.0, max_iter=1)

def test_bisection_method_2():
    bisection_method(lambda *a: 0.0, 0.0, 0.0, epsilon=0.5, max_iter=1)

def test_bisection_method_3():
    with pytest.raises(ValueError, match='Function\\ must\\ have\\ opposite\\ signs\\ at\\ endpoints'):
        bisection_method(lambda *a: 2.0, float('inf'), 0.0, epsilon=0.0, max_iter=0)

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_9qsp1j7r/tmpmhlhcs3x/test_concolic_coverage.py::test_bisection_method	1.83μs	1.67μs	10.0%✅
codeflash_concolic_9qsp1j7r/tmpmhlhcs3x/test_concolic_coverage.py::test_bisection_method_2	1.04μs	1.08μs	-3.87%⚠️
codeflash_concolic_9qsp1j7r/tmpmhlhcs3x/test_concolic_coverage.py::test_bisection_method_3	875ns	916ns	-4.48%⚠️

To edit these changes git checkout codeflash/optimize-bisection_method-mh16zt7y and push.