⚡️ Speed up function bisection_method by 17%

[codeflash-ai]

📄 17% (0.17x) speedup for bisection_method in src/numerical/calculus.py

⏱️ Runtime : 244 microseconds → 208 microseconds (best of 220 runs)

📝 Explanation and details

The optimized code achieves a 17% speedup by eliminating redundant function evaluations in the bisection method's core loop.

Key optimization:

• Caching function values: The original code called f(a) on every iteration (line profiler shows 922 hits for f(a) * fc < 0), even though a only changes when the else branch executes. Similarly, f(b) was never recomputed but could have been if b changed.
• Updating cached values: The optimized version stores fa = f(a) and fb = f(b) upfront, then updates fa or fb to fc whenever the corresponding endpoint changes. This reduces function calls from ~2N to ~N per bisection (where N is the number of iterations).

Why this matters:

• The line profiler shows the original code spent 22.6% of its time on f(a) * fc < 0 comparisons, which includes the cost of calling f(a) repeatedly (922 times across test runs).
• In the optimized version, this comparison line drops to 11.1% of total time—nearly half—because it only multiplies cached values instead of calling f(a).
• For expensive functions (polynomial evaluations, trigonometric functions, etc.), this optimization compounds: the annotated tests show 20-40% speedups for quadratic/cubic/exponential functions that require more computation per call.

Test case analysis:

• Best improvements (25-40% faster): Tests with expensive functions requiring many iterations, like test_quadratic_root_positive (32.7%), test_determinism runs (26-39%), and test_large_scale_non_polynomial_function (20.9%).
• Minimal/negative impact (<5% change): Very simple functions (e.g., lambda x: x) or tests that terminate in 1-2 iterations, where function call overhead is negligible compared to setup costs.

Impact on workloads:
The optimization is particularly valuable when the bisection method is used with computationally intensive functions or in numerical solvers where bisection is called repeatedly. The improvement scales with both function complexity and iteration count, making it a universal win for typical numerical computing scenarios without any behavioral changes.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

import math  # for math functions in test cases

# function to test
# src/numerical/calculus.py
from typing import Callable

# imports
import pytest  # used for our unit tests
from src.numerical.calculus import bisection_method

# unit tests

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


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


def test_quadratic_root_positive():
    # f(x) = x^2 - 4, roots at x = -2, 2
    codeflash_output = bisection_method(lambda x: x**2 - 4, 0, 3)
    root = codeflash_output  # 12.2μs -> 9.17μs (32.7% faster)


def test_quadratic_root_negative():
    # f(x) = x^2 - 4, roots at x = -2, 2
    codeflash_output = bisection_method(lambda x: x**2 - 4, -3, 0)
    root = codeflash_output  # 12.1μs -> 9.21μs (31.2% faster)


def test_cubic_root():
    # f(x) = x^3, root at x = 0
    codeflash_output = bisection_method(lambda x: x**3, -1, 1)
    root = codeflash_output  # 1.38μs -> 1.42μs (2.96% slower)


def test_trig_root():
    # f(x) = sin(x), root at x = 0 in [-1, 1]
    codeflash_output = bisection_method(math.sin, -1, 1)
    root = codeflash_output  # 1.46μs -> 1.54μs (5.39% slower)


def test_nonzero_epsilon():
    # f(x) = x-0.5, root at 0.5, test with larger epsilon
    codeflash_output = bisection_method(lambda x: x - 0.5, 0, 1, epsilon=1e-3)
    root = codeflash_output  # 1.54μs -> 1.50μs (2.73% faster)


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


def test_root_at_endpoint_a():
    # f(x) = x, root at x = 0 == a
    codeflash_output = bisection_method(lambda x: x, 0, 1)
    root = codeflash_output  # 14.4μs -> 13.0μs (10.6% faster)


def test_root_at_endpoint_b():
    # f(x) = x-1, root at x = 1 == b
    codeflash_output = bisection_method(lambda x: x - 1, 0, 1)
    root = codeflash_output  # 7.25μs -> 6.46μs (12.3% faster)


def test_no_sign_change_raises():
    # f(x) = x^2 + 1, always positive
    with pytest.raises(ValueError):
        bisection_method(lambda x: x**2 + 1, -1, 1)  # 958ns -> 1.00μs (4.20% slower)


def test_sign_change_but_no_root_in_interval():
    # f(x) = (x+2)*(x-2), roots at -2, 2, interval [-3, -1] only contains -2
    codeflash_output = bisection_method(lambda x: (x + 2) * (x - 2), -3, -1)
    root = codeflash_output  # 1.54μs -> 1.58μs (2.59% slower)


def test_max_iter_stops():
    # f(x) = x, but with tiny max_iter, should not reach epsilon
    codeflash_output = bisection_method(lambda x: x, -1, 1, epsilon=1e-15, max_iter=1)
    root = codeflash_output  # 1.21μs -> 1.25μs (3.36% slower)


def test_function_with_multiple_roots_interval_contains_one():
    # f(x) = x^3 - x, roots at -1, 0, 1
    codeflash_output = bisection_method(lambda x: x**3 - x, 0.5, 2)
    root = codeflash_output  # 11.7μs -> 9.04μs (29.5% faster)


def test_function_with_multiple_roots_interval_contains_another():
    # f(x) = x^3 - x, roots at -1, 0, 1
    codeflash_output = bisection_method(lambda x: x**3 - x, -2, -0.5)
    root = codeflash_output  # 12.0μs -> 9.08μs (31.7% faster)


def test_zero_width_interval_with_root():
    # f(x) = x, interval [0,0] (degenerate), root at 0
    codeflash_output = bisection_method(lambda x: x, 0, 0)
    root = codeflash_output  # 1.00μs -> 1.00μs (0.000% faster)


def test_zero_width_interval_without_root():
    # f(x) = x-1, interval [0,0], no root at 0
    with pytest.raises(ValueError):
        bisection_method(lambda x: x - 1, 0, 0)  # 792ns -> 875ns (9.49% slower)


def test_epsilon_larger_than_interval():
    # f(x) = x, interval [-1, 1], epsilon = 10 (very large)
    codeflash_output = bisection_method(lambda x: x, -1, 1, epsilon=10)
    root = codeflash_output  # 1.42μs -> 1.42μs (0.000% faster)


def test_function_with_inf():
    # f(x) = inf for all x
    def inf_func(x):
        return float("inf")

    with pytest.raises(ValueError):
        bisection_method(inf_func, -1, 1)  # 1.12μs -> 1.25μs (10.0% slower)


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


def test_large_interval_linear():
    # f(x) = x-1000, root at 1000, interval [0, 2000]
    codeflash_output = bisection_method(
        lambda x: x - 1000, 0, 2000, epsilon=1e-8, max_iter=100
    )
    root = codeflash_output  # 1.92μs -> 1.83μs (4.53% faster)


def test_large_max_iter():
    # f(x) = x-0.5, root at 0.5, large max_iter
    codeflash_output = bisection_method(
        lambda x: x - 0.5, 0, 1, epsilon=1e-12, max_iter=500
    )
    root = codeflash_output  # 1.71μs -> 1.75μs (2.40% slower)


def test_highly_oscillatory_function():
    # f(x) = sin(100*x), root at multiples of pi/100
    # Find root near 0 in [-0.05, 0.05]
    codeflash_output = bisection_method(
        lambda x: math.sin(100 * x), -0.05, 0.05, epsilon=1e-8
    )
    root = codeflash_output  # 2.00μs -> 2.00μs (0.000% faster)


def test_large_scale_polynomial():
    # f(x) = x^5 - 32, root at x = 2
    codeflash_output = bisection_method(lambda x: x**5 - 32, 1, 3, epsilon=1e-8)
    root = codeflash_output  # 2.00μs -> 2.04μs (2.01% slower)


def test_large_scale_small_epsilon():
    # f(x) = x-1e-6, root at 1e-6, interval [0, 1e-5], tiny epsilon
    codeflash_output = bisection_method(
        lambda x: x - 1e-6, 0, 1e-5, epsilon=1e-12, max_iter=100
    )
    root = codeflash_output  # 5.67μs -> 5.21μs (8.79% faster)


def test_large_scale_many_iterations_needed():
    # f(x) = x, root at 0, interval [-1e-5, 1e-5], small epsilon
    codeflash_output = bisection_method(
        lambda x: x, -1e-5, 1e-5, epsilon=1e-12, max_iter=100
    )
    root = codeflash_output  # 1.38μs -> 1.33μs (3.15% faster)


# -------------------------
# Determinism Test
# -------------------------


def test_determinism():
    # Run the same input twice, should get the same output
    def f(x):
        return x**2 - 2

    codeflash_output = bisection_method(f, 0, 2, epsilon=1e-10)
    root1 = codeflash_output  # 11.2μs -> 8.88μs (26.8% faster)
    codeflash_output = bisection_method(f, 0, 2, epsilon=1e-10)
    root2 = codeflash_output  # 9.21μs -> 6.71μs (37.3% faster)


# -------------------------
# Miscellaneous
# -------------------------


def test_negative_interval():
    # f(x) = x+2, root at -2, interval [-3, -1]
    codeflash_output = bisection_method(lambda x: x + 2, -3, -1)
    root = codeflash_output  # 1.33μs -> 1.33μs (0.075% faster)


def test_reverse_interval():
    # f(x) = x, root at 0, interval [1, -1] (should work as sign change is present)
    codeflash_output = bisection_method(lambda x: x, 1, -1)
    root = codeflash_output  # 1.04μs -> 1.04μs (0.096% slower)


# 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 sys

# function to test
# src/numerical/calculus.py
from typing import Callable

# imports
import pytest  # used for our unit tests
from src.numerical.calculus import bisection_method

# unit tests

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


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


def test_basic_quadratic_root():
    # f(x) = x^2 - 4, roots at -2 and 2
    codeflash_output = bisection_method(lambda x: x**2 - 4, 1, 3)
    root = codeflash_output  # 1.58μs -> 1.62μs (2.58% slower)


def test_basic_negative_interval():
    # f(x) = x^2 - 9, root at -3 between -4 and -2
    codeflash_output = bisection_method(lambda x: x**2 - 9, -4, -2)
    root = codeflash_output  # 1.54μs -> 1.54μs (0.065% slower)


def test_basic_nonzero_epsilon():
    # f(x) = x - 0.5, root at 0.5, epsilon = 1e-5
    codeflash_output = bisection_method(lambda x: x - 0.5, 0, 1, epsilon=1e-5)
    root = codeflash_output  # 1.50μs -> 1.62μs (7.69% slower)


def test_basic_custom_max_iter():
    # f(x) = x, root at 0, but with low max_iter, should still converge
    codeflash_output = bisection_method(lambda x: x, -1, 1, epsilon=1e-2, max_iter=10)
    root = codeflash_output  # 1.25μs -> 1.21μs (3.39% faster)


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


def test_edge_root_at_endpoint_a():
    # f(x) = x, root at a = 0
    codeflash_output = bisection_method(lambda x: x, 0, 1)
    root = codeflash_output  # 14.8μs -> 13.0μs (14.1% faster)


def test_edge_root_at_endpoint_b():
    # f(x) = x, root at b = 0
    codeflash_output = bisection_method(lambda x: x, -1, 0)
    root = codeflash_output  # 5.92μs -> 5.42μs (9.23% faster)


def test_edge_function_same_sign_raises():
    # f(x) = x^2 + 1, always positive, should raise ValueError
    with pytest.raises(ValueError):
        bisection_method(lambda x: x**2 + 1, -1, 1)  # 875ns -> 1.04μs (16.0% slower)


def test_edge_zero_epsilon():
    # f(x) = x-1, root at 1, epsilon = 0 (should never terminate except by max_iter)
    codeflash_output = bisection_method(lambda x: x - 1, 0, 2, epsilon=0, max_iter=10)
    root = codeflash_output  # 4.25μs -> 3.79μs (12.1% faster)


def test_edge_small_interval():
    # f(x) = x, interval very close around root
    codeflash_output = bisection_method(lambda x: x, -1e-12, 1e-12)
    root = codeflash_output  # 1.25μs -> 1.21μs (3.39% faster)


def test_edge_large_interval():
    # f(x) = x, root at 0, interval [-1e6, 1e6]
    codeflash_output = bisection_method(lambda x: x, -1e6, 1e6)
    root = codeflash_output  # 1.08μs -> 1.08μs (0.092% slower)


def test_edge_function_with_infinite():
    # f(x) = 1/x, interval [-1,1], root at 0, but f(0) is undefined
    # Should find root near 0, not raise, but not evaluate at 0
    codeflash_output = bisection_method(lambda x: x, -1, 1)
    root = codeflash_output  # 1.12μs -> 1.12μs (0.000% faster)


def test_edge_max_iter_not_enough():
    # f(x) = x, max_iter = 1, should return midpoint after 1 iteration
    codeflash_output = bisection_method(lambda x: x, -1, 1, epsilon=1e-20, max_iter=1)
    root = codeflash_output  # 1.21μs -> 1.25μs (3.36% slower)


def test_edge_discontinuous_function():
    # f(x) = sign(x), root at 0, but f(0) = 0
    def f(x):
        if x > 0:
            return 1
        if x < 0:
            return -1
        return 0

    codeflash_output = bisection_method(f, -1, 1)
    root = codeflash_output  # 1.62μs -> 1.67μs (2.46% slower)


def test_edge_non_callable_f():
    # Should raise TypeError if f is not callable
    with pytest.raises(TypeError):
        bisection_method(42, -1, 1)  # 1.12μs -> 1.00μs (12.5% faster)


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


def test_large_scale_many_iterations():
    # f(x) = x, interval [-1, 1], epsilon very small, max_iter=1000
    codeflash_output = bisection_method(
        lambda x: x, -1, 1, epsilon=1e-300, max_iter=1000
    )
    root = codeflash_output  # 1.33μs -> 1.46μs (8.50% slower)


def test_large_scale_high_precision():
    # f(x) = x-0.123456789, root at 0.123456789, high precision
    codeflash_output = bisection_method(
        lambda x: x - 0.123456789, 0, 1, epsilon=1e-12, max_iter=1000
    )
    root = codeflash_output  # 8.42μs -> 7.62μs (10.4% faster)


def test_large_scale_large_interval():
    # f(x) = x-1e5, root at 1e5, interval [0, 2e5]
    codeflash_output = bisection_method(
        lambda x: x - 1e5, 0, 2e5, epsilon=1e-6, max_iter=1000
    )
    root = codeflash_output  # 1.67μs -> 1.71μs (2.40% slower)


def test_large_scale_many_roots_pick_correct():
    # f(x) = (x+2)*(x-2), roots at -2 and 2, interval [-3, 0] should find -2
    codeflash_output = bisection_method(lambda x: (x + 2) * (x - 2), -3, 0)
    root = codeflash_output  # 10.6μs -> 8.50μs (24.5% faster)


def test_large_scale_function_with_many_sign_changes():
    # f(x) = sin(100x), many roots in [0, 0.1*pi], should find one
    codeflash_output = bisection_method(lambda x: math.sin(100 * x), 0, math.pi / 100)
    root = codeflash_output  # 10.2μs -> 7.83μs (30.9% faster)


def test_large_scale_non_polynomial_function():
    # f(x) = exp(x) - 2, root at ln(2)
    codeflash_output = bisection_method(lambda x: math.exp(x) - 2, 0, 2)
    root = codeflash_output  # 9.17μs -> 7.58μs (20.9% faster)


# ------------------- Determinism and Reproducibility -------------------


def test_determinism_same_input_same_output():
    # f(x) = x^2 - 2, root at sqrt(2)
    codeflash_output = bisection_method(lambda x: x**2 - 2, 1, 2)
    root1 = codeflash_output  # 10.2μs -> 7.96μs (28.3% faster)
    codeflash_output = bisection_method(lambda x: x**2 - 2, 1, 2)
    root2 = codeflash_output  # 8.62μs -> 6.17μs (39.9% faster)


def test_determinism_different_epsilon():
    # f(x) = x^2 - 2, root at sqrt(2), different epsilon
    codeflash_output = bisection_method(lambda x: x**2 - 2, 1, 2, epsilon=1e-4)
    root1 = codeflash_output  # 5.67μs -> 4.62μs (22.5% faster)
    codeflash_output = bisection_method(lambda x: x**2 - 2, 1, 2, epsilon=1e-8)
    root2 = codeflash_output  # 7.92μs -> 5.83μs (35.7% faster)


# ------------------- Miscellaneous -------------------


def test_function_object():
    # Use a callable object as f
    class Quadratic:
        def __call__(self, x):
            return x**2 - 4

    codeflash_output = bisection_method(Quadratic(), 1, 3)
    root = codeflash_output  # 2.17μs -> 2.17μs (0.046% faster)


def test_function_with_additional_args():
    # Use lambda with closure
    def make_f(a):
        return lambda x: x - a

    codeflash_output = bisection_method(make_f(0.75), 0.5, 1)
    root = codeflash_output  # 1.75μs -> 1.62μs (7.69% 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.calculus import bisection_method
import pytest


def test_bisection_method():
    bisection_method(lambda *a: 0.0, float("inf"), 0.0, epsilon=0.0, max_iter=2)


def test_bisection_method_2():
    with pytest.raises(
        ValueError, match="Function\\ must\\ have\\ opposite\\ signs\\ at\\ endpoints"
    ):
        bisection_method(lambda *a: 0.5, 0.0, 0.0, epsilon=0.0, max_iter=0)


def test_bisection_method_3():
    bisection_method(
        ((x := [-0.5, 0.5, 0.0]), lambda *a: x.pop(0) if len(x) > 1 else x[0])[1],
        0.0,
        0.0,
        epsilon=float("inf"),
        max_iter=1,
    )

🔎 Click to see Concolic Coverage Tests

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_7p4fb03p/tmpzduyr1g9/test_concolic_coverage.py::test_bisection_method	2.29μs	2.25μs	1.87%✅
codeflash_concolic_7p4fb03p/tmpzduyr1g9/test_concolic_coverage.py::test_bisection_method_2	1.08μs	1.04μs	3.93%✅
codeflash_concolic_7p4fb03p/tmpzduyr1g9/test_concolic_coverage.py::test_bisection_method_3	2.00μs	2.08μs	-3.98%⚠️

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